php-internal-docs 8.4.8
Unofficial docs for php/php-src
Loading...
Searching...
No Matches
zend_vm_execute.h
Go to the documentation of this file.
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
31static 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
290static 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#define SPEC_START_MASK 0x0000ffff
310#define SPEC_EXTRA_MASK 0xfffc0000
311#define SPEC_RULE_OP1 0x00010000
312#define SPEC_RULE_OP2 0x00020000
313#define SPEC_RULE_OP_DATA 0x00040000
314#define SPEC_RULE_RETVAL 0x00080000
315#define SPEC_RULE_QUICK_ARG 0x00100000
316#define SPEC_RULE_SMART_BRANCH 0x00200000
317#define SPEC_RULE_COMMUTATIVE 0x00800000
318#define SPEC_RULE_ISSET 0x01000000
319#define SPEC_RULE_OBSERVER 0x02000000
320
321static const uint32_t *zend_spec_handlers;
322static const void * const *zend_opcode_handlers;
323static int zend_handlers_count;
324#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
325static const void * const * zend_opcode_handler_funcs;
326static zend_op hybrid_halt_op;
327#endif
328#if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC
329static const void *zend_vm_get_opcode_handler(uint8_t opcode, const zend_op* op);
330#endif
331
332#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
333static const void *zend_vm_get_opcode_handler_func(uint8_t opcode, const zend_op* op);
334#else
335# define zend_vm_get_opcode_handler_func zend_vm_get_opcode_handler
336#endif
337
338#ifndef VM_TRACE
339# define VM_TRACE(op)
340#endif
341#ifndef VM_TRACE_OP_END
342# define VM_TRACE_OP_END(op)
343#endif
344#ifndef VM_TRACE_START
345# define VM_TRACE_START()
346#endif
347#ifndef VM_TRACE_END
348# define VM_TRACE_END()
349#endif
350#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
351# if defined(__GNUC__) && defined(__i386__)
352# define HYBRID_JIT_GUARD() __asm__ __volatile__ (""::: "ebx")
353# elif defined(__GNUC__) && defined(__x86_64__)
354# define HYBRID_JIT_GUARD() __asm__ __volatile__ (""::: "rbx","r12","r13")
355# elif defined(__GNUC__) && defined(__aarch64__)
356# define HYBRID_JIT_GUARD() __asm__ __volatile__ (""::: "x19","x20","x21","x22","x23","x24","x25","x26")
357# else
358# define HYBRID_JIT_GUARD()
359# endif
360#define HYBRID_NEXT() HYBRID_JIT_GUARD(); goto *(void**)(OPLINE->handler)
361#define HYBRID_SWITCH() HYBRID_NEXT();
362#define HYBRID_CASE(op) op ## _LABEL
363#define HYBRID_BREAK() HYBRID_NEXT()
364#define HYBRID_DEFAULT ZEND_NULL_LABEL
365#endif
366
367#ifdef ZEND_VM_FP_GLOBAL_REG
368# define ZEND_OPCODE_HANDLER_ARGS void
369# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU
370# define ZEND_OPCODE_HANDLER_ARGS_DC
371# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC
372#else
373# define ZEND_OPCODE_HANDLER_ARGS zend_execute_data *execute_data
374# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU execute_data
375# define ZEND_OPCODE_HANDLER_ARGS_DC , ZEND_OPCODE_HANDLER_ARGS
376# define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC , ZEND_OPCODE_HANDLER_ARGS_PASSTHRU
377#endif
378
379#if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
380# define ZEND_OPCODE_HANDLER_RET void
381# define ZEND_VM_TAIL_CALL(call) call; return
382# ifdef ZEND_VM_TAIL_CALL_DISPATCH
383# define ZEND_VM_CONTINUE() ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); return
384# else
385# define ZEND_VM_CONTINUE() return
386# endif
387# if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
388# define ZEND_VM_RETURN() opline = &hybrid_halt_op; return
389# define ZEND_VM_HOT zend_always_inline ZEND_COLD ZEND_OPT_SIZE
390# define ZEND_VM_COLD ZEND_COLD ZEND_OPT_SIZE
391# else
392# define ZEND_VM_RETURN() opline = NULL; return
393# define ZEND_VM_HOT
394# define ZEND_VM_COLD ZEND_COLD ZEND_OPT_SIZE
395# endif
396#else
397# define ZEND_OPCODE_HANDLER_RET int
398# define ZEND_VM_TAIL_CALL(call) return call
399# define ZEND_VM_CONTINUE() return 0
400# define ZEND_VM_RETURN() return -1
401# define ZEND_VM_HOT
402# define ZEND_VM_COLD ZEND_COLD ZEND_OPT_SIZE
403#endif
404
405typedef ZEND_OPCODE_HANDLER_RET (ZEND_FASTCALL *opcode_handler_t) (ZEND_OPCODE_HANDLER_ARGS);
406
407#define DCL_OPLINE
408#ifdef ZEND_VM_IP_GLOBAL_REG
409# define OPLINE opline
410# define USE_OPLINE
411# define LOAD_OPLINE() opline = EX(opline)
412# define LOAD_OPLINE_EX()
413# define LOAD_NEXT_OPLINE() opline = EX(opline) + 1
414# define SAVE_OPLINE() EX(opline) = opline
415# define SAVE_OPLINE_EX() SAVE_OPLINE()
416#else
417# define OPLINE EX(opline)
418# define USE_OPLINE const zend_op *opline = EX(opline);
419# define LOAD_OPLINE()
420# define LOAD_OPLINE_EX()
421# define LOAD_NEXT_OPLINE() ZEND_VM_INC_OPCODE()
422# define SAVE_OPLINE()
423# define SAVE_OPLINE_EX()
424#endif
425#define HANDLE_EXCEPTION() ZEND_ASSERT(EG(exception)); LOAD_OPLINE(); ZEND_VM_CONTINUE()
426#define HANDLE_EXCEPTION_LEAVE() ZEND_ASSERT(EG(exception)); LOAD_OPLINE(); ZEND_VM_LEAVE()
427#if defined(ZEND_VM_FP_GLOBAL_REG)
428# define ZEND_VM_ENTER_EX() ZEND_VM_INTERRUPT_CHECK(); ZEND_VM_CONTINUE()
429# define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_ENTER_EX()
430# define ZEND_VM_LEAVE() ZEND_VM_CONTINUE()
431#elif defined(ZEND_VM_IP_GLOBAL_REG)
432# define ZEND_VM_ENTER_EX() return 1
433# define ZEND_VM_ENTER() opline = EG(current_execute_data)->opline; ZEND_VM_ENTER_EX()
434# define ZEND_VM_LEAVE() return 2
435#else
436# define ZEND_VM_ENTER_EX() return 1
437# define ZEND_VM_ENTER() return 1
438# define ZEND_VM_LEAVE() return 2
439#endif
440#define ZEND_VM_INTERRUPT() ZEND_VM_TAIL_CALL(zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
441#define ZEND_VM_LOOP_INTERRUPT() zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
442#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));
443
444static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS);
445static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS);
446
447static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_add_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
448{
449 USE_OPLINE
450
451 SAVE_OPLINE();
452 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
453 op_1 = ZVAL_UNDEFINED_OP1();
454 }
455 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
456 op_2 = ZVAL_UNDEFINED_OP2();
457 }
458 add_function(EX_VAR(opline->result.var), op_1, op_2);
459 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
460 zval_ptr_dtor_nogc(op_1);
461 }
462 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
463 zval_ptr_dtor_nogc(op_2);
464 }
465 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
466}
467
468static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_sub_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
469{
470 USE_OPLINE
471
472 SAVE_OPLINE();
473 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
474 op_1 = ZVAL_UNDEFINED_OP1();
475 }
476 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
477 op_2 = ZVAL_UNDEFINED_OP2();
478 }
479 sub_function(EX_VAR(opline->result.var), op_1, op_2);
480 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
481 zval_ptr_dtor_nogc(op_1);
482 }
483 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
484 zval_ptr_dtor_nogc(op_2);
485 }
486 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
487}
488
489static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mul_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
490{
491 USE_OPLINE
492
493 SAVE_OPLINE();
494 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
495 op_1 = ZVAL_UNDEFINED_OP1();
496 }
497 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
498 op_2 = ZVAL_UNDEFINED_OP2();
499 }
500 mul_function(EX_VAR(opline->result.var), op_1, op_2);
501 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
502 zval_ptr_dtor_nogc(op_1);
503 }
504 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
505 zval_ptr_dtor_nogc(op_2);
506 }
507 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
508}
509
510static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
511{
512 USE_OPLINE
513
514 SAVE_OPLINE();
515 zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero");
516 ZVAL_UNDEF(EX_VAR(opline->result.var));
517 HANDLE_EXCEPTION();
518}
519
520static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_mod_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
521{
522 USE_OPLINE
523
524 SAVE_OPLINE();
525 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
526 op_1 = ZVAL_UNDEFINED_OP1();
527 }
528 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
529 op_2 = ZVAL_UNDEFINED_OP2();
530 }
531 mod_function(EX_VAR(opline->result.var), op_1, op_2);
532 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
533 zval_ptr_dtor_nogc(op_1);
534 }
535 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
536 zval_ptr_dtor_nogc(op_2);
537 }
538 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
539}
540
541static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_left_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
542{
543 USE_OPLINE
544
545 SAVE_OPLINE();
546 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
547 op_1 = ZVAL_UNDEFINED_OP1();
548 }
549 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
550 op_2 = ZVAL_UNDEFINED_OP2();
551 }
552 shift_left_function(EX_VAR(opline->result.var), op_1, op_2);
553 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
554 zval_ptr_dtor_nogc(op_1);
555 }
556 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
557 zval_ptr_dtor_nogc(op_2);
558 }
559 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
560}
561
562static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_shift_right_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
563{
564 USE_OPLINE
565
566 SAVE_OPLINE();
567 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
568 op_1 = ZVAL_UNDEFINED_OP1();
569 }
570 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
571 op_2 = ZVAL_UNDEFINED_OP2();
572 }
573 shift_right_function(EX_VAR(opline->result.var), op_1, op_2);
574 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
575 zval_ptr_dtor_nogc(op_1);
576 }
577 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
578 zval_ptr_dtor_nogc(op_2);
579 }
580 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
581}
582
583static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
584{
585 int ret;
586 USE_OPLINE
587
588 SAVE_OPLINE();
589 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
590 op_1 = ZVAL_UNDEFINED_OP1();
591 }
592 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
593 op_2 = ZVAL_UNDEFINED_OP2();
594 }
595 ret = zend_compare(op_1, op_2);
596 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
597 zval_ptr_dtor_nogc(op_1);
598 }
599 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
600 zval_ptr_dtor_nogc(op_2);
601 }
602 ZEND_VM_SMART_BRANCH(ret == 0, 1);
603}
604
605static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_not_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
606{
607 int ret;
608 USE_OPLINE
609
610 SAVE_OPLINE();
611 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
612 op_1 = ZVAL_UNDEFINED_OP1();
613 }
614 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
615 op_2 = ZVAL_UNDEFINED_OP2();
616 }
617 ret = zend_compare(op_1, op_2);
618 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
619 zval_ptr_dtor_nogc(op_1);
620 }
621 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
622 zval_ptr_dtor_nogc(op_2);
623 }
624 ZEND_VM_SMART_BRANCH(ret != 0, 1);
625}
626
627static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
628{
629 int ret;
630 USE_OPLINE
631
632 SAVE_OPLINE();
633 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
634 op_1 = ZVAL_UNDEFINED_OP1();
635 }
636 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
637 op_2 = ZVAL_UNDEFINED_OP2();
638 }
639 ret = zend_compare(op_1, op_2);
640 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
641 zval_ptr_dtor_nogc(op_1);
642 }
643 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
644 zval_ptr_dtor_nogc(op_2);
645 }
646 ZEND_VM_SMART_BRANCH(ret < 0, 1);
647}
648
649static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_is_smaller_or_equal_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
650{
651 int ret;
652 USE_OPLINE
653
654 SAVE_OPLINE();
655 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
656 op_1 = ZVAL_UNDEFINED_OP1();
657 }
658 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
659 op_2 = ZVAL_UNDEFINED_OP2();
660 }
661 ret = zend_compare(op_1, op_2);
662 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
663 zval_ptr_dtor_nogc(op_1);
664 }
665 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
666 zval_ptr_dtor_nogc(op_2);
667 }
668 ZEND_VM_SMART_BRANCH(ret <= 0, 1);
669}
670
671static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_or_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
672{
673 USE_OPLINE
674
675 SAVE_OPLINE();
676 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
677 op_1 = ZVAL_UNDEFINED_OP1();
678 }
679 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
680 op_2 = ZVAL_UNDEFINED_OP2();
681 }
682 bitwise_or_function(EX_VAR(opline->result.var), op_1, op_2);
683 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
684 zval_ptr_dtor_nogc(op_1);
685 }
686 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
687 zval_ptr_dtor_nogc(op_2);
688 }
689 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
690}
691
692static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_and_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
693{
694 USE_OPLINE
695
696 SAVE_OPLINE();
697 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
698 op_1 = ZVAL_UNDEFINED_OP1();
699 }
700 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
701 op_2 = ZVAL_UNDEFINED_OP2();
702 }
703 bitwise_and_function(EX_VAR(opline->result.var), op_1, op_2);
704 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
705 zval_ptr_dtor_nogc(op_1);
706 }
707 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
708 zval_ptr_dtor_nogc(op_2);
709 }
710 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
711}
712
713static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_xor_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
714{
715 USE_OPLINE
716
717 SAVE_OPLINE();
718 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
719 op_1 = ZVAL_UNDEFINED_OP1();
720 }
721 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
722 op_2 = ZVAL_UNDEFINED_OP2();
723 }
724 bitwise_xor_function(EX_VAR(opline->result.var), op_1, op_2);
725 if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
726 zval_ptr_dtor_nogc(op_1);
727 }
728 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
729 zval_ptr_dtor_nogc(op_2);
730 }
731 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
732}
733
734static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_bw_not_helper_SPEC(zval *op_1 ZEND_OPCODE_HANDLER_ARGS_DC)
735{
736 USE_OPLINE
737
738 SAVE_OPLINE();
739 if (UNEXPECTED(Z_TYPE_P(op_1) == IS_UNDEF)) {
740 op_1 = ZVAL_UNDEFINED_OP1();
741 }
742 bitwise_not_function(EX_VAR(opline->result.var), op_1);
743 FREE_OP(opline->op1_type, opline->op1.var);
744 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
745}
746
747static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
748{
749 USE_OPLINE
750
751 SAVE_OPLINE();
752 zend_throw_error(NULL, "Using $this when not in object context");
753 UNDEF_RESULT();
754 HANDLE_EXCEPTION();
755}
756
757static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
758{
759 USE_OPLINE
760 zval *function_name;
761
762 SAVE_OPLINE();
763 function_name = RT_CONSTANT(opline, opline->op2);
764 zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name));
765 HANDLE_EXCEPTION();
766}
767
768static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
769{
770 /* 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 */
771
772 USE_OPLINE
773 zval *prop, *value;
774 zend_property_info *prop_info;
775 zend_reference *ref;
776
777 SAVE_OPLINE();
778
779 if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
780 UNDEF_RESULT();
781 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
782 HANDLE_EXCEPTION();
783 }
784
785 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
786
787 do {
788 if (UNEXPECTED(Z_ISREF_P(prop))) {
789 ref = Z_REF_P(prop);
790 prop = Z_REFVAL_P(prop);
791 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
792 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
793 break;
794 }
795 }
796
797 if (ZEND_TYPE_IS_SET(prop_info->type)) {
798 /* special case for typed properties */
799 zend_binary_assign_op_typed_prop(prop_info, prop, value OPLINE_CC EXECUTE_DATA_CC);
800 } else {
801 zend_binary_op(prop, prop, value OPLINE_CC);
802 }
803 } while (0);
804
805 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
806 ZVAL_COPY(EX_VAR(opline->result.var), prop);
807 }
808
809 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
810 /* assign_static_prop has two opcodes! */
811 ZEND_VM_NEXT_OPCODE_EX(1, 2);
812}
813
814static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
815{
816 USE_OPLINE
817 zval *prop;
818 zend_property_info *prop_info;
819
820 SAVE_OPLINE();
821
822 if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
823 UNDEF_RESULT();
824 HANDLE_EXCEPTION();
825 }
826
827 zend_pre_incdec_property_zval(prop,
828 ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC);
829
830 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
831}
832
833/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
834static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
835{
836 USE_OPLINE
837 zval *prop;
838 zend_property_info *prop_info;
839
840 SAVE_OPLINE();
841
842 if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
843 UNDEF_RESULT();
844 HANDLE_EXCEPTION();
845 }
846
847 zend_post_incdec_property_zval(prop,
848 ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC);
849
850 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
851}
852
853/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
854static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC(int type ZEND_OPCODE_HANDLER_ARGS_DC)
855{
856 USE_OPLINE
857 zval *prop;
858
859 SAVE_OPLINE();
860
861 if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
862 ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS));
863 prop = &EG(uninitialized_zval);
864 }
865
866 if (type == BP_VAR_R || type == BP_VAR_IS) {
867 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
868 } else {
869 ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
870 }
871 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
872}
873
874/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
875static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
876{
877 ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
878}
879
880/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
881static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
882{
883 ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
884}
885
886/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
887static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
888{
889 ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
890}
891
892/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
893static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
894{
895 int fetch_type =
896 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
897 BP_VAR_W : BP_VAR_R;
898 ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
899}
900
901/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
902static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
903{
904 ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
905}
906
907/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
908static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
909{
910 ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
911}
912
913static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
914{
915 USE_OPLINE
916
917 SAVE_OPLINE();
918 zend_throw_error(NULL, "Cannot use temporary expression in write context");
919 FREE_OP(opline->op2_type, opline->op2.var);
920 FREE_OP(opline->op1_type, opline->op1.var);
921 ZVAL_UNDEF(EX_VAR(opline->result.var));
922 HANDLE_EXCEPTION();
923}
924
925static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
926{
927 USE_OPLINE
928
929 SAVE_OPLINE();
930 zend_throw_error(NULL, "Cannot use [] for reading");
931 FREE_OP(opline->op2_type, opline->op2.var);
932 FREE_OP(opline->op1_type, opline->op1.var);
933 ZVAL_UNDEF(EX_VAR(opline->result.var));
934 HANDLE_EXCEPTION();
935}
936
937static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
938{
939 USE_OPLINE
940 zval *prop, *value;
941 zend_property_info *prop_info;
942 zend_refcounted *garbage = NULL;
943
944 SAVE_OPLINE();
945
946 if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
947
948 UNDEF_RESULT();
949 HANDLE_EXCEPTION();
950 }
951
952 value = RT_CONSTANT((opline+1), (opline+1)->op1);
953
954 if (ZEND_TYPE_IS_SET(prop_info->type)) {
955 value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
956
957 } else {
958 value = zend_assign_to_variable_ex(prop, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
959 }
960
961 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
962 ZVAL_COPY(EX_VAR(opline->result.var), value);
963 }
964
965 if (garbage) {
966 GC_DTOR_NO_REF(garbage);
967 }
968
969 /* assign_static_prop has two opcodes! */
970 ZEND_VM_NEXT_OPCODE_EX(1, 2);
971}
972
973static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
974{
975 USE_OPLINE
976 zval *prop, *value;
977 zend_property_info *prop_info;
978 zend_refcounted *garbage = NULL;
979
980 SAVE_OPLINE();
981
982 if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
983 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
984 UNDEF_RESULT();
985 HANDLE_EXCEPTION();
986 }
987
988 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
989
990 if (ZEND_TYPE_IS_SET(prop_info->type)) {
991 value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
992 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
993 } else {
994 value = zend_assign_to_variable_ex(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
995 }
996
997 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
998 ZVAL_COPY(EX_VAR(opline->result.var), value);
999 }
1000
1001 if (garbage) {
1002 GC_DTOR_NO_REF(garbage);
1003 }
1004
1005 /* assign_static_prop has two opcodes! */
1006 ZEND_VM_NEXT_OPCODE_EX(1, 2);
1007}
1008
1009static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1010{
1011 USE_OPLINE
1012 zval *prop, *value;
1013 zend_property_info *prop_info;
1014 zend_refcounted *garbage = NULL;
1015
1016 SAVE_OPLINE();
1017
1018 if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
1019 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
1020 UNDEF_RESULT();
1021 HANDLE_EXCEPTION();
1022 }
1023
1024 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
1025
1026 if (ZEND_TYPE_IS_SET(prop_info->type)) {
1027 value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
1028 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
1029 } else {
1030 value = zend_assign_to_variable_ex(prop, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
1031 }
1032
1033 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1034 ZVAL_COPY(EX_VAR(opline->result.var), value);
1035 }
1036
1037 if (garbage) {
1038 GC_DTOR_NO_REF(garbage);
1039 }
1040
1041 /* assign_static_prop has two opcodes! */
1042 ZEND_VM_NEXT_OPCODE_EX(1, 2);
1043}
1044
1045static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1046{
1047 USE_OPLINE
1048 zval *prop, *value;
1049 zend_property_info *prop_info;
1050 zend_refcounted *garbage = NULL;
1051
1052 SAVE_OPLINE();
1053
1054 if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
1055
1056 UNDEF_RESULT();
1057 HANDLE_EXCEPTION();
1058 }
1059
1060 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
1061
1062 if (ZEND_TYPE_IS_SET(prop_info->type)) {
1063 value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC);
1064
1065 } else {
1066 value = zend_assign_to_variable_ex(prop, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
1067 }
1068
1069 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1070 ZVAL_COPY(EX_VAR(opline->result.var), value);
1071 }
1072
1073 if (garbage) {
1074 GC_DTOR_NO_REF(garbage);
1075 }
1076
1077 /* assign_static_prop has two opcodes! */
1078 ZEND_VM_NEXT_OPCODE_EX(1, 2);
1079}
1080
1081static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1082{
1083 USE_OPLINE
1084 zval *prop, *value_ptr;
1085 zend_property_info *prop_info;
1086 zend_refcounted *garbage = NULL;
1087
1088 SAVE_OPLINE();
1089
1090 if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
1091 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
1092 UNDEF_RESULT();
1093 HANDLE_EXCEPTION();
1094 }
1095
1096 value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, BP_VAR_W);
1097
1098 if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
1099 if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC))) {
1100 prop = &EG(uninitialized_zval);
1101 }
1102 } else if (ZEND_TYPE_IS_SET(prop_info->type)) {
1103 prop = zend_assign_to_typed_property_reference(prop_info, prop, value_ptr, &garbage EXECUTE_DATA_CC);
1104 } else {
1105 zend_assign_to_variable_reference(prop, value_ptr, &garbage);
1106 }
1107
1108 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
1109 ZVAL_COPY(EX_VAR(opline->result.var), prop);
1110 }
1111
1112 if (garbage) {
1113 GC_DTOR(garbage);
1114 }
1115
1116 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
1117 ZEND_VM_NEXT_OPCODE_EX(1, 2);
1118}
1119
1120static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
1121{
1122 zend_execute_data *old_execute_data;
1123 uint32_t call_info = EX_CALL_INFO();
1124 SAVE_OPLINE();
1125
1126 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)) {
1127 EG(current_execute_data) = EX(prev_execute_data);
1128 i_free_compiled_variables(execute_data);
1129
1130#ifdef ZEND_PREFER_RELOAD
1131 call_info = EX_CALL_INFO();
1132#endif
1133 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
1134 OBJ_RELEASE(Z_OBJ(execute_data->This));
1135 } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
1136 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
1137 }
1138 EG(vm_stack_top) = (zval*)execute_data;
1139 execute_data = EX(prev_execute_data);
1140
1141 if (UNEXPECTED(EG(exception) != NULL)) {
1142 zend_rethrow_exception(execute_data);
1143 HANDLE_EXCEPTION_LEAVE();
1144 }
1145
1146 LOAD_NEXT_OPLINE();
1147 ZEND_VM_LEAVE();
1148 } else if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP)) == 0)) {
1149 EG(current_execute_data) = EX(prev_execute_data);
1150 i_free_compiled_variables(execute_data);
1151
1152#ifdef ZEND_PREFER_RELOAD
1153 call_info = EX_CALL_INFO();
1154#endif
1155 if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
1156 zend_clean_and_cache_symbol_table(EX(symbol_table));
1157 }
1158
1159 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
1160 zend_free_extra_named_params(EX(extra_named_params));
1161 }
1162
1163 /* Free extra args before releasing the closure,
1164 * as that may free the op_array. */
1165 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
1166
1167 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
1168 OBJ_RELEASE(Z_OBJ(execute_data->This));
1169 } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
1170 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
1171 }
1172
1173 old_execute_data = execute_data;
1174 execute_data = EX(prev_execute_data);
1175 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
1176
1177 if (UNEXPECTED(EG(exception) != NULL)) {
1178 zend_rethrow_exception(execute_data);
1179 HANDLE_EXCEPTION_LEAVE();
1180 }
1181
1182 LOAD_NEXT_OPLINE();
1183 ZEND_VM_LEAVE();
1184 } else if (EXPECTED((call_info & ZEND_CALL_TOP) == 0)) {
1185 if (EX(func)->op_array.last_var > 0) {
1186 zend_detach_symbol_table(execute_data);
1187 call_info |= ZEND_CALL_NEEDS_REATTACH;
1188 }
1189 zend_destroy_static_vars(&EX(func)->op_array);
1190 destroy_op_array(&EX(func)->op_array);
1191 efree_size(EX(func), sizeof(zend_op_array));
1192 old_execute_data = execute_data;
1193 execute_data = EG(current_execute_data) = EX(prev_execute_data);
1194 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
1195
1196 if (call_info & ZEND_CALL_NEEDS_REATTACH) {
1197 if (EX(func)->op_array.last_var > 0) {
1198 zend_attach_symbol_table(execute_data);
1199 } else {
1200 ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_NEEDS_REATTACH);
1201 }
1202 }
1203 if (UNEXPECTED(EG(exception) != NULL)) {
1204 zend_rethrow_exception(execute_data);
1205 HANDLE_EXCEPTION_LEAVE();
1206 }
1207
1208 LOAD_NEXT_OPLINE();
1209 ZEND_VM_LEAVE();
1210 } else {
1211 if (EXPECTED((call_info & ZEND_CALL_CODE) == 0)) {
1212 EG(current_execute_data) = EX(prev_execute_data);
1213 i_free_compiled_variables(execute_data);
1214#ifdef ZEND_PREFER_RELOAD
1215 call_info = EX_CALL_INFO();
1216#endif
1217 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) {
1218 if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
1219 zend_clean_and_cache_symbol_table(EX(symbol_table));
1220 }
1221 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
1222 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
1223 zend_free_extra_named_params(EX(extra_named_params));
1224 }
1225 }
1226 if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
1227 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
1228 }
1229 ZEND_VM_RETURN();
1230 } else /* if (call_kind == ZEND_CALL_TOP_CODE) */ {
1231 zend_array *symbol_table = EX(symbol_table);
1232
1233 if (EX(func)->op_array.last_var > 0) {
1234 zend_detach_symbol_table(execute_data);
1235 call_info |= ZEND_CALL_NEEDS_REATTACH;
1236 }
1237 if (call_info & ZEND_CALL_NEEDS_REATTACH) {
1238 old_execute_data = EX(prev_execute_data);
1239 while (old_execute_data) {
1240 if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) {
1241 if (old_execute_data->symbol_table == symbol_table) {
1242 if (old_execute_data->func->op_array.last_var > 0) {
1243 zend_attach_symbol_table(old_execute_data);
1244 } else {
1245 ZEND_ADD_CALL_FLAG(old_execute_data, ZEND_CALL_NEEDS_REATTACH);
1246 }
1247 }
1248 break;
1249 }
1250 old_execute_data = old_execute_data->prev_execute_data;
1251 }
1252 }
1253 EG(current_execute_data) = EX(prev_execute_data);
1254 ZEND_VM_RETURN();
1255 }
1256 }
1257}
1258
1259static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1260{
1261 USE_OPLINE
1262
1263 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op1), 0);
1264}
1265
1266static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1267{
1268 USE_OPLINE
1269 zend_execute_data *call = EX(call);
1270 zend_function *fbc = call->func;
1271 zval *ret;
1272 zval retval;
1273
1274 SAVE_OPLINE();
1275 EX(call) = call->prev_execute_data;
1276
1277 call->prev_execute_data = execute_data;
1278 EG(current_execute_data) = call;
1279
1280#if ZEND_DEBUG
1281 bool should_throw = zend_internal_call_should_throw(fbc, call);
1282#endif
1283
1284 ret = 0 ? EX_VAR(opline->result.var) : &retval;
1285 ZVAL_NULL(ret);
1286
1287 fbc->internal_function.handler(call, ret);
1288
1289#if ZEND_DEBUG
1290 if (!EG(exception) && call->func) {
1291 if (should_throw) {
1292 zend_internal_call_arginfo_violation(call->func);
1293 }
1294 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1295 zend_verify_internal_return_type(call->func, ret));
1296 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1297 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1298 zend_verify_internal_func_info(call->func, ret);
1299 }
1300#endif
1301
1302 ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1303
1304 EG(current_execute_data) = execute_data;
1305 zend_vm_stack_free_args(call);
1306
1307 uint32_t call_info = ZEND_CALL_INFO(call);
1308 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1309 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1310 zend_free_extra_named_params(call->extra_named_params);
1311 }
1312 zend_vm_stack_free_call_frame_ex(call_info, call);
1313 } else {
1314 EG(vm_stack_top) = (zval*)call;
1315 }
1316
1317 if (!0) {
1318 i_zval_ptr_dtor(ret);
1319 }
1320
1321 if (UNEXPECTED(EG(exception) != NULL)) {
1322 zend_rethrow_exception(execute_data);
1323 HANDLE_EXCEPTION();
1324 }
1325
1326 ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1327 ZEND_VM_CONTINUE();
1328}
1329
1330static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1331{
1332 USE_OPLINE
1333 zend_execute_data *call = EX(call);
1334 zend_function *fbc = call->func;
1335 zval *ret;
1336 zval retval;
1337
1338 SAVE_OPLINE();
1339 EX(call) = call->prev_execute_data;
1340
1341 call->prev_execute_data = execute_data;
1342 EG(current_execute_data) = call;
1343
1344#if ZEND_DEBUG
1345 bool should_throw = zend_internal_call_should_throw(fbc, call);
1346#endif
1347
1348 ret = 1 ? EX_VAR(opline->result.var) : &retval;
1349 ZVAL_NULL(ret);
1350
1351 fbc->internal_function.handler(call, ret);
1352
1353#if ZEND_DEBUG
1354 if (!EG(exception) && call->func) {
1355 if (should_throw) {
1356 zend_internal_call_arginfo_violation(call->func);
1357 }
1358 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1359 zend_verify_internal_return_type(call->func, ret));
1360 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1361 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1362 zend_verify_internal_func_info(call->func, ret);
1363 }
1364#endif
1365
1366 ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1367
1368 EG(current_execute_data) = execute_data;
1369 zend_vm_stack_free_args(call);
1370
1371 uint32_t call_info = ZEND_CALL_INFO(call);
1372 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1373 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1374 zend_free_extra_named_params(call->extra_named_params);
1375 }
1376 zend_vm_stack_free_call_frame_ex(call_info, call);
1377 } else {
1378 EG(vm_stack_top) = (zval*)call;
1379 }
1380
1381 if (!1) {
1382 i_zval_ptr_dtor(ret);
1383 }
1384
1385 if (UNEXPECTED(EG(exception) != NULL)) {
1386 zend_rethrow_exception(execute_data);
1387 HANDLE_EXCEPTION();
1388 }
1389
1390 ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1391 ZEND_VM_CONTINUE();
1392}
1393
1394static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1395{
1396 USE_OPLINE
1397 zend_execute_data *call = EX(call);
1398 zend_function *fbc = call->func;
1399 zval *ret;
1400 zval retval;
1401
1402 SAVE_OPLINE();
1403 EX(call) = call->prev_execute_data;
1404
1405 call->prev_execute_data = execute_data;
1406 EG(current_execute_data) = call;
1407
1408#if ZEND_DEBUG
1409 bool should_throw = zend_internal_call_should_throw(fbc, call);
1410#endif
1411
1412 ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
1413 ZVAL_NULL(ret);
1414
1415 zend_observer_fcall_begin_specialized(call, false);
1416 fbc->internal_function.handler(call, ret);
1417
1418#if ZEND_DEBUG
1419 if (!EG(exception) && call->func) {
1420 if (should_throw) {
1421 zend_internal_call_arginfo_violation(call->func);
1422 }
1423 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1424 zend_verify_internal_return_type(call->func, ret));
1425 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1426 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1427 zend_verify_internal_func_info(call->func, ret);
1428 }
1429#endif
1430 zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
1431 ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1432
1433 EG(current_execute_data) = execute_data;
1434 zend_vm_stack_free_args(call);
1435
1436 uint32_t call_info = ZEND_CALL_INFO(call);
1437 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1438 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1439 zend_free_extra_named_params(call->extra_named_params);
1440 }
1441 zend_vm_stack_free_call_frame_ex(call_info, call);
1442 } else {
1443 EG(vm_stack_top) = (zval*)call;
1444 }
1445
1446 if (!RETURN_VALUE_USED(opline)) {
1447 i_zval_ptr_dtor(ret);
1448 }
1449
1450 if (UNEXPECTED(EG(exception) != NULL)) {
1451 zend_rethrow_exception(execute_data);
1452 HANDLE_EXCEPTION();
1453 }
1454
1455 ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1456 ZEND_VM_CONTINUE();
1457}
1458
1459static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1460{
1461 USE_OPLINE
1462 zend_execute_data *call = EX(call);
1463 zend_function *fbc = call->func;
1464 zval *ret;
1465
1466 SAVE_OPLINE();
1467 EX(call) = call->prev_execute_data;
1468
1469 ret = NULL;
1470 if (0) {
1471 ret = EX_VAR(opline->result.var);
1472 }
1473
1474 call->prev_execute_data = execute_data;
1475 execute_data = call;
1476 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1477 LOAD_OPLINE_EX();
1478
1479
1480 ZEND_VM_ENTER_EX();
1481}
1482
1483static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1484{
1485 USE_OPLINE
1486 zend_execute_data *call = EX(call);
1487 zend_function *fbc = call->func;
1488 zval *ret;
1489
1490 SAVE_OPLINE();
1491 EX(call) = call->prev_execute_data;
1492
1493 ret = NULL;
1494 if (1) {
1495 ret = EX_VAR(opline->result.var);
1496 }
1497
1498 call->prev_execute_data = execute_data;
1499 execute_data = call;
1500 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1501 LOAD_OPLINE_EX();
1502
1503
1504 ZEND_VM_ENTER_EX();
1505}
1506
1507static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1508{
1509 USE_OPLINE
1510 zend_execute_data *call = EX(call);
1511 zend_function *fbc = call->func;
1512 zval *ret;
1513
1514 SAVE_OPLINE();
1515 EX(call) = call->prev_execute_data;
1516
1517 ret = NULL;
1518 if (RETURN_VALUE_USED(opline)) {
1519 ret = EX_VAR(opline->result.var);
1520 }
1521
1522 call->prev_execute_data = execute_data;
1523 execute_data = call;
1524 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1525 LOAD_OPLINE_EX();
1526 SAVE_OPLINE();
1527 zend_observer_fcall_begin_specialized(execute_data, false);
1528
1529 ZEND_VM_ENTER_EX();
1530}
1531
1532static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1533{
1534 USE_OPLINE
1535 zend_execute_data *call = EX(call);
1536 zend_function *fbc = call->func;
1537 zval *ret;
1538 zval retval;
1539
1540 SAVE_OPLINE();
1541 EX(call) = call->prev_execute_data;
1542
1543 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
1544 zend_deprecated_function(fbc);
1545 if (UNEXPECTED(EG(exception) != NULL)) {
1546 UNDEF_RESULT();
1547 if (!0) {
1548 ret = &retval;
1549 ZVAL_UNDEF(ret);
1550 }
1551 goto fcall_by_name_end;
1552 }
1553 }
1554
1555 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1556 ret = NULL;
1557 if (0) {
1558 ret = EX_VAR(opline->result.var);
1559 }
1560
1561 call->prev_execute_data = execute_data;
1562 execute_data = call;
1563 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1564 LOAD_OPLINE_EX();
1565
1566
1567 ZEND_VM_ENTER_EX();
1568 } else {
1569 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1570 if (0) {
1571 ret = NULL;
1572 }
1573
1574 call->prev_execute_data = execute_data;
1575 EG(current_execute_data) = call;
1576
1577#if ZEND_DEBUG
1578 bool should_throw = zend_internal_call_should_throw(fbc, call);
1579#endif
1580
1581 ret = 0 ? EX_VAR(opline->result.var) : &retval;
1582 ZVAL_NULL(ret);
1583
1584 fbc->internal_function.handler(call, ret);
1585
1586#if ZEND_DEBUG
1587 if (!EG(exception) && call->func) {
1588 if (should_throw) {
1589 zend_internal_call_arginfo_violation(call->func);
1590 }
1591 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1592 zend_verify_internal_return_type(call->func, ret));
1593 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1594 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1595 zend_verify_internal_func_info(call->func, ret);
1596 }
1597#endif
1598
1599 ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1600
1601 EG(current_execute_data) = execute_data;
1602
1603 goto fcall_by_name_end;
1604 }
1605
1606 if (0) {
1607fcall_by_name_end:
1608
1609 zend_vm_stack_free_args(call);
1610
1611 uint32_t call_info = ZEND_CALL_INFO(call);
1612 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1613 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1614 zend_free_extra_named_params(call->extra_named_params);
1615 }
1616 zend_vm_stack_free_call_frame_ex(call_info, call);
1617 } else {
1618 EG(vm_stack_top) = (zval*)call;
1619 }
1620
1621 if (!0) {
1622 i_zval_ptr_dtor(ret);
1623 }
1624 }
1625
1626 if (UNEXPECTED(EG(exception) != NULL)) {
1627 zend_rethrow_exception(execute_data);
1628 HANDLE_EXCEPTION();
1629 }
1630 ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1631 ZEND_VM_CONTINUE();
1632}
1633
1634static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1635{
1636 USE_OPLINE
1637 zend_execute_data *call = EX(call);
1638 zend_function *fbc = call->func;
1639 zval *ret;
1640 zval retval;
1641
1642 SAVE_OPLINE();
1643 EX(call) = call->prev_execute_data;
1644
1645 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
1646 zend_deprecated_function(fbc);
1647 if (UNEXPECTED(EG(exception) != NULL)) {
1648 UNDEF_RESULT();
1649 if (!1) {
1650 ret = &retval;
1651 ZVAL_UNDEF(ret);
1652 }
1653 goto fcall_by_name_end;
1654 }
1655 }
1656
1657 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1658 ret = NULL;
1659 if (1) {
1660 ret = EX_VAR(opline->result.var);
1661 }
1662
1663 call->prev_execute_data = execute_data;
1664 execute_data = call;
1665 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1666 LOAD_OPLINE_EX();
1667
1668
1669 ZEND_VM_ENTER_EX();
1670 } else {
1671 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1672 if (0) {
1673 ret = NULL;
1674 }
1675
1676 call->prev_execute_data = execute_data;
1677 EG(current_execute_data) = call;
1678
1679#if ZEND_DEBUG
1680 bool should_throw = zend_internal_call_should_throw(fbc, call);
1681#endif
1682
1683 ret = 1 ? EX_VAR(opline->result.var) : &retval;
1684 ZVAL_NULL(ret);
1685
1686 fbc->internal_function.handler(call, ret);
1687
1688#if ZEND_DEBUG
1689 if (!EG(exception) && call->func) {
1690 if (should_throw) {
1691 zend_internal_call_arginfo_violation(call->func);
1692 }
1693 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1694 zend_verify_internal_return_type(call->func, ret));
1695 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1696 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1697 zend_verify_internal_func_info(call->func, ret);
1698 }
1699#endif
1700
1701 ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1702
1703 EG(current_execute_data) = execute_data;
1704
1705 goto fcall_by_name_end;
1706 }
1707
1708 if (0) {
1709fcall_by_name_end:
1710
1711 zend_vm_stack_free_args(call);
1712
1713 uint32_t call_info = ZEND_CALL_INFO(call);
1714 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1715 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1716 zend_free_extra_named_params(call->extra_named_params);
1717 }
1718 zend_vm_stack_free_call_frame_ex(call_info, call);
1719 } else {
1720 EG(vm_stack_top) = (zval*)call;
1721 }
1722
1723 if (!1) {
1724 i_zval_ptr_dtor(ret);
1725 }
1726 }
1727
1728 if (UNEXPECTED(EG(exception) != NULL)) {
1729 zend_rethrow_exception(execute_data);
1730 HANDLE_EXCEPTION();
1731 }
1732 ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1733 ZEND_VM_CONTINUE();
1734}
1735
1736static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1737{
1738 USE_OPLINE
1739 zend_execute_data *call = EX(call);
1740 zend_function *fbc = call->func;
1741 zval *ret;
1742 zval retval;
1743
1744 SAVE_OPLINE();
1745 EX(call) = call->prev_execute_data;
1746
1747 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
1748 zend_deprecated_function(fbc);
1749 if (UNEXPECTED(EG(exception) != NULL)) {
1750 UNDEF_RESULT();
1751 if (!RETURN_VALUE_USED(opline)) {
1752 ret = &retval;
1753 ZVAL_UNDEF(ret);
1754 }
1755 goto fcall_by_name_end;
1756 }
1757 }
1758
1759 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1760 ret = NULL;
1761 if (RETURN_VALUE_USED(opline)) {
1762 ret = EX_VAR(opline->result.var);
1763 }
1764
1765 call->prev_execute_data = execute_data;
1766 execute_data = call;
1767 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1768 LOAD_OPLINE_EX();
1769 SAVE_OPLINE();
1770 zend_observer_fcall_begin_specialized(execute_data, false);
1771
1772 ZEND_VM_ENTER_EX();
1773 } else {
1774 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1775 if (1) {
1776 ret = NULL;
1777 }
1778
1779 call->prev_execute_data = execute_data;
1780 EG(current_execute_data) = call;
1781
1782#if ZEND_DEBUG
1783 bool should_throw = zend_internal_call_should_throw(fbc, call);
1784#endif
1785
1786 ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
1787 ZVAL_NULL(ret);
1788
1789 zend_observer_fcall_begin_specialized(call, false);
1790 fbc->internal_function.handler(call, ret);
1791
1792#if ZEND_DEBUG
1793 if (!EG(exception) && call->func) {
1794 if (should_throw) {
1795 zend_internal_call_arginfo_violation(call->func);
1796 }
1797 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1798 zend_verify_internal_return_type(call->func, ret));
1799 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1800 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1801 zend_verify_internal_func_info(call->func, ret);
1802 }
1803#endif
1804 zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
1805 ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1806
1807 EG(current_execute_data) = execute_data;
1808
1809 goto fcall_by_name_end;
1810 }
1811
1812 if (0) {
1813fcall_by_name_end:
1814
1815 zend_vm_stack_free_args(call);
1816
1817 uint32_t call_info = ZEND_CALL_INFO(call);
1818 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1819 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1820 zend_free_extra_named_params(call->extra_named_params);
1821 }
1822 zend_vm_stack_free_call_frame_ex(call_info, call);
1823 } else {
1824 EG(vm_stack_top) = (zval*)call;
1825 }
1826
1827 if (!RETURN_VALUE_USED(opline)) {
1828 i_zval_ptr_dtor(ret);
1829 }
1830 }
1831
1832 if (UNEXPECTED(EG(exception) != NULL)) {
1833 zend_rethrow_exception(execute_data);
1834 HANDLE_EXCEPTION();
1835 }
1836 ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1837 ZEND_VM_CONTINUE();
1838}
1839
1840static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1841{
1842 USE_OPLINE
1843 zend_execute_data *call = EX(call);
1844 zend_function *fbc = call->func;
1845 zval *ret;
1846 zval retval;
1847
1848 SAVE_OPLINE();
1849 EX(call) = call->prev_execute_data;
1850
1851 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
1852 zend_deprecated_function(fbc);
1853 if (UNEXPECTED(EG(exception) != NULL)) {
1854 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) {
1855 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func));
1856 }
1857 UNDEF_RESULT();
1858 if (!0) {
1859 ret = &retval;
1860 ZVAL_UNDEF(ret);
1861 }
1862 goto fcall_end;
1863 }
1864 }
1865
1866 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1867 ret = NULL;
1868 if (0) {
1869 ret = EX_VAR(opline->result.var);
1870 }
1871
1872 call->prev_execute_data = execute_data;
1873 execute_data = call;
1874 i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
1875
1876 if (EXPECTED(zend_execute_ex == execute_ex)) {
1877 LOAD_OPLINE_EX();
1878
1879
1880 ZEND_VM_ENTER_EX();
1881 } else {
1882 SAVE_OPLINE_EX();
1883
1884 execute_data = EX(prev_execute_data);
1885 LOAD_OPLINE();
1886 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
1887 zend_execute_ex(call);
1888 }
1889 } else {
1890 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1891 if (0) {
1892 ret = NULL;
1893 }
1894
1895 call->prev_execute_data = execute_data;
1896 EG(current_execute_data) = call;
1897
1898#if ZEND_DEBUG
1899 bool should_throw = zend_internal_call_should_throw(fbc, call);
1900#endif
1901
1902 ret = 0 ? EX_VAR(opline->result.var) : &retval;
1903 ZVAL_NULL(ret);
1904
1905 if (!zend_execute_internal) {
1906 /* saves one function call if zend_execute_internal is not used */
1907 fbc->internal_function.handler(call, ret);
1908 } else {
1909 zend_execute_internal(call, ret);
1910 }
1911
1912#if ZEND_DEBUG
1913 if (!EG(exception) && call->func && !(call->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE)) {
1914 if (should_throw) {
1915 zend_internal_call_arginfo_violation(call->func);
1916 }
1917 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1918 zend_verify_internal_return_type(call->func, ret));
1919 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1920 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1921 zend_verify_internal_func_info(call->func, ret);
1922 }
1923#endif
1924
1925 ZEND_VM_FCALL_INTERRUPT_CHECK(call);
1926
1927 EG(current_execute_data) = execute_data;
1928
1929 goto fcall_end;
1930 }
1931
1932 if (0) {
1933fcall_end:
1934
1935 zend_vm_stack_free_args(call);
1936 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
1937 zend_free_extra_named_params(call->extra_named_params);
1938 }
1939
1940 if (!0) {
1941 i_zval_ptr_dtor(ret);
1942 }
1943 }
1944
1945 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
1946 OBJ_RELEASE(Z_OBJ(call->This));
1947 }
1948
1949 zend_vm_stack_free_call_frame(call);
1950 if (UNEXPECTED(EG(exception) != NULL)) {
1951 zend_rethrow_exception(execute_data);
1952 HANDLE_EXCEPTION();
1953 }
1954 ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
1955 ZEND_VM_CONTINUE();
1956}
1957
1958static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1959{
1960 USE_OPLINE
1961 zend_execute_data *call = EX(call);
1962 zend_function *fbc = call->func;
1963 zval *ret;
1964 zval retval;
1965
1966 SAVE_OPLINE();
1967 EX(call) = call->prev_execute_data;
1968
1969 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
1970 zend_deprecated_function(fbc);
1971 if (UNEXPECTED(EG(exception) != NULL)) {
1972 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) {
1973 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func));
1974 }
1975 UNDEF_RESULT();
1976 if (!1) {
1977 ret = &retval;
1978 ZVAL_UNDEF(ret);
1979 }
1980 goto fcall_end;
1981 }
1982 }
1983
1984 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1985 ret = NULL;
1986 if (1) {
1987 ret = EX_VAR(opline->result.var);
1988 }
1989
1990 call->prev_execute_data = execute_data;
1991 execute_data = call;
1992 i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
1993
1994 if (EXPECTED(zend_execute_ex == execute_ex)) {
1995 LOAD_OPLINE_EX();
1996
1997
1998 ZEND_VM_ENTER_EX();
1999 } else {
2000 SAVE_OPLINE_EX();
2001
2002 execute_data = EX(prev_execute_data);
2003 LOAD_OPLINE();
2004 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
2005 zend_execute_ex(call);
2006 }
2007 } else {
2008 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
2009 if (0) {
2010 ret = NULL;
2011 }
2012
2013 call->prev_execute_data = execute_data;
2014 EG(current_execute_data) = call;
2015
2016#if ZEND_DEBUG
2017 bool should_throw = zend_internal_call_should_throw(fbc, call);
2018#endif
2019
2020 ret = 1 ? EX_VAR(opline->result.var) : &retval;
2021 ZVAL_NULL(ret);
2022
2023 if (!zend_execute_internal) {
2024 /* saves one function call if zend_execute_internal is not used */
2025 fbc->internal_function.handler(call, ret);
2026 } else {
2027 zend_execute_internal(call, ret);
2028 }
2029
2030#if ZEND_DEBUG
2031 if (!EG(exception) && call->func && !(call->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE)) {
2032 if (should_throw) {
2033 zend_internal_call_arginfo_violation(call->func);
2034 }
2035 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
2036 zend_verify_internal_return_type(call->func, ret));
2037 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
2038 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
2039 zend_verify_internal_func_info(call->func, ret);
2040 }
2041#endif
2042
2043 ZEND_VM_FCALL_INTERRUPT_CHECK(call);
2044
2045 EG(current_execute_data) = execute_data;
2046
2047 goto fcall_end;
2048 }
2049
2050 if (0) {
2051fcall_end:
2052
2053 zend_vm_stack_free_args(call);
2054 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
2055 zend_free_extra_named_params(call->extra_named_params);
2056 }
2057
2058 if (!1) {
2059 i_zval_ptr_dtor(ret);
2060 }
2061 }
2062
2063 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
2064 OBJ_RELEASE(Z_OBJ(call->This));
2065 }
2066
2067 zend_vm_stack_free_call_frame(call);
2068 if (UNEXPECTED(EG(exception) != NULL)) {
2069 zend_rethrow_exception(execute_data);
2070 HANDLE_EXCEPTION();
2071 }
2072 ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
2073 ZEND_VM_CONTINUE();
2074}
2075
2076static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2077{
2078 USE_OPLINE
2079 zend_execute_data *call = EX(call);
2080 zend_function *fbc = call->func;
2081 zval *ret;
2082 zval retval;
2083
2084 SAVE_OPLINE();
2085 EX(call) = call->prev_execute_data;
2086
2087 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
2088 zend_deprecated_function(fbc);
2089 if (UNEXPECTED(EG(exception) != NULL)) {
2090 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE)) {
2091 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func));
2092 }
2093 UNDEF_RESULT();
2094 if (!RETURN_VALUE_USED(opline)) {
2095 ret = &retval;
2096 ZVAL_UNDEF(ret);
2097 }
2098 goto fcall_end;
2099 }
2100 }
2101
2102 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
2103 ret = NULL;
2104 if (RETURN_VALUE_USED(opline)) {
2105 ret = EX_VAR(opline->result.var);
2106 }
2107
2108 call->prev_execute_data = execute_data;
2109 execute_data = call;
2110 i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
2111
2112 if (EXPECTED(zend_execute_ex == execute_ex)) {
2113 LOAD_OPLINE_EX();
2114 SAVE_OPLINE();
2115 zend_observer_fcall_begin_specialized(execute_data, false);
2116 ZEND_VM_ENTER_EX();
2117 } else {
2118 SAVE_OPLINE_EX();
2119 zend_observer_fcall_begin_specialized(execute_data, false);
2120 execute_data = EX(prev_execute_data);
2121 LOAD_OPLINE();
2122 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
2123 zend_execute_ex(call);
2124 }
2125 } else {
2126 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
2127 if (1) {
2128 ret = NULL;
2129 }
2130
2131 call->prev_execute_data = execute_data;
2132 EG(current_execute_data) = call;
2133
2134#if ZEND_DEBUG
2135 bool should_throw = zend_internal_call_should_throw(fbc, call);
2136#endif
2137
2138 ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
2139 ZVAL_NULL(ret);
2140
2141 zend_observer_fcall_begin_specialized(call, false);
2142 if (!zend_execute_internal) {
2143 /* saves one function call if zend_execute_internal is not used */
2144 fbc->internal_function.handler(call, ret);
2145 } else {
2146 zend_execute_internal(call, ret);
2147 }
2148
2149#if ZEND_DEBUG
2150 if (!EG(exception) && call->func && !(call->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE)) {
2151 if (should_throw) {
2152 zend_internal_call_arginfo_violation(call->func);
2153 }
2154 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
2155 zend_verify_internal_return_type(call->func, ret));
2156 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
2157 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
2158 zend_verify_internal_func_info(call->func, ret);
2159 }
2160#endif
2161 zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
2162 ZEND_VM_FCALL_INTERRUPT_CHECK(call);
2163
2164 EG(current_execute_data) = execute_data;
2165
2166 goto fcall_end;
2167 }
2168
2169 if (0) {
2170fcall_end:
2171
2172 zend_vm_stack_free_args(call);
2173 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
2174 zend_free_extra_named_params(call->extra_named_params);
2175 }
2176
2177 if (!RETURN_VALUE_USED(opline)) {
2178 i_zval_ptr_dtor(ret);
2179 }
2180 }
2181
2182 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
2183 OBJ_RELEASE(Z_OBJ(call->This));
2184 }
2185
2186 zend_vm_stack_free_call_frame(call);
2187 if (UNEXPECTED(EG(exception) != NULL)) {
2188 zend_rethrow_exception(execute_data);
2189 HANDLE_EXCEPTION();
2190 }
2191 ZEND_VM_SET_OPCODE_NO_INTERRUPT(opline + 1);
2192 ZEND_VM_CONTINUE();
2193}
2194
2195static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2196{
2197 zval *return_value = EX(return_value);
2198
2199 if (EXPECTED(return_value)) {
2200 USE_OPLINE
2201 zend_generator *generator;
2202 zend_execute_data *gen_execute_data;
2203 uint32_t num_args, used_stack, call_info;
2204
2205 SAVE_OPLINE();
2206 object_init_ex(return_value, zend_ce_generator);
2207
2208 /*
2209 * Normally the execute_data is allocated on the VM stack (because it does
2210 * not actually do any allocation and thus is faster). For generators
2211 * though this behavior would be suboptimal, because the (rather large)
2212 * structure would have to be copied back and forth every time execution is
2213 * suspended or resumed. That's why for generators the execution context
2214 * is allocated on heap.
2215 */
2216 num_args = EX_NUM_ARGS();
2217 if (EXPECTED(num_args <= EX(func)->op_array.num_args)) {
2218 used_stack = (ZEND_CALL_FRAME_SLOT + EX(func)->op_array.last_var + EX(func)->op_array.T) * sizeof(zval);
2219 gen_execute_data = (zend_execute_data*)emalloc(used_stack);
2220 used_stack = (ZEND_CALL_FRAME_SLOT + EX(func)->op_array.last_var) * sizeof(zval);
2221 } else {
2222 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);
2223 gen_execute_data = (zend_execute_data*)emalloc(used_stack);
2224 }
2225 memcpy(gen_execute_data, execute_data, used_stack);
2226
2227 /* Save execution context in generator object. */
2228 generator = (zend_generator *) Z_OBJ_P(EX(return_value));
2229 generator->func = gen_execute_data->func;
2230 generator->execute_data = gen_execute_data;
2231 generator->frozen_call_stack = NULL;
2232 generator->execute_fake.opline = NULL;
2233 generator->execute_fake.func = NULL;
2234 generator->execute_fake.prev_execute_data = NULL;
2235 ZVAL_OBJ(&generator->execute_fake.This, (zend_object *) generator);
2236
2237 gen_execute_data->opline = opline;
2238 /* EX(return_value) keeps pointer to zend_object (not a real zval) */
2239 gen_execute_data->return_value = (zval*)generator;
2240 call_info = Z_TYPE_INFO(EX(This));
2241 if ((call_info & Z_TYPE_MASK) == IS_OBJECT
2242 && (!(call_info & (ZEND_CALL_CLOSURE|ZEND_CALL_RELEASE_THIS))
2243 /* Bug #72523 */
2244 || UNEXPECTED(zend_execute_ex != execute_ex))) {
2245 ZEND_ADD_CALL_FLAG_EX(call_info, ZEND_CALL_RELEASE_THIS);
2246 Z_ADDREF(gen_execute_data->This);
2247 }
2248 ZEND_ADD_CALL_FLAG_EX(call_info, (ZEND_CALL_TOP_FUNCTION | ZEND_CALL_ALLOCATED | ZEND_CALL_GENERATOR));
2249 Z_TYPE_INFO(gen_execute_data->This) = call_info;
2250 gen_execute_data->prev_execute_data = NULL;
2251
2252 call_info = EX_CALL_INFO();
2253 EG(current_execute_data) = EX(prev_execute_data);
2254 if (EXPECTED(!(call_info & (ZEND_CALL_TOP|ZEND_CALL_ALLOCATED)))) {
2255 EG(vm_stack_top) = (zval*)execute_data;
2256 execute_data = EX(prev_execute_data);
2257 LOAD_NEXT_OPLINE();
2258 ZEND_VM_LEAVE();
2259 } else if (EXPECTED(!(call_info & ZEND_CALL_TOP))) {
2260 zend_execute_data *old_execute_data = execute_data;
2261 execute_data = EX(prev_execute_data);
2262 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
2263 LOAD_NEXT_OPLINE();
2264 ZEND_VM_LEAVE();
2265 } else {
2266 ZEND_VM_RETURN();
2267 }
2268 } else {
2269 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
2270 }
2271}
2272
2273static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_cannot_pass_by_ref_helper_SPEC(uint32_t _arg_num, zval *_arg ZEND_OPCODE_HANDLER_ARGS_DC)
2274{
2275 USE_OPLINE
2276
2277 SAVE_OPLINE();
2278
2279 zend_cannot_pass_by_reference(_arg_num);
2280 FREE_OP(opline->op1_type, opline->op1.var);
2281 ZVAL_UNDEF(_arg);
2282 HANDLE_EXCEPTION();
2283}
2284
2285static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2286{
2287 USE_OPLINE
2288 zval *args;
2289 uint32_t arg_num;
2290
2291 SAVE_OPLINE();
2292 args = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
2293 arg_num = ZEND_CALL_NUM_ARGS(EX(call)) + 1;
2294
2295send_again:
2296 if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
2297 HashTable *ht = Z_ARRVAL_P(args);
2298 zval *arg, *top;
2299 zend_string *name;
2300 bool have_named_params = 0;
2301
2302 zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, zend_hash_num_elements(ht));
2303
2304 // TODO: Speed this up using a flag that specifies whether there are any ref parameters.
2305 if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_REFCOUNT_P(args) > 1) {
2306 uint32_t tmp_arg_num = arg_num;
2307 bool separate = 0;
2308
2309 /* check if any of arguments are going to be passed by reference */
2310 ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2311 if (UNEXPECTED(name)) {
2312 void *cache_slot[2] = {NULL, NULL};
2313 tmp_arg_num = zend_get_arg_offset_by_name(
2314 EX(call)->func, name, cache_slot) + 1;
2315 }
2316 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, tmp_arg_num)) {
2317 separate = 1;
2318 break;
2319 }
2320 tmp_arg_num++;
2321 } ZEND_HASH_FOREACH_END();
2322 if (separate) {
2323 SEPARATE_ARRAY(args);
2324 ht = Z_ARRVAL_P(args);
2325 }
2326 }
2327
2328 ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2329 if (UNEXPECTED(name)) {
2330 void *cache_slot[2] = {NULL, NULL};
2331 have_named_params = 1;
2332 top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2333 if (UNEXPECTED(!top)) {
2334 FREE_OP(opline->op1_type, opline->op1.var);
2335 HANDLE_EXCEPTION();
2336 }
2337 } else {
2338 if (have_named_params) {
2339 zend_throw_error(NULL,
2340 "Cannot use positional argument after named argument during unpacking");
2341 FREE_OP(opline->op1_type, opline->op1.var);
2342 HANDLE_EXCEPTION();
2343 }
2344
2345 top = ZEND_CALL_ARG(EX(call), arg_num);
2346 ZEND_CALL_NUM_ARGS(EX(call))++;
2347 }
2348
2349 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2350 if (Z_ISREF_P(arg)) {
2351 Z_ADDREF_P(arg);
2352 ZVAL_REF(top, Z_REF_P(arg));
2353 } else if (opline->op1_type & (IS_VAR|IS_CV)) {
2354 /* array is already separated above */
2355 ZVAL_MAKE_REF_EX(arg, 2);
2356 ZVAL_REF(top, Z_REF_P(arg));
2357 } else {
2358 Z_TRY_ADDREF_P(arg);
2359 ZVAL_NEW_REF(top, arg);
2360 }
2361 } else {
2362 ZVAL_COPY_DEREF(top, arg);
2363 }
2364
2365 arg_num++;
2366 } ZEND_HASH_FOREACH_END();
2367
2368 } else if (EXPECTED(Z_TYPE_P(args) == IS_OBJECT)) {
2369 zend_class_entry *ce = Z_OBJCE_P(args);
2370 zend_object_iterator *iter;
2371 bool have_named_params = 0;
2372
2373 if (!ce || !ce->get_iterator) {
2374 zend_type_error("Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(args));
2375 } else {
2376
2377 iter = ce->get_iterator(ce, args, 0);
2378 if (UNEXPECTED(!iter)) {
2379 FREE_OP(opline->op1_type, opline->op1.var);
2380 if (!EG(exception)) {
2381 zend_throw_exception_ex(
2382 NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
2383 );
2384 }
2385 HANDLE_EXCEPTION();
2386 }
2387
2388 const zend_object_iterator_funcs *funcs = iter->funcs;
2389 if (funcs->rewind) {
2390 funcs->rewind(iter);
2391 }
2392
2393 for (; funcs->valid(iter) == SUCCESS; ++arg_num) {
2394 zval *arg, *top;
2395
2396 if (UNEXPECTED(EG(exception) != NULL)) {
2397 break;
2398 }
2399
2400 arg = funcs->get_current_data(iter);
2401 if (UNEXPECTED(EG(exception) != NULL)) {
2402 break;
2403 }
2404
2405 zend_string *name = NULL;
2406 if (funcs->get_current_key) {
2407 zval key;
2408 funcs->get_current_key(iter, &key);
2409 if (UNEXPECTED(EG(exception) != NULL)) {
2410 break;
2411 }
2412
2413 if (UNEXPECTED(Z_TYPE(key) != IS_LONG)) {
2414 if (UNEXPECTED(Z_TYPE(key) != IS_STRING)) {
2415 zend_throw_error(NULL,
2416 "Keys must be of type int|string during argument unpacking");
2417 zval_ptr_dtor(&key);
2418 break;
2419 }
2420
2421 name = Z_STR_P(&key);
2422 }
2423 }
2424
2425 if (UNEXPECTED(name)) {
2426 void *cache_slot[2] = {NULL, NULL};
2427 have_named_params = 1;
2428 top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2429 if (UNEXPECTED(!top)) {
2430 zend_string_release(name);
2431 break;
2432 }
2433
2434 ZVAL_DEREF(arg);
2435 Z_TRY_ADDREF_P(arg);
2436
2437 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2438 zend_error(
2439 E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
2440 " by unpacking a Traversable, passing by-value instead", arg_num,
2441 EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
2442 EX(call)->func->common.scope ? "::" : "",
2443 ZSTR_VAL(EX(call)->func->common.function_name)
2444 );
2445 ZVAL_NEW_REF(top, arg);
2446 } else {
2447 ZVAL_COPY_VALUE(top, arg);
2448 }
2449
2450 zend_string_release(name);
2451 } else {
2452 if (have_named_params) {
2453 zend_throw_error(NULL,
2454 "Cannot use positional argument after named argument during unpacking");
2455 break;
2456 }
2457
2458 zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, 1);
2459 top = ZEND_CALL_ARG(EX(call), arg_num);
2460 ZVAL_DEREF(arg);
2461 Z_TRY_ADDREF_P(arg);
2462
2463 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2464 zend_error(
2465 E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
2466 " by unpacking a Traversable, passing by-value instead", arg_num,
2467 EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
2468 EX(call)->func->common.scope ? "::" : "",
2469 ZSTR_VAL(EX(call)->func->common.function_name)
2470 );
2471 ZVAL_NEW_REF(top, arg);
2472 } else {
2473 ZVAL_COPY_VALUE(top, arg);
2474 }
2475
2476 ZEND_CALL_NUM_ARGS(EX(call))++;
2477 }
2478
2479 funcs->move_forward(iter);
2480 }
2481
2482 zend_iterator_dtor(iter);
2483 }
2484 } else if (EXPECTED(Z_ISREF_P(args))) {
2485 args = Z_REFVAL_P(args);
2486 goto send_again;
2487 } else {
2488 if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(args) == IS_UNDEF)) {
2489 ZVAL_UNDEFINED_OP1();
2490 }
2491 zend_type_error("Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(args));
2492 }
2493
2494 FREE_OP(opline->op1_type, opline->op1.var);
2495 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2496}
2497
2498static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2499{
2500 USE_OPLINE
2501 zval *args;
2502
2503 SAVE_OPLINE();
2504 args = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
2505
2506 if (UNEXPECTED(Z_TYPE_P(args) != IS_ARRAY)) {
2507 if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_ISREF_P(args)) {
2508 args = Z_REFVAL_P(args);
2509 if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
2510 goto send_array;
2511 }
2512 }
2513 zend_type_error("call_user_func_array(): Argument #2 ($args) must be of type array, %s given", zend_zval_value_name(args));
2514 FREE_OP(opline->op2_type, opline->op2.var);
2515 FREE_OP(opline->op1_type, opline->op1.var);
2516 HANDLE_EXCEPTION();
2517 } else {
2518 uint32_t arg_num;
2519 HashTable *ht;
2520 zval *arg, *param;
2521
2522send_array:
2523 ht = Z_ARRVAL_P(args);
2524 if (opline->op2_type != IS_UNUSED) {
2525 /* We don't need to handle named params in this case,
2526 * because array_slice() is called with $preserve_keys == false. */
2527 zval *op2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
2528 uint32_t skip = opline->extended_value;
2529 uint32_t count = zend_hash_num_elements(ht);
2530 zend_long len;
2531 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
2532 len = Z_LVAL_P(op2);
2533 } else if (Z_TYPE_P(op2) == IS_NULL) {
2534 len = count - skip;
2535 } else if (EX_USES_STRICT_TYPES()
2536 || !zend_parse_arg_long_weak(op2, &len, /* arg_num */ 3)) {
2537 zend_type_error(
2538 "array_slice(): Argument #3 ($length) must be of type ?int, %s given",
2539 zend_zval_value_name(op2));
2540 FREE_OP(opline->op2_type, opline->op2.var);
2541 FREE_OP(opline->op1_type, opline->op1.var);
2542 HANDLE_EXCEPTION();
2543 }
2544
2545 if (len < 0) {
2546 len += (zend_long)(count - skip);
2547 }
2548 if (skip < count && len > 0) {
2549 if (len > (zend_long)(count - skip)) {
2550 len = (zend_long)(count - skip);
2551 }
2552 zend_vm_stack_extend_call_frame(&EX(call), 0, len);
2553 arg_num = 1;
2554 param = ZEND_CALL_ARG(EX(call), 1);
2555 ZEND_HASH_FOREACH_VAL(ht, arg) {
2556 bool must_wrap = 0;
2557 if (skip > 0) {
2558 skip--;
2559 continue;
2560 } else if ((zend_long)(arg_num - 1) >= len) {
2561 break;
2562 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2563 if (UNEXPECTED(!Z_ISREF_P(arg))) {
2564 if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2565 /* By-value send is not allowed -- emit a warning,
2566 * but still perform the call. */
2567 zend_param_must_be_ref(EX(call)->func, arg_num);
2568 must_wrap = 1;
2569 }
2570 }
2571 } else {
2572 if (Z_ISREF_P(arg) &&
2573 !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
2574 /* don't separate references for __call */
2575 arg = Z_REFVAL_P(arg);
2576 }
2577 }
2578 if (EXPECTED(!must_wrap)) {
2579 ZVAL_COPY(param, arg);
2580 } else {
2581 Z_TRY_ADDREF_P(arg);
2582 ZVAL_NEW_REF(param, arg);
2583 }
2584 ZEND_CALL_NUM_ARGS(EX(call))++;
2585 arg_num++;
2586 param++;
2587 } ZEND_HASH_FOREACH_END();
2588 }
2589 FREE_OP(opline->op2_type, opline->op2.var);
2590 } else {
2591 zend_string *name;
2592 bool have_named_params;
2593 zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht));
2594 arg_num = 1;
2595 param = ZEND_CALL_ARG(EX(call), 1);
2596 have_named_params = 0;
2597 ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2598 if (name) {
2599 void *cache_slot[2] = {NULL, NULL};
2600 have_named_params = 1;
2601 param = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2602 if (!param) {
2603 FREE_OP(opline->op1_type, opline->op1.var);
2604 HANDLE_EXCEPTION();
2605 }
2606 } else if (have_named_params) {
2607 zend_throw_error(NULL,
2608 "Cannot use positional argument after named argument");
2609 FREE_OP(opline->op1_type, opline->op1.var);
2610 HANDLE_EXCEPTION();
2611 }
2612
2613 bool must_wrap = 0;
2614 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2615 if (UNEXPECTED(!Z_ISREF_P(arg))) {
2616 if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2617 /* By-value send is not allowed -- emit a warning,
2618 * but still perform the call. */
2619 zend_param_must_be_ref(EX(call)->func, arg_num);
2620 must_wrap = 1;
2621 }
2622 }
2623 } else {
2624 if (Z_ISREF_P(arg) &&
2625 !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
2626 /* don't separate references for __call */
2627 arg = Z_REFVAL_P(arg);
2628 }
2629 }
2630
2631 if (EXPECTED(!must_wrap)) {
2632 ZVAL_COPY(param, arg);
2633 } else {
2634 Z_TRY_ADDREF_P(arg);
2635 ZVAL_NEW_REF(param, arg);
2636 }
2637 if (!name) {
2638 ZEND_CALL_NUM_ARGS(EX(call))++;
2639 arg_num++;
2640 param++;
2641 }
2642 } ZEND_HASH_FOREACH_END();
2643 }
2644 }
2645 FREE_OP(opline->op1_type, opline->op1.var);
2646 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2647}
2648
2649static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
2650{
2651#ifdef ZEND_VM_IP_GLOBAL_REG
2652 USE_OPLINE
2653
2654 SAVE_OPLINE();
2655#endif
2656 zend_missing_arg_error(execute_data);
2657 HANDLE_EXCEPTION();
2658}
2659
2660static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_verify_recv_arg_type_helper_SPEC(zval *op_1 ZEND_OPCODE_HANDLER_ARGS_DC)
2661{
2662 USE_OPLINE
2663
2664 SAVE_OPLINE();
2665 if (UNEXPECTED(!zend_verify_recv_arg_type(EX(func), opline->op1.num, op_1, CACHE_ADDR(opline->extended_value)))) {
2666 HANDLE_EXCEPTION();
2667 }
2668
2669 ZEND_VM_NEXT_OPCODE();
2670}
2671
2672static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2673{
2674 USE_OPLINE
2675 uint32_t arg_num = opline->op1.num;
2676
2677 if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
2678 ZEND_VM_TAIL_CALL(zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
2679 }
2680
2681 ZEND_VM_NEXT_OPCODE();
2682}
2683
2684static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_case_helper_SPEC(zval *op_1, zval *op_2 ZEND_OPCODE_HANDLER_ARGS_DC)
2685{
2686 int ret;
2687 USE_OPLINE
2688
2689 SAVE_OPLINE();
2690 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
2691 op_1 = ZVAL_UNDEFINED_OP1();
2692 }
2693 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
2694 op_2 = ZVAL_UNDEFINED_OP2();
2695 }
2696 ret = zend_compare(op_1, op_2);
2697 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
2698 zval_ptr_dtor_nogc(op_2);
2699 }
2700 ZEND_VM_SMART_BRANCH(ret == 0, 1);
2701}
2702
2703static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2704{
2705 USE_OPLINE
2706 zval *op1;
2707 HashTable *result_ht;
2708
2709 SAVE_OPLINE();
2710 op1 = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
2711 result_ht = Z_ARRVAL_P(EX_VAR(opline->result.var));
2712
2713add_unpack_again:
2714 if (EXPECTED(Z_TYPE_P(op1) == IS_ARRAY)) {
2715 HashTable *ht = Z_ARRVAL_P(op1);
2716 zval *val;
2717
2718 if (HT_IS_PACKED(ht) && (zend_hash_num_elements(result_ht) == 0 || HT_IS_PACKED(result_ht))) {
2719 zend_hash_extend(result_ht, result_ht->nNumUsed + zend_hash_num_elements(ht), 1);
2720 ZEND_HASH_FILL_PACKED(result_ht) {
2721 ZEND_HASH_PACKED_FOREACH_VAL(ht, val) {
2722 if (UNEXPECTED(Z_ISREF_P(val)) &&
2723 UNEXPECTED(Z_REFCOUNT_P(val) == 1)) {
2724 val = Z_REFVAL_P(val);
2725 }
2726 Z_TRY_ADDREF_P(val);
2727 ZEND_HASH_FILL_ADD(val);
2728 } ZEND_HASH_FOREACH_END();
2729 } ZEND_HASH_FILL_END();
2730 } else {
2731 zend_string *key;
2732
2733 ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
2734 if (UNEXPECTED(Z_ISREF_P(val)) &&
2735 UNEXPECTED(Z_REFCOUNT_P(val) == 1)) {
2736 val = Z_REFVAL_P(val);
2737 }
2738 Z_TRY_ADDREF_P(val);
2739 if (key) {
2740 zend_hash_update(result_ht, key, val);
2741 } else {
2742 if (!zend_hash_next_index_insert(result_ht, val)) {
2743 zend_cannot_add_element();
2744 zval_ptr_dtor_nogc(val);
2745 break;
2746 }
2747 }
2748 } ZEND_HASH_FOREACH_END();
2749 }
2750 } else if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
2751 zend_class_entry *ce = Z_OBJCE_P(op1);
2752 zend_object_iterator *iter;
2753
2754 if (!ce || !ce->get_iterator) {
2755 zend_type_error("Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(op1));
2756 } else {
2757 iter = ce->get_iterator(ce, op1, 0);
2758 if (UNEXPECTED(!iter)) {
2759 FREE_OP(opline->op1_type, opline->op1.var);
2760 if (!EG(exception)) {
2761 zend_throw_exception_ex(
2762 NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
2763 );
2764 }
2765 HANDLE_EXCEPTION();
2766 }
2767
2768 const zend_object_iterator_funcs *funcs = iter->funcs;
2769 if (funcs->rewind) {
2770 funcs->rewind(iter);
2771 }
2772
2773 for (; funcs->valid(iter) == SUCCESS; ) {
2774 zval *val;
2775
2776 if (UNEXPECTED(EG(exception) != NULL)) {
2777 break;
2778 }
2779
2780 val = funcs->get_current_data(iter);
2781 if (UNEXPECTED(EG(exception) != NULL)) {
2782 break;
2783 }
2784
2785 zval key;
2786 if (funcs->get_current_key) {
2787 funcs->get_current_key(iter, &key);
2788 if (UNEXPECTED(EG(exception) != NULL)) {
2789 break;
2790 }
2791
2792 if (UNEXPECTED(Z_TYPE(key) != IS_LONG && Z_TYPE(key) != IS_STRING)) {
2793 zend_throw_error(NULL,
2794 "Keys must be of type int|string during array unpacking");
2795 zval_ptr_dtor(&key);
2796 break;
2797 }
2798 } else {
2799 ZVAL_UNDEF(&key);
2800 }
2801
2802 ZVAL_DEREF(val);
2803 Z_TRY_ADDREF_P(val);
2804
2805 zend_ulong num_key;
2806 if (Z_TYPE(key) == IS_STRING && !ZEND_HANDLE_NUMERIC(Z_STR(key), num_key)) {
2807 zend_hash_update(result_ht, Z_STR(key), val);
2808 zval_ptr_dtor_str(&key);
2809 } else {
2810 zval_ptr_dtor(&key);
2811 if (!zend_hash_next_index_insert(result_ht, val)) {
2812 zend_cannot_add_element();
2813 zval_ptr_dtor_nogc(val);
2814 break;
2815 }
2816 }
2817
2818 funcs->move_forward(iter);
2819 if (UNEXPECTED(EG(exception))) {
2820 break;
2821 }
2822 }
2823
2824 zend_iterator_dtor(iter);
2825 }
2826 } else if (EXPECTED(Z_ISREF_P(op1))) {
2827 op1 = Z_REFVAL_P(op1);
2828 goto add_unpack_again;
2829 } else {
2830 zend_throw_error(NULL, "Only arrays and Traversables can be unpacked, %s given", zend_zval_value_name(op1));
2831 }
2832
2833 FREE_OP(opline->op1_type, opline->op1.var);
2834 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2835}
2836
2837static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2838{
2839 USE_OPLINE
2840 zval *varname;
2841 zend_string *name, *tmp_name = NULL;
2842 zend_class_entry *ce;
2843
2844 SAVE_OPLINE();
2845
2846 if (opline->op2_type == IS_CONST) {
2847 ce = CACHED_PTR(opline->extended_value);
2848 if (UNEXPECTED(ce == NULL)) {
2849 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);
2850 if (UNEXPECTED(ce == NULL)) {
2851 FREE_OP(opline->op1_type, opline->op1.var);
2852 HANDLE_EXCEPTION();
2853 }
2854 /*CACHE_PTR(opline->extended_value, ce);*/
2855 }
2856 } else if (opline->op2_type == IS_UNUSED) {
2857 ce = zend_fetch_class(NULL, opline->op2.num);
2858 if (UNEXPECTED(ce == NULL)) {
2859 FREE_OP(opline->op1_type, opline->op1.var);
2860 HANDLE_EXCEPTION();
2861 }
2862 } else {
2863 ce = Z_CE_P(EX_VAR(opline->op2.var));
2864 }
2865
2866 varname = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
2867 if (opline->op1_type == IS_CONST) {
2868 name = Z_STR_P(varname);
2869 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
2870 name = Z_STR_P(varname);
2871 } else {
2872 if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
2873 varname = ZVAL_UNDEFINED_OP1();
2874 }
2875 name = zval_try_get_tmp_string(varname, &tmp_name);
2876 if (UNEXPECTED(!name)) {
2877 FREE_OP(opline->op1_type, opline->op1.var);
2878 HANDLE_EXCEPTION();
2879 }
2880 }
2881
2882 zend_std_unset_static_property(ce, name);
2883
2884 zend_tmp_string_release(tmp_name);
2885 FREE_OP(opline->op1_type, opline->op1.var);
2886 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2887}
2888
2889static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
2890{
2891 USE_OPLINE
2892 zval *array;
2893 zval *value;
2894 uint32_t value_type;
2895 HashTable *fe_ht;
2896 HashPosition pos;
2897 Bucket *p;
2898 zend_object_iterator *iter;
2899
2900 array = EX_VAR(opline->op1.var);
2901 SAVE_OPLINE();
2902
2903 ZEND_ASSERT(Z_TYPE_P(array) == IS_OBJECT);
2904 if ((iter = zend_iterator_unwrap(array)) == NULL) {
2905 /* plain object */
2906
2907 fe_ht = Z_OBJPROP_P(array);
2908 pos = zend_hash_iterator_pos(Z_FE_ITER_P(array), fe_ht);
2909 p = fe_ht->arData + pos;
2910 while (1) {
2911 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
2912 /* reached end of iteration */
2913 goto fe_fetch_r_exit;
2914 }
2915 pos++;
2916 value = &p->val;
2917 value_type = Z_TYPE_INFO_P(value);
2918 if (EXPECTED(value_type != IS_UNDEF)) {
2919 if (UNEXPECTED(value_type == IS_INDIRECT)) {
2920 value = Z_INDIRECT_P(value);
2921 value_type = Z_TYPE_INFO_P(value);
2922 if (EXPECTED(value_type != IS_UNDEF)
2923 && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
2924 break;
2925 }
2926 } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
2927 || !p->key
2928 || zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
2929 break;
2930 }
2931 }
2932 p++;
2933 }
2934 EG(ht_iterators)[Z_FE_ITER_P(array)].pos = pos;
2935 if (RETURN_VALUE_USED(opline)) {
2936 if (UNEXPECTED(!p->key)) {
2937 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
2938 } else if (ZSTR_VAL(p->key)[0]) {
2939 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
2940 } else {
2941 const char *class_name, *prop_name;
2942 size_t prop_name_len;
2943 zend_unmangle_property_name_ex(
2944 p->key, &class_name, &prop_name, &prop_name_len);
2945 ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
2946 }
2947 }
2948 } else {
2949 const zend_object_iterator_funcs *funcs = iter->funcs;
2950 if (EXPECTED(++iter->index > 0)) {
2951 /* This could cause an endless loop if index becomes zero again.
2952 * In case that ever happens we need an additional flag. */
2953 funcs->move_forward(iter);
2954 if (UNEXPECTED(EG(exception) != NULL)) {
2955 UNDEF_RESULT();
2956 HANDLE_EXCEPTION();
2957 }
2958 if (UNEXPECTED(funcs->valid(iter) == FAILURE)) {
2959 /* reached end of iteration */
2960 if (UNEXPECTED(EG(exception) != NULL)) {
2961 UNDEF_RESULT();
2962 HANDLE_EXCEPTION();
2963 }
2964fe_fetch_r_exit:
2965 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
2966 ZEND_VM_CONTINUE();
2967 }
2968 }
2969 value = funcs->get_current_data(iter);
2970 if (UNEXPECTED(EG(exception) != NULL)) {
2971 UNDEF_RESULT();
2972 HANDLE_EXCEPTION();
2973 }
2974 if (!value) {
2975 /* failure in get_current_data */
2976 goto fe_fetch_r_exit;
2977 }
2978 if (RETURN_VALUE_USED(opline)) {
2979 if (funcs->get_current_key) {
2980 funcs->get_current_key(iter, EX_VAR(opline->result.var));
2981 if (UNEXPECTED(EG(exception) != NULL)) {
2982 UNDEF_RESULT();
2983 HANDLE_EXCEPTION();
2984 }
2985 } else {
2986 ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
2987 }
2988 }
2989 value_type = Z_TYPE_INFO_P(value);
2990 }
2991
2992 if (EXPECTED(opline->op2_type == IS_CV)) {
2993 zval *variable_ptr = EX_VAR(opline->op2.var);
2994 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
2995 } else {
2996 zval *res = EX_VAR(opline->op2.var);
2997 zend_refcounted *gc = Z_COUNTED_P(value);
2998
2999 ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
3000 if (Z_TYPE_INFO_REFCOUNTED(value_type)) {
3001 GC_ADDREF(gc);
3002 }
3003 }
3004 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3005}
3006
3007static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3008{
3009 USE_OPLINE
3010 zval *value;
3011 zend_result fetch_result;
3012 bool result;
3013
3014 SAVE_OPLINE();
3015
3016 fetch_result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
3017
3018 if (!(opline->extended_value & ZEND_ISEMPTY)) {
3019 result = fetch_result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
3020 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
3021 } else {
3022 result = fetch_result != SUCCESS || !i_zend_is_true(value);
3023 }
3024
3025 ZEND_VM_SMART_BRANCH(result, 1);
3026}
3027
3028static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3029{
3030 USE_OPLINE
3031
3032 ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting));
3033
3034 if (!E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))) {
3035 do {
3036 /* Do not silence fatal errors */
3037 EG(error_reporting) &= E_FATAL_ERRORS;
3038 if (!EG(error_reporting_ini_entry)) {
3039 zval *zv = zend_hash_find_known_hash(EG(ini_directives), ZSTR_KNOWN(ZEND_STR_ERROR_REPORTING));
3040 if (zv) {
3041 EG(error_reporting_ini_entry) = (zend_ini_entry *)Z_PTR_P(zv);
3042 } else {
3043 break;
3044 }
3045 }
3046 if (!EG(error_reporting_ini_entry)->modified) {
3047 if (!EG(modified_ini_directives)) {
3048 ALLOC_HASHTABLE(EG(modified_ini_directives));
3049 zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
3050 }
3051 if (EXPECTED(zend_hash_add_ptr(EG(modified_ini_directives), ZSTR_KNOWN(ZEND_STR_ERROR_REPORTING), EG(error_reporting_ini_entry)) != NULL)) {
3052 EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
3053 EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
3054 EG(error_reporting_ini_entry)->modified = 1;
3055 }
3056 }
3057 } while (0);
3058 }
3059 ZEND_VM_NEXT_OPCODE();
3060}
3061
3062static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3063{
3064 USE_OPLINE
3065
3066 if (!EG(no_extensions)) {
3067 SAVE_OPLINE();
3068 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, execute_data);
3069 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3070 }
3071 ZEND_VM_NEXT_OPCODE();
3072}
3073
3074static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3075{
3076 USE_OPLINE
3077
3078 if (!EG(no_extensions)) {
3079 SAVE_OPLINE();
3080 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, execute_data);
3081 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3082 }
3083 ZEND_VM_NEXT_OPCODE();
3084}
3085
3086static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3087{
3088 USE_OPLINE
3089
3090 if (!EG(no_extensions)) {
3091 SAVE_OPLINE();
3092 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, execute_data);
3093 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3094 }
3095 ZEND_VM_NEXT_OPCODE();
3096}
3097
3098static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3099{
3100 zval *zv;
3101 zend_class_entry *ce;
3102 USE_OPLINE
3103
3104 ce = CACHED_PTR(opline->extended_value);
3105 if (UNEXPECTED(ce == NULL)) {
3106 zend_string *rtd_key = Z_STR_P(RT_CONSTANT(opline, opline->op1));
3107 zv = zend_hash_find_known_hash(EG(class_table), rtd_key);
3108 ZEND_ASSERT(zv != NULL);
3109 ce = Z_CE_P(zv);
3110 if (!(ce->ce_flags & ZEND_ACC_LINKED)) {
3111 SAVE_OPLINE();
3112 ce = zend_do_link_class(ce, (opline->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL, rtd_key);
3113 if (!ce) {
3114 HANDLE_EXCEPTION();
3115 }
3116 }
3117 CACHE_PTR(opline->extended_value, ce);
3118 }
3119 Z_CE_P(EX_VAR(opline->result.var)) = ce;
3120 ZEND_VM_NEXT_OPCODE();
3121}
3122
3123static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3124{
3125 zend_function *func;
3126 USE_OPLINE
3127
3128 SAVE_OPLINE();
3129 func = (zend_function *) EX(func)->op_array.dynamic_func_defs[opline->op2.num];
3130 do_bind_function(func, RT_CONSTANT(opline, opline->op1));
3131 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3132}
3133
3134static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3135{
3136 USE_OPLINE
3137
3138 if ((uint32_t)++EG(ticks_count) >= opline->extended_value) {
3139 EG(ticks_count) = 0;
3140 if (zend_ticks_function) {
3141 SAVE_OPLINE();
3142 zend_fiber_switch_block();
3143 zend_ticks_function(opline->extended_value);
3144 zend_fiber_switch_unblock();
3145 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3146 }
3147 }
3148 ZEND_VM_NEXT_OPCODE();
3149}
3150
3151static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3152{
3153 USE_OPLINE
3154
3155 ZEND_VM_NEXT_OPCODE();
3156}
3157
3158static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3159{
3160 USE_OPLINE
3161
3162 ZEND_VM_NEXT_OPCODE();
3163}
3164
3165static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_dispatch_try_catch_finally_helper_SPEC(uint32_t try_catch_offset, uint32_t op_num ZEND_OPCODE_HANDLER_ARGS_DC)
3166{
3167 /* May be NULL during generator closing (only finally blocks are executed) */
3168 zend_object *ex = EG(exception);
3169
3170 /* Walk try/catch/finally structures upwards, performing the necessary actions */
3171 for (; try_catch_offset != (uint32_t) -1; try_catch_offset--) {
3172 zend_try_catch_element *try_catch =
3173 &EX(func)->op_array.try_catch_array[try_catch_offset];
3174
3175 if (op_num < try_catch->catch_op && ex) {
3176 /* Go to catch block */
3177 cleanup_live_vars(execute_data, op_num, try_catch->catch_op);
3178 ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->catch_op], 0);
3179
3180 } else if (op_num < try_catch->finally_op) {
3181 if (ex && zend_is_unwind_exit(ex)) {
3182 /* Don't execute finally blocks on exit (for now) */
3183 continue;
3184 }
3185
3186 /* Go to finally block */
3187 zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var);
3188 cleanup_live_vars(execute_data, op_num, try_catch->finally_op);
3189 Z_OBJ_P(fast_call) = EG(exception);
3190 EG(exception) = NULL;
3191 Z_OPLINE_NUM_P(fast_call) = (uint32_t)-1;
3192 ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->finally_op], 0);
3193
3194 } else if (op_num < try_catch->finally_end) {
3195 zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var);
3196
3197 /* cleanup incomplete RETURN statement */
3198 if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1
3199 && (EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2_type & (IS_TMP_VAR | IS_VAR))) {
3200 zval *return_value = EX_VAR(EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2.var);
3201
3202 zval_ptr_dtor(return_value);
3203 }
3204
3205 /* Chain potential exception from wrapping finally block */
3206 if (Z_OBJ_P(fast_call)) {
3207 if (ex) {
3208 if (zend_is_unwind_exit(ex) || zend_is_graceful_exit(ex)) {
3209 /* discard the previously thrown exception */
3210 OBJ_RELEASE(Z_OBJ_P(fast_call));
3211 } else {
3212 zend_exception_set_previous(ex, Z_OBJ_P(fast_call));
3213 }
3214 } else {
3215 ex = EG(exception) = Z_OBJ_P(fast_call);
3216 }
3217 }
3218 }
3219 }
3220
3221 /* Uncaught exception */
3222
3223 /* Don't use 0 because it gets replaced by zend_vm_gen.php. */
3224 if (zend_observer_fcall_op_array_extension != -1) {
3225 zend_observer_fcall_end(execute_data, NULL);
3226 }
3227 cleanup_live_vars(execute_data, op_num, 0);
3228 if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
3229 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
3230 EG(current_execute_data) = EX(prev_execute_data);
3231 zend_generator_close(generator, 1);
3232 ZEND_VM_RETURN();
3233 } else {
3234 /* We didn't execute RETURN, and have to initialize return_value */
3235 if (EX(return_value)) {
3236 ZVAL_UNDEF(EX(return_value));
3237 }
3238 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3239 }
3240}
3241
3242static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3243{
3244 const zend_op *throw_op = EG(opline_before_exception);
3245
3246 /* Exception was thrown before executing any op */
3247 if (UNEXPECTED(!throw_op)) {
3248 ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(-1, 0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
3249 }
3250
3251 uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes;
3252 int i, current_try_catch_offset = -1;
3253
3254 if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE)
3255 && throw_op->extended_value & ZEND_FREE_ON_RETURN) {
3256 /* exceptions thrown because of loop var destruction on return/break/...
3257 * are logically thrown at the end of the foreach loop, so adjust the
3258 * throw_op_num.
3259 */
3260 const zend_live_range *range = find_live_range(
3261 &EX(func)->op_array, throw_op_num, throw_op->op1.var);
3262 /* free op1 of the corresponding RETURN */
3263 for (i = throw_op_num; i < range->end; i++) {
3264 if (EX(func)->op_array.opcodes[i].opcode == ZEND_FREE
3265 || EX(func)->op_array.opcodes[i].opcode == ZEND_FE_FREE) {
3266 /* pass */
3267 } else {
3268 if (EX(func)->op_array.opcodes[i].opcode == ZEND_RETURN
3269 && (EX(func)->op_array.opcodes[i].op1_type & (IS_VAR|IS_TMP_VAR))) {
3270 zval_ptr_dtor(EX_VAR(EX(func)->op_array.opcodes[i].op1.var));
3271 }
3272 break;
3273 }
3274 }
3275 throw_op_num = range->end;
3276 }
3277
3278 /* Find the innermost try/catch/finally the exception was thrown in */
3279 for (i = 0; i < EX(func)->op_array.last_try_catch; i++) {
3280 zend_try_catch_element *try_catch = &EX(func)->op_array.try_catch_array[i];
3281 if (try_catch->try_op > throw_op_num) {
3282 /* further blocks will not be relevant... */
3283 break;
3284 }
3285 if (throw_op_num < try_catch->catch_op || throw_op_num < try_catch->finally_end) {
3286 current_try_catch_offset = i;
3287 }
3288 }
3289
3290 cleanup_unfinished_calls(execute_data, throw_op_num);
3291
3292 if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) {
3293 switch (throw_op->opcode) {
3294 case ZEND_ADD_ARRAY_ELEMENT:
3295 case ZEND_ADD_ARRAY_UNPACK:
3296 case ZEND_ROPE_INIT:
3297 case ZEND_ROPE_ADD:
3298 break; /* exception while building structures, live range handling will free those */
3299
3300 case ZEND_FETCH_CLASS:
3301 case ZEND_DECLARE_ANON_CLASS:
3302 break; /* return value is zend_class_entry pointer */
3303
3304 default:
3305 /* smart branch opcodes may not initialize result */
3306 if (!zend_is_smart_branch(throw_op)) {
3307 zval_ptr_dtor_nogc(EX_VAR(throw_op->result.var));
3308 }
3309 }
3310 }
3311
3312 ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(current_try_catch_offset, throw_op_num ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
3313}
3314
3315static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3316{
3317 USE_OPLINE
3318 int ret;
3319
3320 SAVE_OPLINE();
3321 ret = zend_user_opcode_handlers[opline->opcode](execute_data);
3322 opline = EX(opline);
3323
3324 switch (ret) {
3325 case ZEND_USER_OPCODE_CONTINUE:
3326 ZEND_VM_CONTINUE();
3327 case ZEND_USER_OPCODE_RETURN:
3328 if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
3329 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
3330 EG(current_execute_data) = EX(prev_execute_data);
3331 zend_generator_close(generator, 1);
3332 ZEND_VM_RETURN();
3333 } else {
3334 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3335 }
3336 case ZEND_USER_OPCODE_ENTER:
3337 ZEND_VM_ENTER();
3338 case ZEND_USER_OPCODE_LEAVE:
3339 ZEND_VM_LEAVE();
3340 case ZEND_USER_OPCODE_DISPATCH:
3341 ZEND_VM_DISPATCH(opline->opcode, opline);
3342 default:
3343 ZEND_VM_DISPATCH((uint8_t)(ret & 0xff), opline);
3344 }
3345}
3346
3347static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
3348{
3349 USE_OPLINE
3350
3351 SAVE_OPLINE();
3352 zend_throw_error(NULL, "Cannot yield from finally in a force-closed generator");
3353 FREE_OP(opline->op2_type, opline->op2.var);
3354 FREE_OP(opline->op1_type, opline->op1.var);
3355 UNDEF_RESULT();
3356 HANDLE_EXCEPTION();
3357}
3358
3359static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3360{
3361 USE_OPLINE
3362 zval *fast_call = EX_VAR(opline->op1.var);
3363 SAVE_OPLINE();
3364
3365 /* cleanup incomplete RETURN statement */
3366 if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1
3367 && (EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2_type & (IS_TMP_VAR | IS_VAR))) {
3368 zval *return_value = EX_VAR(EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2.var);
3369
3370 zval_ptr_dtor(return_value);
3371 }
3372
3373 /* cleanup delayed exception */
3374 if (Z_OBJ_P(fast_call) != NULL) {
3375 /* discard the previously thrown exception */
3376 OBJ_RELEASE(Z_OBJ_P(fast_call));
3377 Z_OBJ_P(fast_call) = NULL;
3378 }
3379
3380 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3381}
3382
3383static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3384{
3385 USE_OPLINE
3386 zval *fast_call = EX_VAR(opline->result.var);
3387
3388 Z_OBJ_P(fast_call) = NULL;
3389 /* set return address */
3390 Z_OPLINE_NUM_P(fast_call) = opline - EX(func)->op_array.opcodes;
3391 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op1), 0);
3392}
3393
3394static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3395{
3396 USE_OPLINE
3397 zval *fast_call = EX_VAR(opline->op1.var);
3398 uint32_t current_try_catch_offset, current_op_num;
3399
3400 if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1) {
3401 const zend_op *fast_ret = EX(func)->op_array.opcodes + Z_OPLINE_NUM_P(fast_call);
3402
3403 ZEND_VM_JMP_EX(fast_ret + 1, 0);
3404 }
3405
3406 /* special case for unhandled exceptions */
3407 EG(exception) = Z_OBJ_P(fast_call);
3408 Z_OBJ_P(fast_call) = NULL;
3409 current_try_catch_offset = opline->op2.num;
3410 current_op_num = opline - EX(func)->op_array.opcodes;
3411 ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(current_try_catch_offset, current_op_num ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
3412}
3413
3414static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3415{
3416 USE_OPLINE
3417
3418 if (EG(assertions) <= 0) {
3419 zend_op *target = OP_JMP_ADDR(opline, opline->op2);
3420 if (RETURN_VALUE_USED(opline)) {
3421 ZVAL_TRUE(EX_VAR(opline->result.var));
3422 }
3423 ZEND_VM_JMP_EX(target, 0);
3424 } else {
3425 ZEND_VM_NEXT_OPCODE();
3426 }
3427}
3428
3429static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3430{
3431 zend_array *args = NULL;
3432 zend_function *fbc = EX(func);
3433 zval *ret = EX(return_value);
3434 uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS);
3435 uint32_t num_args = EX_NUM_ARGS();
3436 zend_execute_data *call;
3437
3438 SAVE_OPLINE();
3439
3440 if (num_args) {
3441 zval *p = ZEND_CALL_ARG(execute_data, 1);
3442 zval *end = p + num_args;
3443
3444 args = zend_new_array(num_args);
3445 zend_hash_real_init_packed(args);
3446 ZEND_HASH_FILL_PACKED(args) {
3447 do {
3448 ZEND_HASH_FILL_ADD(p);
3449 p++;
3450 } while (p != end);
3451 } ZEND_HASH_FILL_END();
3452 }
3453
3454 call = execute_data;
3455 execute_data = EG(current_execute_data) = EX(prev_execute_data);
3456
3457 call->func = (fbc->op_array.fn_flags & ZEND_ACC_STATIC) ? fbc->op_array.scope->__callstatic : fbc->op_array.scope->__call;
3458 ZEND_ASSERT(zend_vm_calc_used_stack(2, call->func) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call));
3459 ZEND_CALL_NUM_ARGS(call) = 2;
3460
3461 ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name);
3462
3463 zval *call_args = ZEND_CALL_ARG(call, 2);
3464 if (args) {
3465 ZVAL_ARR(call_args, args);
3466 } else {
3467 ZVAL_EMPTY_ARRAY(call_args);
3468 }
3469 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3470 if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) {
3471 GC_ADDREF(call->extra_named_params);
3472 ZVAL_ARR(call_args, call->extra_named_params);
3473 } else {
3474 SEPARATE_ARRAY(call_args);
3475 zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref);
3476 }
3477 }
3478 zend_free_trampoline(fbc);
3479 fbc = call->func;
3480
3481 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
3482 if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3483 init_func_run_time_cache(&fbc->op_array);
3484 }
3485 execute_data = call;
3486 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
3487 if (EXPECTED(zend_execute_ex == execute_ex)) {
3488 LOAD_OPLINE_EX();
3489
3490
3491 ZEND_VM_ENTER_EX();
3492 } else {
3493 SAVE_OPLINE_EX();
3494
3495 execute_data = EX(prev_execute_data);
3496 if (execute_data) {
3497 LOAD_OPLINE();
3498 }
3499 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
3500 zend_execute_ex(call);
3501 }
3502 } else {
3503 zval retval;
3504
3505 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
3506
3507 EG(current_execute_data) = call;
3508
3509#if ZEND_DEBUG
3510 bool should_throw = zend_internal_call_should_throw(fbc, call);
3511#endif
3512
3513 if (ret == NULL) {
3514 ret = &retval;
3515 }
3516
3517 ZVAL_NULL(ret);
3518
3519 if (!zend_execute_internal) {
3520 /* saves one function call if zend_execute_internal is not used */
3521 fbc->internal_function.handler(call, ret);
3522 } else {
3523 zend_execute_internal(call, ret);
3524 }
3525
3526#if ZEND_DEBUG
3527 if (!EG(exception) && call->func) {
3528 if (should_throw) {
3529 zend_internal_call_arginfo_violation(call->func);
3530 }
3531 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
3532 zend_verify_internal_return_type(call->func, ret));
3533 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
3534 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
3535 zend_verify_internal_func_info(call->func, ret);
3536 }
3537#endif
3538
3539 EG(current_execute_data) = call->prev_execute_data;
3540
3541 zend_vm_stack_free_args(call);
3542 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3543 zend_free_extra_named_params(call->extra_named_params);
3544 }
3545 if (ret == &retval) {
3546 zval_ptr_dtor(ret);
3547 }
3548 }
3549
3550 execute_data = EG(current_execute_data);
3551
3552 if (!execute_data || !EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
3553 ZEND_VM_RETURN();
3554 }
3555
3556 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
3557 zend_object *object = Z_OBJ(call->This);
3558 OBJ_RELEASE(object);
3559 }
3560 zend_vm_stack_free_call_frame(call);
3561
3562 if (UNEXPECTED(EG(exception) != NULL)) {
3563 zend_rethrow_exception(execute_data);
3564 HANDLE_EXCEPTION_LEAVE();
3565 }
3566
3567 LOAD_OPLINE();
3568 ZEND_VM_INC_OPCODE();
3569 ZEND_VM_LEAVE();
3570}
3571
3572static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3573{
3574 zend_array *args = NULL;
3575 zend_function *fbc = EX(func);
3576 zval *ret = EX(return_value);
3577 uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS);
3578 uint32_t num_args = EX_NUM_ARGS();
3579 zend_execute_data *call;
3580
3581 SAVE_OPLINE();
3582
3583 if (num_args) {
3584 zval *p = ZEND_CALL_ARG(execute_data, 1);
3585 zval *end = p + num_args;
3586
3587 args = zend_new_array(num_args);
3588 zend_hash_real_init_packed(args);
3589 ZEND_HASH_FILL_PACKED(args) {
3590 do {
3591 ZEND_HASH_FILL_ADD(p);
3592 p++;
3593 } while (p != end);
3594 } ZEND_HASH_FILL_END();
3595 }
3596
3597 call = execute_data;
3598 execute_data = EG(current_execute_data) = EX(prev_execute_data);
3599
3600 call->func = (fbc->op_array.fn_flags & ZEND_ACC_STATIC) ? fbc->op_array.scope->__callstatic : fbc->op_array.scope->__call;
3601 ZEND_ASSERT(zend_vm_calc_used_stack(2, call->func) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call));
3602 ZEND_CALL_NUM_ARGS(call) = 2;
3603
3604 ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name);
3605
3606 zval *call_args = ZEND_CALL_ARG(call, 2);
3607 if (args) {
3608 ZVAL_ARR(call_args, args);
3609 } else {
3610 ZVAL_EMPTY_ARRAY(call_args);
3611 }
3612 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3613 if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) {
3614 GC_ADDREF(call->extra_named_params);
3615 ZVAL_ARR(call_args, call->extra_named_params);
3616 } else {
3617 SEPARATE_ARRAY(call_args);
3618 zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref);
3619 }
3620 }
3621 zend_free_trampoline(fbc);
3622 fbc = call->func;
3623
3624 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
3625 if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3626 init_func_run_time_cache(&fbc->op_array);
3627 }
3628 execute_data = call;
3629 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
3630 if (EXPECTED(zend_execute_ex == execute_ex)) {
3631 LOAD_OPLINE_EX();
3632 SAVE_OPLINE();
3633 zend_observer_fcall_begin_specialized(execute_data, false);
3634 ZEND_VM_ENTER_EX();
3635 } else {
3636 SAVE_OPLINE_EX();
3637 zend_observer_fcall_begin_specialized(execute_data, false);
3638 execute_data = EX(prev_execute_data);
3639 if (execute_data) {
3640 LOAD_OPLINE();
3641 }
3642 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
3643 zend_execute_ex(call);
3644 }
3645 } else {
3646 zval retval;
3647
3648 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
3649
3650 EG(current_execute_data) = call;
3651
3652#if ZEND_DEBUG
3653 bool should_throw = zend_internal_call_should_throw(fbc, call);
3654#endif
3655
3656 if (ret == NULL) {
3657 ret = &retval;
3658 }
3659
3660 ZVAL_NULL(ret);
3661 zend_observer_fcall_begin_specialized(call, false);
3662 if (!zend_execute_internal) {
3663 /* saves one function call if zend_execute_internal is not used */
3664 fbc->internal_function.handler(call, ret);
3665 } else {
3666 zend_execute_internal(call, ret);
3667 }
3668
3669#if ZEND_DEBUG
3670 if (!EG(exception) && call->func) {
3671 if (should_throw) {
3672 zend_internal_call_arginfo_violation(call->func);
3673 }
3674 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
3675 zend_verify_internal_return_type(call->func, ret));
3676 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
3677 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
3678 zend_verify_internal_func_info(call->func, ret);
3679 }
3680#endif
3681 zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
3682
3683 EG(current_execute_data) = call->prev_execute_data;
3684
3685 zend_vm_stack_free_args(call);
3686 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3687 zend_free_extra_named_params(call->extra_named_params);
3688 }
3689 if (ret == &retval) {
3690 zval_ptr_dtor(ret);
3691 }
3692 }
3693
3694 execute_data = EG(current_execute_data);
3695
3696 if (!execute_data || !EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
3697 ZEND_VM_RETURN();
3698 }
3699
3700 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
3701 zend_object *object = Z_OBJ(call->This);
3702 OBJ_RELEASE(object);
3703 }
3704 zend_vm_stack_free_call_frame(call);
3705
3706 if (UNEXPECTED(EG(exception) != NULL)) {
3707 zend_rethrow_exception(execute_data);
3708 HANDLE_EXCEPTION_LEAVE();
3709 }
3710
3711 LOAD_OPLINE();
3712 ZEND_VM_INC_OPCODE();
3713 ZEND_VM_LEAVE();
3714}
3715
3716static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3717{
3718 USE_OPLINE
3719 SAVE_OPLINE();
3720
3721 zval *result = EX_VAR(opline->result.var);
3722 ZVAL_NULL(result);
3723 zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3724 zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3725 if (EG(exception)) {
3726 FREE_OP(opline->op1_type, opline->op1.var);
3727 FREE_OP(opline->op2_type, opline->op2.var);
3728 HANDLE_EXCEPTION();
3729 }
3730
3731#if 0 || 0
3732 if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3733 zend_frameless_observed_call(execute_data);
3734 } else
3735#endif
3736 {
3737 zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline);
3738 function(result, arg1, arg2);
3739 }
3740
3741 FREE_OP(opline->op1_type, opline->op1.var);
3742 /* Set OP1 to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3743 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3744 ZVAL_UNDEF(EX_VAR(opline->op1.var));
3745 }
3746 FREE_OP(opline->op2_type, opline->op2.var);
3747 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3748}
3749
3750static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3751{
3752 USE_OPLINE
3753 SAVE_OPLINE();
3754
3755 zval *result = EX_VAR(opline->result.var);
3756 ZVAL_NULL(result);
3757 zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3758 zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3759 if (EG(exception)) {
3760 FREE_OP(opline->op1_type, opline->op1.var);
3761 FREE_OP(opline->op2_type, opline->op2.var);
3762 HANDLE_EXCEPTION();
3763 }
3764
3765#if 0 || 1
3766 if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3767 zend_frameless_observed_call(execute_data);
3768 } else
3769#endif
3770 {
3771 zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline);
3772 function(result, arg1, arg2);
3773 }
3774
3775 FREE_OP(opline->op1_type, opline->op1.var);
3776 /* Set OP1 to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3777 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3778 ZVAL_UNDEF(EX_VAR(opline->op1.var));
3779 }
3780 FREE_OP(opline->op2_type, opline->op2.var);
3781 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3782}
3783
3784static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3785{
3786 USE_OPLINE
3787 SAVE_OPLINE();
3788
3789 zval *result = EX_VAR(opline->result.var);
3790 ZVAL_NULL(result);
3791 zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3792 zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3793 zval *arg3 = get_op_data_zval_ptr_deref_r((opline+1)->op1_type, (opline+1)->op1);
3794 if (EG(exception)) {
3795 FREE_OP(opline->op1_type, opline->op1.var);
3796 FREE_OP(opline->op2_type, opline->op2.var);
3797 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3798 HANDLE_EXCEPTION();
3799 }
3800
3801#if 0 || 0
3802 if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3803 zend_frameless_observed_call(execute_data);
3804 } else
3805#endif
3806 {
3807 zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline);
3808 function(result, arg1, arg2, arg3);
3809 }
3810
3811 FREE_OP(opline->op1_type, opline->op1.var);
3812 /* Set to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3813 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3814 ZVAL_UNDEF(EX_VAR(opline->op1.var));
3815 }
3816 FREE_OP(opline->op2_type, opline->op2.var);
3817 if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) {
3818 ZVAL_UNDEF(EX_VAR(opline->op2.var));
3819 }
3820 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3821 ZEND_VM_NEXT_OPCODE_EX(1, 2);
3822}
3823
3824static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3825{
3826 USE_OPLINE
3827 SAVE_OPLINE();
3828
3829 zval *result = EX_VAR(opline->result.var);
3830 ZVAL_NULL(result);
3831 zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3832 zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3833 zval *arg3 = get_op_data_zval_ptr_deref_r((opline+1)->op1_type, (opline+1)->op1);
3834 if (EG(exception)) {
3835 FREE_OP(opline->op1_type, opline->op1.var);
3836 FREE_OP(opline->op2_type, opline->op2.var);
3837 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3838 HANDLE_EXCEPTION();
3839 }
3840
3841#if 0 || 1
3842 if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
3843 zend_frameless_observed_call(execute_data);
3844 } else
3845#endif
3846 {
3847 zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline);
3848 function(result, arg1, arg2, arg3);
3849 }
3850
3851 FREE_OP(opline->op1_type, opline->op1.var);
3852 /* Set to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3853 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3854 ZVAL_UNDEF(EX_VAR(opline->op1.var));
3855 }
3856 FREE_OP(opline->op2_type, opline->op2.var);
3857 if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) {
3858 ZVAL_UNDEF(EX_VAR(opline->op2.var));
3859 }
3860 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3861 ZEND_VM_NEXT_OPCODE_EX(1, 2);
3862}
3863
3864static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3865{
3866 USE_OPLINE
3867
3868 OPLINE = OP_JMP_ADDR(opline, opline->op1);
3869 ZEND_VM_CONTINUE();
3870}
3871
3872static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
3873{
3874 zend_atomic_bool_store_ex(&EG(vm_interrupt), false);
3875 SAVE_OPLINE();
3876 if (zend_atomic_bool_load_ex(&EG(timed_out))) {
3877 zend_timeout();
3878 } else if (zend_interrupt_function) {
3879 zend_interrupt_function(execute_data);
3880 if (EG(exception)) {
3881 /* We have to UNDEF result, because ZEND_HANDLE_EXCEPTION is going to free it */
3882 const zend_op *throw_op = EG(opline_before_exception);
3883
3884 if (throw_op
3885 && throw_op->result_type & (IS_TMP_VAR|IS_VAR)
3886 && throw_op->opcode != ZEND_ADD_ARRAY_ELEMENT
3887 && throw_op->opcode != ZEND_ADD_ARRAY_UNPACK
3888 && throw_op->opcode != ZEND_ROPE_INIT
3889 && throw_op->opcode != ZEND_ROPE_ADD) {
3890 ZVAL_UNDEF(ZEND_CALL_VAR(EG(current_execute_data), throw_op->result.var));
3891
3892 }
3893 }
3894 ZEND_VM_ENTER();
3895 }
3896 ZEND_VM_CONTINUE();
3897}
3898static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3899{
3900 USE_OPLINE
3901 zend_function *fbc;
3902 zval *function_name, *func;
3903 zend_execute_data *call;
3904
3905 fbc = CACHED_PTR(opline->result.num);
3906 if (UNEXPECTED(fbc == NULL)) {
3907 function_name = (zval*)RT_CONSTANT(opline, opline->op2);
3908 func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(function_name+1));
3909 if (UNEXPECTED(func == NULL)) {
3910 ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3911 }
3912 fbc = Z_FUNC_P(func);
3913 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3914 init_func_run_time_cache(&fbc->op_array);
3915 }
3916 CACHE_PTR(opline->result.num, fbc);
3917 }
3918 call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
3919 fbc, opline->extended_value, NULL);
3920 call->prev_execute_data = EX(call);
3921 EX(call) = call;
3922
3923 ZEND_VM_NEXT_OPCODE();
3924}
3925
3926static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3927{
3928 USE_OPLINE
3929 zval *function_name;
3930 zend_execute_data *call;
3931
3932 SAVE_OPLINE();
3933 function_name = RT_CONSTANT(opline, opline->op2);
3934
3935try_function_name:
3936 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
3937 call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
3938 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
3939 call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
3940 } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
3941 call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
3942 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
3943 function_name = Z_REFVAL_P(function_name);
3944 goto try_function_name;
3945 } else {
3946 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
3947 function_name = ZVAL_UNDEFINED_OP2();
3948 if (UNEXPECTED(EG(exception) != NULL)) {
3949 HANDLE_EXCEPTION();
3950 }
3951 }
3952 zend_throw_error(NULL, "Value of type %s is not callable",
3953 zend_zval_type_name(function_name));
3954 call = NULL;
3955 }
3956
3957 if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
3958
3959 if (UNEXPECTED(EG(exception))) {
3960 if (call) {
3961 if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
3962 zend_string_release_ex(call->func->common.function_name, 0);
3963 zend_free_trampoline(call->func);
3964 }
3965 zend_vm_stack_free_call_frame(call);
3966 }
3967 HANDLE_EXCEPTION();
3968 }
3969 } else if (!call) {
3970 HANDLE_EXCEPTION();
3971 }
3972
3973 call->prev_execute_data = EX(call);
3974 EX(call) = call;
3975
3976 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3977}
3978
3979static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3980{
3981 USE_OPLINE
3982 zval *func_name;
3983 zval *func;
3984 zend_function *fbc;
3985 zend_execute_data *call;
3986
3987 fbc = CACHED_PTR(opline->result.num);
3988 if (UNEXPECTED(fbc == NULL)) {
3989 func_name = (zval *)RT_CONSTANT(opline, opline->op2);
3990 func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name + 1));
3991 if (func == NULL) {
3992 func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name + 2));
3993 if (UNEXPECTED(func == NULL)) {
3994 ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3995 }
3996 }
3997 fbc = Z_FUNC_P(func);
3998 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3999 init_func_run_time_cache(&fbc->op_array);
4000 }
4001 CACHE_PTR(opline->result.num, fbc);
4002 }
4003
4004 call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
4005 fbc, opline->extended_value, NULL);
4006 call->prev_execute_data = EX(call);
4007 EX(call) = call;
4008
4009 ZEND_VM_NEXT_OPCODE();
4010}
4011
4012static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4013{
4014 USE_OPLINE
4015 zval *fname;
4016 zval *func;
4017 zend_function *fbc;
4018 zend_execute_data *call;
4019
4020 fbc = CACHED_PTR(opline->result.num);
4021 if (UNEXPECTED(fbc == NULL)) {
4022 fname = (zval*)RT_CONSTANT(opline, opline->op2);
4023 func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(fname));
4024 ZEND_ASSERT(func != NULL && "Function existence must be checked at compile time");
4025 fbc = Z_FUNC_P(func);
4026 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
4027 init_func_run_time_cache(&fbc->op_array);
4028 }
4029 CACHE_PTR(opline->result.num, fbc);
4030 }
4031
4032 call = _zend_vm_stack_push_call_frame_ex(
4033 opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
4034 fbc, opline->extended_value, NULL);
4035 call->prev_execute_data = EX(call);
4036 EX(call) = call;
4037
4038 ZEND_VM_NEXT_OPCODE();
4039}
4040
4041static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4042{
4043 USE_OPLINE
4044 zend_function *fbc;
4045 zend_execute_data *call;
4046 fbc = CACHED_PTR(opline->result.num);
4047 if (UNEXPECTED(fbc == NULL)) {
4048 fbc = Z_PTR(EG(function_table)->arData[Z_EXTRA_P(RT_CONSTANT(opline, opline->op2))].val);
4049 CACHE_PTR(opline->result.num, fbc);
4050 }
4051 call = _zend_vm_stack_push_call_frame_ex(
4052 opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
4053 fbc, opline->extended_value, NULL);
4054 call->prev_execute_data = EX(call);
4055 EX(call) = call;
4056 ZEND_VM_NEXT_OPCODE();
4057}
4058
4059static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4060{
4061 USE_OPLINE
4062 uint32_t arg_num;
4063 zval *param;
4064
4065 ZEND_VM_REPEATABLE_OPCODE
4066
4067 arg_num = opline->op1.num;
4068 param = EX_VAR(opline->result.var);
4069 if (arg_num > EX_NUM_ARGS()) {
4070 zval *default_value = RT_CONSTANT(opline, opline->op2);
4071
4072 if (Z_OPT_TYPE_P(default_value) == IS_CONSTANT_AST) {
4073 zval *cache_val = (zval*)CACHE_ADDR(Z_CACHE_SLOT_P(default_value));
4074
4075 /* we keep in cache only not refcounted values */
4076 if (Z_TYPE_P(cache_val) != IS_UNDEF) {
4077 ZVAL_COPY_VALUE(param, cache_val);
4078 } else {
4079 SAVE_OPLINE();
4080 ZVAL_COPY(param, default_value);
4081 zend_ast_evaluate_ctx ctx = {0};
4082 if (UNEXPECTED(zval_update_constant_with_ctx(param, EX(func)->op_array.scope, &ctx) != SUCCESS)) {
4083 zval_ptr_dtor_nogc(param);
4084 ZVAL_UNDEF(param);
4085 HANDLE_EXCEPTION();
4086 }
4087 if (!Z_REFCOUNTED_P(param) && !ctx.had_side_effects) {
4088 ZVAL_COPY_VALUE(cache_val, param);
4089 }
4090 }
4091 goto recv_init_check_type;
4092 } else {
4093 ZVAL_COPY(param, default_value);
4094 }
4095 } else {
4096recv_init_check_type:
4097 if ((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0) {
4098 SAVE_OPLINE();
4099 if (UNEXPECTED(!zend_verify_recv_arg_type(EX(func), arg_num, param, CACHE_ADDR(opline->extended_value)))) {
4100 HANDLE_EXCEPTION();
4101 }
4102 }
4103 }
4104
4105 ZEND_VM_REPEAT_OPCODE(ZEND_RECV_INIT);
4106 ZEND_VM_NEXT_OPCODE();
4107}
4108
4109static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4110{
4111 USE_OPLINE
4112 zval *function_name;
4113 zend_execute_data *call;
4114
4115 SAVE_OPLINE();
4116 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
4117
4118try_function_name:
4119 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
4120 call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
4121 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
4122 call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
4123 } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
4124 call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
4125 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
4126 function_name = Z_REFVAL_P(function_name);
4127 goto try_function_name;
4128 } else {
4129 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
4130 function_name = ZVAL_UNDEFINED_OP2();
4131 if (UNEXPECTED(EG(exception) != NULL)) {
4132 HANDLE_EXCEPTION();
4133 }
4134 }
4135 zend_throw_error(NULL, "Value of type %s is not callable",
4136 zend_zval_type_name(function_name));
4137 call = NULL;
4138 }
4139
4140 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) {
4141 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
4142 if (UNEXPECTED(EG(exception))) {
4143 if (call) {
4144 if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4145 zend_string_release_ex(call->func->common.function_name, 0);
4146 zend_free_trampoline(call->func);
4147 }
4148 zend_vm_stack_free_call_frame(call);
4149 }
4150 HANDLE_EXCEPTION();
4151 }
4152 } else if (!call) {
4153 HANDLE_EXCEPTION();
4154 }
4155
4156 call->prev_execute_data = EX(call);
4157 EX(call) = call;
4158
4159 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4160}
4161
4162static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4163{
4164 USE_OPLINE
4165 uint32_t arg_num = opline->op1.num;
4166 zval *param;
4167
4168 if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
4169 ZEND_VM_TAIL_CALL(zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4170 }
4171
4172 param = EX_VAR(opline->result.var);
4173
4174 if (UNEXPECTED(!(opline->op2.num & (1u << Z_TYPE_P(param))))) {
4175 ZEND_VM_TAIL_CALL(zend_verify_recv_arg_type_helper_SPEC(param ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
4176 }
4177
4178 ZEND_VM_NEXT_OPCODE();
4179}
4180
4181static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4182{
4183 USE_OPLINE
4184 uint32_t arg_num = opline->op1.num;
4185 uint32_t arg_count = EX_NUM_ARGS();
4186 zval *params;
4187
4188 SAVE_OPLINE();
4189
4190 params = EX_VAR(opline->result.var);
4191
4192 if (arg_num <= arg_count) {
4193 ZEND_ASSERT(EX(func)->common.fn_flags & ZEND_ACC_VARIADIC);
4194 ZEND_ASSERT(EX(func)->common.num_args == arg_num - 1);
4195 zend_arg_info *arg_info = &EX(func)->common.arg_info[arg_num - 1];
4196
4197 array_init_size(params, arg_count - arg_num + 1);
4198 zend_hash_real_init_packed(Z_ARRVAL_P(params));
4199 ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(params)) {
4200 zval *param = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
4201 if (ZEND_TYPE_IS_SET(arg_info->type)) {
4202 ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_FREE_EXTRA_ARGS);
4203 do {
4204 if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param, CACHE_ADDR(opline->extended_value)))) {
4205 ZEND_HASH_FILL_FINISH();
4206 HANDLE_EXCEPTION();
4207 }
4208
4209 if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4210 ZEND_HASH_FILL_ADD(param);
4211 param++;
4212 } while (++arg_num <= arg_count);
4213 } else {
4214 do {
4215 if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4216 ZEND_HASH_FILL_ADD(param);
4217 param++;
4218 } while (++arg_num <= arg_count);
4219 }
4220 } ZEND_HASH_FILL_END();
4221 } else {
4222 ZVAL_EMPTY_ARRAY(params);
4223 }
4224
4225 if (EX_CALL_INFO() & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
4226 zend_string *name;
4227 zval *param;
4228 zend_arg_info *arg_info = &EX(func)->common.arg_info[EX(func)->common.num_args];
4229 if (ZEND_TYPE_IS_SET(arg_info->type)) {
4230 SEPARATE_ARRAY(params);
4231 ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) {
4232 if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param, CACHE_ADDR(opline->extended_value)))) {
4233 HANDLE_EXCEPTION();
4234 }
4235 Z_TRY_ADDREF_P(param);
4236 zend_hash_add_new(Z_ARRVAL_P(params), name, param);
4237 } ZEND_HASH_FOREACH_END();
4238 } else if (zend_hash_num_elements(Z_ARRVAL_P(params)) == 0) {
4239 GC_ADDREF(EX(extra_named_params));
4240 ZVAL_ARR(params, EX(extra_named_params));
4241 } else {
4242 SEPARATE_ARRAY(params);
4243 ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) {
4244 Z_TRY_ADDREF_P(param);
4245 zend_hash_add_new(Z_ARRVAL_P(params), name, param);
4246 } ZEND_HASH_FOREACH_END();
4247 }
4248 }
4249
4250 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4251}
4252
4253static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4254{
4255 USE_OPLINE
4256 SAVE_OPLINE();
4257
4258 zval *result = EX_VAR(opline->result.var);
4259 ZVAL_NULL(result);
4260 zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
4261 if (EG(exception)) {
4262 FREE_OP(opline->op1_type, opline->op1.var);
4263 HANDLE_EXCEPTION();
4264 }
4265
4266#if 0 || 0
4267 if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
4268 zend_frameless_observed_call(execute_data);
4269 } else
4270#endif
4271 {
4272 zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline);
4273 function(result, arg1);
4274 }
4275 FREE_OP(opline->op1_type, opline->op1.var);
4276 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4277}
4278
4279static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4280{
4281 USE_OPLINE
4282 SAVE_OPLINE();
4283
4284 zval *result = EX_VAR(opline->result.var);
4285 ZVAL_NULL(result);
4286 zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
4287 if (EG(exception)) {
4288 FREE_OP(opline->op1_type, opline->op1.var);
4289 HANDLE_EXCEPTION();
4290 }
4291
4292#if 0 || 1
4293 if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
4294 zend_frameless_observed_call(execute_data);
4295 } else
4296#endif
4297 {
4298 zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline);
4299 function(result, arg1);
4300 }
4301 FREE_OP(opline->op1_type, opline->op1.var);
4302 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4303}
4304
4305static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4306{
4307 USE_OPLINE
4308 zval *function_name;
4309 zend_execute_data *call;
4310
4311 SAVE_OPLINE();
4312 function_name = EX_VAR(opline->op2.var);
4313
4314try_function_name:
4315 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
4316 call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
4317 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
4318 call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
4319 } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
4320 call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
4321 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
4322 function_name = Z_REFVAL_P(function_name);
4323 goto try_function_name;
4324 } else {
4325 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
4326 function_name = ZVAL_UNDEFINED_OP2();
4327 if (UNEXPECTED(EG(exception) != NULL)) {
4328 HANDLE_EXCEPTION();
4329 }
4330 }
4331 zend_throw_error(NULL, "Value of type %s is not callable",
4332 zend_zval_type_name(function_name));
4333 call = NULL;
4334 }
4335
4336 if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
4337
4338 if (UNEXPECTED(EG(exception))) {
4339 if (call) {
4340 if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4341 zend_string_release_ex(call->func->common.function_name, 0);
4342 zend_free_trampoline(call->func);
4343 }
4344 zend_vm_stack_free_call_frame(call);
4345 }
4346 HANDLE_EXCEPTION();
4347 }
4348 } else if (!call) {
4349 HANDLE_EXCEPTION();
4350 }
4351
4352 call->prev_execute_data = EX(call);
4353 EX(call) = call;
4354
4355 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4356}
4357
4358static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4359{
4360 USE_OPLINE
4361 zval *op1;
4362
4363 op1 = RT_CONSTANT(opline, opline->op1);
4364 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
4365 ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
4366 ZEND_VM_NEXT_OPCODE();
4367 }
4368
4369 ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(op1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
4370}
4371
4372static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4373{
4374 USE_OPLINE
4375 zval *val;
4376
4377 val = RT_CONSTANT(opline, opline->op1);
4378 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4379 ZVAL_FALSE(EX_VAR(opline->result.var));
4380 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4381 /* The result and op1 can be the same cv zval */
4382 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
4383 ZVAL_TRUE(EX_VAR(opline->result.var));
4384 if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
4385 SAVE_OPLINE();
4386 ZVAL_UNDEFINED_OP1();
4387 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4388 }
4389 } else {
4390 SAVE_OPLINE();
4391 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
4392
4393 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4394 }
4395 ZEND_VM_NEXT_OPCODE();
4396}
4397
4398static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4399{
4400 USE_OPLINE
4401 zval *z;
4402
4403 SAVE_OPLINE();
4404 z = RT_CONSTANT(opline, opline->op1);
4405
4406 if (Z_TYPE_P(z) == IS_STRING) {
4407 zend_string *str = Z_STR_P(z);
4408
4409 if (ZSTR_LEN(str) != 0) {
4410 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
4411 }
4412 } else {
4413 zend_string *str = zval_get_string_func(z);
4414
4415 if (ZSTR_LEN(str) != 0) {
4416 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
4417 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
4418 ZVAL_UNDEFINED_OP1();
4419 }
4420 zend_string_release_ex(str, 0);
4421 }
4422
4423 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4424}
4425
4426static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4427{
4428 USE_OPLINE
4429 zval *val;
4430 uint8_t op1_type;
4431
4432 val = RT_CONSTANT(opline, opline->op1);
4433
4434 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4435 ZEND_VM_NEXT_OPCODE();
4436 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4437 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4438 SAVE_OPLINE();
4439 ZVAL_UNDEFINED_OP1();
4440 if (UNEXPECTED(EG(exception))) {
4441 HANDLE_EXCEPTION();
4442 }
4443 }
4444 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4445 }
4446
4447 SAVE_OPLINE();
4448 op1_type = IS_CONST;
4449 if (i_zend_is_true(val)) {
4450 opline++;
4451 } else {
4452 opline = OP_JMP_ADDR(opline, opline->op2);
4453 }
4454 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
4455 zval_ptr_dtor_nogc(val);
4456 }
4457 ZEND_VM_JMP(opline);
4458}
4459
4460static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4461{
4462 USE_OPLINE
4463 zval *val;
4464 uint8_t op1_type;
4465
4466 val = RT_CONSTANT(opline, opline->op1);
4467
4468 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4469 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4470 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4471 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4472 SAVE_OPLINE();
4473 ZVAL_UNDEFINED_OP1();
4474 if (UNEXPECTED(EG(exception))) {
4475 HANDLE_EXCEPTION();
4476 }
4477 }
4478 ZEND_VM_NEXT_OPCODE();
4479 }
4480
4481 SAVE_OPLINE();
4482 op1_type = IS_CONST;
4483 if (i_zend_is_true(val)) {
4484 opline = OP_JMP_ADDR(opline, opline->op2);
4485 } else {
4486 opline++;
4487 }
4488 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
4489 zval_ptr_dtor_nogc(val);
4490 }
4491 ZEND_VM_JMP(opline);
4492}
4493
4494static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4495{
4496 USE_OPLINE
4497 zval *val;
4498 bool ret;
4499
4500 val = RT_CONSTANT(opline, opline->op1);
4501
4502 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4503 ZVAL_TRUE(EX_VAR(opline->result.var));
4504 ZEND_VM_NEXT_OPCODE();
4505 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4506 ZVAL_FALSE(EX_VAR(opline->result.var));
4507 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4508 SAVE_OPLINE();
4509 ZVAL_UNDEFINED_OP1();
4510 if (UNEXPECTED(EG(exception))) {
4511 HANDLE_EXCEPTION();
4512 }
4513 }
4514 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4515 }
4516
4517 SAVE_OPLINE();
4518 ret = i_zend_is_true(val);
4519
4520 if (ret) {
4521 ZVAL_TRUE(EX_VAR(opline->result.var));
4522 opline++;
4523 } else {
4524 ZVAL_FALSE(EX_VAR(opline->result.var));
4525 opline = OP_JMP_ADDR(opline, opline->op2);
4526 }
4527 ZEND_VM_JMP(opline);
4528}
4529
4530static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4531{
4532 USE_OPLINE
4533 zval *val;
4534 bool ret;
4535
4536 val = RT_CONSTANT(opline, opline->op1);
4537
4538 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4539 ZVAL_TRUE(EX_VAR(opline->result.var));
4540 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4541 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4542 ZVAL_FALSE(EX_VAR(opline->result.var));
4543 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4544 SAVE_OPLINE();
4545 ZVAL_UNDEFINED_OP1();
4546 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4547 } else {
4548 ZEND_VM_NEXT_OPCODE();
4549 }
4550 }
4551
4552 SAVE_OPLINE();
4553 ret = i_zend_is_true(val);
4554
4555 if (ret) {
4556 ZVAL_TRUE(EX_VAR(opline->result.var));
4557 opline = OP_JMP_ADDR(opline, opline->op2);
4558 } else {
4559 ZVAL_FALSE(EX_VAR(opline->result.var));
4560 opline++;
4561 }
4562 ZEND_VM_JMP(opline);
4563}
4564
4565static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4566{
4567 USE_OPLINE
4568 zval *retval_ptr;
4569 zval *return_value;
4570
4571 retval_ptr = RT_CONSTANT(opline, opline->op1);
4572 return_value = EX(return_value);
4573
4574 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
4575 SAVE_OPLINE();
4576 retval_ptr = ZVAL_UNDEFINED_OP1();
4577 if (return_value) {
4578 ZVAL_NULL(return_value);
4579 }
4580 } else if (!return_value) {
4581 if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
4582 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
4583 SAVE_OPLINE();
4584 rc_dtor_func(Z_COUNTED_P(retval_ptr));
4585 }
4586 }
4587 } else {
4588 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
4589 ZVAL_COPY_VALUE(return_value, retval_ptr);
4590 if (IS_CONST == IS_CONST) {
4591 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
4592 Z_ADDREF_P(return_value);
4593 }
4594 }
4595 } else if (IS_CONST == IS_CV) {
4596 do {
4597 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4598 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
4599 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
4600 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4601 ZVAL_COPY_VALUE(return_value, retval_ptr);
4602 if (GC_MAY_LEAK(ref)) {
4603 SAVE_OPLINE();
4604 gc_possible_root(ref);
4605 }
4606 ZVAL_NULL(retval_ptr);
4607 break;
4608 } else {
4609 Z_ADDREF_P(retval_ptr);
4610 }
4611 } else {
4612 retval_ptr = Z_REFVAL_P(retval_ptr);
4613 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4614 Z_ADDREF_P(retval_ptr);
4615 }
4616 }
4617 }
4618 ZVAL_COPY_VALUE(return_value, retval_ptr);
4619 } while (0);
4620 } else /* if (IS_CONST == IS_VAR) */ {
4621 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4622 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4623
4624 retval_ptr = Z_REFVAL_P(retval_ptr);
4625 ZVAL_COPY_VALUE(return_value, retval_ptr);
4626 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4627 efree_size(ref, sizeof(zend_reference));
4628 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4629 Z_ADDREF_P(retval_ptr);
4630 }
4631 } else {
4632 ZVAL_COPY_VALUE(return_value, retval_ptr);
4633 }
4634 }
4635 }
4636
4637
4638
4639 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4640}
4641
4642static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4643{
4644 USE_OPLINE
4645 zval *retval_ptr;
4646 zval *return_value;
4647 zval observer_retval;
4648
4649 retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
4650 return_value = EX(return_value);
4651 if (!return_value) { return_value = &observer_retval; };
4652 if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
4653 SAVE_OPLINE();
4654 retval_ptr = ZVAL_UNDEFINED_OP1();
4655 if (return_value) {
4656 ZVAL_NULL(return_value);
4657 }
4658 } else if (!return_value) {
4659 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
4660 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
4661 SAVE_OPLINE();
4662 rc_dtor_func(Z_COUNTED_P(retval_ptr));
4663 }
4664 }
4665 } else {
4666 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
4667 ZVAL_COPY_VALUE(return_value, retval_ptr);
4668 if (opline->op1_type == IS_CONST) {
4669 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
4670 Z_ADDREF_P(return_value);
4671 }
4672 }
4673 } else if (opline->op1_type == IS_CV) {
4674 do {
4675 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4676 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
4677 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
4678 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4679 ZVAL_COPY_VALUE(return_value, retval_ptr);
4680 if (GC_MAY_LEAK(ref)) {
4681 SAVE_OPLINE();
4682 gc_possible_root(ref);
4683 }
4684 ZVAL_NULL(retval_ptr);
4685 break;
4686 } else {
4687 Z_ADDREF_P(retval_ptr);
4688 }
4689 } else {
4690 retval_ptr = Z_REFVAL_P(retval_ptr);
4691 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4692 Z_ADDREF_P(retval_ptr);
4693 }
4694 }
4695 }
4696 ZVAL_COPY_VALUE(return_value, retval_ptr);
4697 } while (0);
4698 } else /* if (opline->op1_type == IS_VAR) */ {
4699 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4700 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4701
4702 retval_ptr = Z_REFVAL_P(retval_ptr);
4703 ZVAL_COPY_VALUE(return_value, retval_ptr);
4704 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4705 efree_size(ref, sizeof(zend_reference));
4706 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4707 Z_ADDREF_P(retval_ptr);
4708 }
4709 } else {
4710 ZVAL_COPY_VALUE(return_value, retval_ptr);
4711 }
4712 }
4713 }
4714 SAVE_OPLINE();
4715 zend_observer_fcall_end(execute_data, return_value);
4716 if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
4717 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4718}
4719
4720static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4721{
4722 USE_OPLINE
4723 zval *retval_ptr;
4724 zval *return_value;
4725
4726 SAVE_OPLINE();
4727
4728 return_value = EX(return_value);
4729
4730 do {
4731 if ((IS_CONST & (IS_CONST|IS_TMP_VAR)) ||
4732 (IS_CONST == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
4733 /* Not supposed to happen, but we'll allow it */
4734 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4735
4736 retval_ptr = RT_CONSTANT(opline, opline->op1);
4737 if (!return_value) {
4738
4739 } else {
4740 if (IS_CONST == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4741 ZVAL_COPY_VALUE(return_value, retval_ptr);
4742 break;
4743 }
4744
4745 ZVAL_NEW_REF(return_value, retval_ptr);
4746 if (IS_CONST == IS_CONST) {
4747 Z_TRY_ADDREF_P(retval_ptr);
4748 }
4749 }
4750 break;
4751 }
4752
4753 retval_ptr = zend_get_bad_ptr();
4754
4755 if (IS_CONST == IS_VAR) {
4756 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
4757 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
4758 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4759 if (return_value) {
4760 ZVAL_NEW_REF(return_value, retval_ptr);
4761 } else {
4762
4763 }
4764 break;
4765 }
4766 }
4767
4768 if (return_value) {
4769 if (Z_ISREF_P(retval_ptr)) {
4770 Z_ADDREF_P(retval_ptr);
4771 } else {
4772 ZVAL_MAKE_REF_EX(retval_ptr, 2);
4773 }
4774 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
4775 }
4776
4777 } while (0);
4778
4779
4780 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4781}
4782
4783static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4784{
4785 USE_OPLINE
4786 zval *retval_ptr;
4787 zval *return_value;
4788 zval observer_retval;
4789
4790 SAVE_OPLINE();
4791
4792 return_value = EX(return_value);
4793 if (!return_value) { return_value = &observer_retval; };
4794 do {
4795 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR)) ||
4796 (opline->op1_type == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
4797 /* Not supposed to happen, but we'll allow it */
4798 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4799
4800 retval_ptr = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
4801 if (!return_value) {
4802 FREE_OP(opline->op1_type, opline->op1.var);
4803 } else {
4804 if (opline->op1_type == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4805 ZVAL_COPY_VALUE(return_value, retval_ptr);
4806 break;
4807 }
4808
4809 ZVAL_NEW_REF(return_value, retval_ptr);
4810 if (opline->op1_type == IS_CONST) {
4811 Z_TRY_ADDREF_P(retval_ptr);
4812 }
4813 }
4814 break;
4815 }
4816
4817 retval_ptr = get_zval_ptr_ptr(opline->op1_type, opline->op1, BP_VAR_W);
4818
4819 if (opline->op1_type == IS_VAR) {
4820 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
4821 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
4822 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4823 if (return_value) {
4824 ZVAL_NEW_REF(return_value, retval_ptr);
4825 } else {
4826 FREE_OP(opline->op1_type, opline->op1.var);
4827 }
4828 break;
4829 }
4830 }
4831
4832 if (return_value) {
4833 if (Z_ISREF_P(retval_ptr)) {
4834 Z_ADDREF_P(retval_ptr);
4835 } else {
4836 ZVAL_MAKE_REF_EX(retval_ptr, 2);
4837 }
4838 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
4839 }
4840
4841 FREE_OP(opline->op1_type, opline->op1.var);
4842 } while (0);
4843
4844 zend_observer_fcall_end(execute_data, return_value);
4845 if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
4846 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4847}
4848
4849static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4850{
4851 USE_OPLINE
4852 zval *retval;
4853
4854 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
4855
4856 SAVE_OPLINE();
4857 retval = RT_CONSTANT(opline, opline->op1);
4858
4859 /* Copy return value into generator->retval */
4860 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
4861 ZVAL_COPY_VALUE(&generator->retval, retval);
4862 if (IS_CONST == IS_CONST) {
4863 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
4864 Z_ADDREF(generator->retval);
4865 }
4866 }
4867 } else if (IS_CONST == IS_CV) {
4868 ZVAL_COPY_DEREF(&generator->retval, retval);
4869 } else /* if (IS_CONST == IS_VAR) */ {
4870 if (UNEXPECTED(Z_ISREF_P(retval))) {
4871 zend_refcounted *ref = Z_COUNTED_P(retval);
4872
4873 retval = Z_REFVAL_P(retval);
4874 ZVAL_COPY_VALUE(&generator->retval, retval);
4875 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4876 efree_size(ref, sizeof(zend_reference));
4877 } else if (Z_OPT_REFCOUNTED_P(retval)) {
4878 Z_ADDREF_P(retval);
4879 }
4880 } else {
4881 ZVAL_COPY_VALUE(&generator->retval, retval);
4882 }
4883 }
4884
4885 EG(current_execute_data) = EX(prev_execute_data);
4886
4887 /* Close the generator to free up resources */
4888 zend_generator_close(generator, 1);
4889
4890 /* Pass execution back to handling code */
4891 ZEND_VM_RETURN();
4892}
4893
4894static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4895{
4896 USE_OPLINE
4897 zval *retval;
4898
4899 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
4900
4901 SAVE_OPLINE();
4902 retval = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
4903
4904 /* Copy return value into generator->retval */
4905 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
4906 ZVAL_COPY_VALUE(&generator->retval, retval);
4907 if (opline->op1_type == IS_CONST) {
4908 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
4909 Z_ADDREF(generator->retval);
4910 }
4911 }
4912 } else if (opline->op1_type == IS_CV) {
4913 ZVAL_COPY_DEREF(&generator->retval, retval);
4914 } else /* if (opline->op1_type == IS_VAR) */ {
4915 if (UNEXPECTED(Z_ISREF_P(retval))) {
4916 zend_refcounted *ref = Z_COUNTED_P(retval);
4917
4918 retval = Z_REFVAL_P(retval);
4919 ZVAL_COPY_VALUE(&generator->retval, retval);
4920 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4921 efree_size(ref, sizeof(zend_reference));
4922 } else if (Z_OPT_REFCOUNTED_P(retval)) {
4923 Z_ADDREF_P(retval);
4924 }
4925 } else {
4926 ZVAL_COPY_VALUE(&generator->retval, retval);
4927 }
4928 }
4929
4930 zend_observer_fcall_end(generator->execute_data, &generator->retval);
4931
4932 EG(current_execute_data) = EX(prev_execute_data);
4933
4934 /* Close the generator to free up resources */
4935 zend_generator_close(generator, 1);
4936
4937 /* Pass execution back to handling code */
4938 ZEND_VM_RETURN();
4939}
4940
4941static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4942{
4943 USE_OPLINE
4944 zval *value;
4945
4946 SAVE_OPLINE();
4947 value = RT_CONSTANT(opline, opline->op1);
4948
4949 do {
4950 if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
4951 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
4952 value = Z_REFVAL_P(value);
4953 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
4954 break;
4955 }
4956 }
4957 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
4958 ZVAL_UNDEFINED_OP1();
4959 if (UNEXPECTED(EG(exception) != NULL)) {
4960 HANDLE_EXCEPTION();
4961 }
4962 }
4963 zend_throw_error(NULL, "Can only throw objects");
4964
4965 HANDLE_EXCEPTION();
4966 }
4967 } while (0);
4968
4969 zend_exception_save();
4970 Z_TRY_ADDREF_P(value);
4971 zend_throw_exception_object(value);
4972 zend_exception_restore();
4973
4974 HANDLE_EXCEPTION();
4975}
4976
4977static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4978{
4979 USE_OPLINE
4980 zend_class_entry *ce, *catch_ce;
4981 zend_object *exception;
4982
4983 SAVE_OPLINE();
4984 /* Check whether an exception has been thrown, if not, jump over code */
4985 zend_exception_restore();
4986 if (EG(exception) == NULL) {
4987 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4988 }
4989 catch_ce = CACHED_PTR(opline->extended_value & ~ZEND_LAST_CATCH);
4990 if (UNEXPECTED(catch_ce == NULL)) {
4991 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);
4992
4993 CACHE_PTR(opline->extended_value & ~ZEND_LAST_CATCH, catch_ce);
4994 }
4995 ce = EG(exception)->ce;
4996
4997#ifdef HAVE_DTRACE
4998 if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
4999 DTRACE_EXCEPTION_CAUGHT((char *)ce->name);
5000 }
5001#endif /* HAVE_DTRACE */
5002
5003 if (ce != catch_ce) {
5004 if (!catch_ce || !instanceof_function(ce, catch_ce)) {
5005 if (opline->extended_value & ZEND_LAST_CATCH) {
5006 zend_rethrow_exception(execute_data);
5007 HANDLE_EXCEPTION();
5008 }
5009 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5010 }
5011 }
5012
5013 exception = EG(exception);
5014 EG(exception) = NULL;
5015 if (RETURN_VALUE_USED(opline)) {
5016 /* Always perform a strict assignment. There is a reasonable expectation that if you
5017 * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such,
5018 * we should not permit coercion to string here. */
5019 zval tmp;
5020 ZVAL_OBJ(&tmp, exception);
5021 zend_assign_to_variable(EX_VAR(opline->result.var), &tmp, IS_TMP_VAR, /* strict */ 1);
5022 } else {
5023 OBJ_RELEASE(exception);
5024 }
5025 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5026}
5027
5028static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5029{
5030 USE_OPLINE
5031 zval *arg, *param;
5032
5033 SAVE_OPLINE();
5034
5035 arg = RT_CONSTANT(opline, opline->op1);
5036 param = ZEND_CALL_VAR(EX(call), opline->result.var);
5037 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
5038 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
5039 Z_TRY_ADDREF_P(arg);
5040 ZVAL_NEW_REF(param, arg);
5041 } else {
5042 ZVAL_COPY(param, arg);
5043 }
5044
5045 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5046}
5047
5048static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5049{
5050 USE_OPLINE
5051 zval *val;
5052
5053 val = RT_CONSTANT(opline, opline->op1);
5054 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
5055 ZVAL_TRUE(EX_VAR(opline->result.var));
5056 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
5057 /* The result and op1 can be the same cv zval */
5058 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
5059 ZVAL_FALSE(EX_VAR(opline->result.var));
5060 if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
5061 SAVE_OPLINE();
5062 ZVAL_UNDEFINED_OP1();
5063 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5064 }
5065 } else {
5066 SAVE_OPLINE();
5067 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
5068
5069 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5070 }
5071 ZEND_VM_NEXT_OPCODE();
5072}
5073
5074static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5075{
5076 USE_OPLINE
5077 zval *obj;
5078 zend_object *zobj;
5079 zend_class_entry *ce, *scope;
5080 zend_function *clone;
5081 zend_object_clone_obj_t clone_call;
5082
5083 SAVE_OPLINE();
5084 obj = RT_CONSTANT(opline, opline->op1);
5085
5086 do {
5087 if (IS_CONST == IS_CONST ||
5088 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
5089 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
5090 obj = Z_REFVAL_P(obj);
5091 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
5092 break;
5093 }
5094 }
5095 ZVAL_UNDEF(EX_VAR(opline->result.var));
5096 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
5097 ZVAL_UNDEFINED_OP1();
5098 if (UNEXPECTED(EG(exception) != NULL)) {
5099 HANDLE_EXCEPTION();
5100 }
5101 }
5102 zend_throw_error(NULL, "__clone method called on non-object");
5103
5104 HANDLE_EXCEPTION();
5105 }
5106 } while (0);
5107
5108 zobj = Z_OBJ_P(obj);
5109 ce = zobj->ce;
5110 clone = ce->clone;
5111 clone_call = zobj->handlers->clone_obj;
5112 if (UNEXPECTED(clone_call == NULL)) {
5113 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
5114
5115 ZVAL_UNDEF(EX_VAR(opline->result.var));
5116 HANDLE_EXCEPTION();
5117 }
5118
5119 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
5120 scope = EX(func)->op_array.scope;
5121 if (clone->common.scope != scope) {
5122 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
5123 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
5124 zend_wrong_clone_call(clone, scope);
5125
5126 ZVAL_UNDEF(EX_VAR(opline->result.var));
5127 HANDLE_EXCEPTION();
5128 }
5129 }
5130 }
5131
5132 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
5133
5134 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5135}
5136
5137static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5138{
5139 USE_OPLINE
5140 zval *expr;
5141 zval *result = EX_VAR(opline->result.var);
5142 HashTable *ht;
5143
5144 SAVE_OPLINE();
5145 expr = RT_CONSTANT(opline, opline->op1);
5146
5147 switch (opline->extended_value) {
5148 case IS_LONG:
5149 ZVAL_LONG(result, zval_get_long(expr));
5150 break;
5151 case IS_DOUBLE:
5152 ZVAL_DOUBLE(result, zval_get_double(expr));
5153 break;
5154 case IS_STRING:
5155 ZVAL_STR(result, zval_get_string(expr));
5156 break;
5157 default:
5158 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
5159 if (IS_CONST & (IS_VAR|IS_CV)) {
5160 ZVAL_DEREF(expr);
5161 }
5162 /* If value is already of correct type, return it directly */
5163 if (Z_TYPE_P(expr) == opline->extended_value) {
5164 ZVAL_COPY_VALUE(result, expr);
5165 if (IS_CONST == IS_CONST) {
5166 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5167 } else if (IS_CONST != IS_TMP_VAR) {
5168 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5169 }
5170
5171 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5172 }
5173
5174 if (opline->extended_value == IS_ARRAY) {
5175 if (IS_CONST == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
5176 if (Z_TYPE_P(expr) != IS_NULL) {
5177 ZVAL_ARR(result, zend_new_array(1));
5178 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
5179 if (IS_CONST == IS_CONST) {
5180 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
5181 } else {
5182 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
5183 }
5184 } else {
5185 ZVAL_EMPTY_ARRAY(result);
5186 }
5187 } else if (ZEND_STD_BUILD_OBJECT_PROPERTIES_ARRAY_COMPATIBLE(expr)) {
5188 /* Optimized version without rebuilding properties HashTable */
5189 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
5190 } else {
5191 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
5192 if (obj_ht) {
5193 /* fast copy */
5194 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
5195 (Z_OBJCE_P(expr)->default_properties_count ||
5196 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
5197 GC_IS_RECURSIVE(obj_ht))));
5198 zend_release_properties(obj_ht);
5199 } else {
5200 ZVAL_EMPTY_ARRAY(result);
5201 }
5202 }
5203 } else {
5204 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
5205 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
5206 if (Z_TYPE_P(expr) == IS_ARRAY) {
5207 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
5208 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
5209 /* TODO: try not to duplicate immutable arrays as well ??? */
5210 ht = zend_array_dup(ht);
5211 }
5212 Z_OBJ_P(result)->properties = ht;
5213 } else if (Z_TYPE_P(expr) != IS_NULL) {
5214 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
5215 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
5216 if (IS_CONST == IS_CONST) {
5217 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
5218 } else {
5219 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
5220 }
5221 }
5222 }
5223 }
5224
5225 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5226}
5227
5228static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5229{
5230 USE_OPLINE
5231 zend_op_array *new_op_array;
5232 zval *inc_filename;
5233
5234 SAVE_OPLINE();
5235 inc_filename = RT_CONSTANT(opline, opline->op1);
5236 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
5237 if (UNEXPECTED(EG(exception) != NULL)) {
5238
5239 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
5240 destroy_op_array(new_op_array);
5241 efree_size(new_op_array, sizeof(zend_op_array));
5242 }
5243 UNDEF_RESULT();
5244 HANDLE_EXCEPTION();
5245 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
5246 if (RETURN_VALUE_USED(opline)) {
5247 ZVAL_TRUE(EX_VAR(opline->result.var));
5248 }
5249 } else if (UNEXPECTED(new_op_array == NULL)) {
5250 if (RETURN_VALUE_USED(opline)) {
5251 ZVAL_FALSE(EX_VAR(opline->result.var));
5252 }
5253 } else if (new_op_array->last == 1
5254 && new_op_array->opcodes[0].opcode == ZEND_RETURN
5255 && new_op_array->opcodes[0].op1_type == IS_CONST
5256 && EXPECTED(zend_execute_ex == execute_ex)) {
5257 if (RETURN_VALUE_USED(opline)) {
5258 const zend_op *op = new_op_array->opcodes;
5259
5260 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
5261 }
5262 zend_destroy_static_vars(new_op_array);
5263 destroy_op_array(new_op_array);
5264 efree_size(new_op_array, sizeof(zend_op_array));
5265 } else {
5266 zval *return_value = NULL;
5267 zend_execute_data *call;
5268 if (RETURN_VALUE_USED(opline)) {
5269 return_value = EX_VAR(opline->result.var);
5270 }
5271
5272 new_op_array->scope = EX(func)->op_array.scope;
5273
5274 call = zend_vm_stack_push_call_frame(
5275 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
5276 (zend_function*)new_op_array, 0,
5277 Z_PTR(EX(This)));
5278
5279 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
5280 call->symbol_table = EX(symbol_table);
5281 } else {
5282 call->symbol_table = zend_rebuild_symbol_table();
5283 }
5284
5285 call->prev_execute_data = execute_data;
5286 i_init_code_execute_data(call, new_op_array, return_value);
5287
5288 if (EXPECTED(zend_execute_ex == execute_ex)) {
5289
5290 ZEND_VM_ENTER();
5291 } else {
5292 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
5293 zend_execute_ex(call);
5294 zend_vm_stack_free_call_frame(call);
5295 }
5296
5297 zend_destroy_static_vars(new_op_array);
5298 destroy_op_array(new_op_array);
5299 efree_size(new_op_array, sizeof(zend_op_array));
5300 if (UNEXPECTED(EG(exception) != NULL)) {
5301 zend_rethrow_exception(execute_data);
5302
5303 UNDEF_RESULT();
5304 HANDLE_EXCEPTION();
5305 }
5306 }
5307
5308 ZEND_VM_NEXT_OPCODE();
5309}
5310
5311static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5312{
5313 USE_OPLINE
5314 zend_op_array *new_op_array;
5315 zval *inc_filename;
5316
5317 SAVE_OPLINE();
5318 inc_filename = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
5319 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
5320 if (UNEXPECTED(EG(exception) != NULL)) {
5321 FREE_OP(opline->op1_type, opline->op1.var);
5322 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
5323 destroy_op_array(new_op_array);
5324 efree_size(new_op_array, sizeof(zend_op_array));
5325 }
5326 UNDEF_RESULT();
5327 HANDLE_EXCEPTION();
5328 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
5329 if (RETURN_VALUE_USED(opline)) {
5330 ZVAL_TRUE(EX_VAR(opline->result.var));
5331 }
5332 } else if (UNEXPECTED(new_op_array == NULL)) {
5333 if (RETURN_VALUE_USED(opline)) {
5334 ZVAL_FALSE(EX_VAR(opline->result.var));
5335 }
5336 } else if (new_op_array->last == 1
5337 && new_op_array->opcodes[0].opcode == ZEND_RETURN
5338 && new_op_array->opcodes[0].op1_type == IS_CONST
5339 && EXPECTED(zend_execute_ex == execute_ex)) {
5340 if (RETURN_VALUE_USED(opline)) {
5341 const zend_op *op = new_op_array->opcodes;
5342
5343 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
5344 }
5345 zend_destroy_static_vars(new_op_array);
5346 destroy_op_array(new_op_array);
5347 efree_size(new_op_array, sizeof(zend_op_array));
5348 } else {
5349 zval *return_value = NULL;
5350 zend_execute_data *call;
5351 if (RETURN_VALUE_USED(opline)) {
5352 return_value = EX_VAR(opline->result.var);
5353 }
5354
5355 new_op_array->scope = EX(func)->op_array.scope;
5356
5357 call = zend_vm_stack_push_call_frame(
5358 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
5359 (zend_function*)new_op_array, 0,
5360 Z_PTR(EX(This)));
5361
5362 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
5363 call->symbol_table = EX(symbol_table);
5364 } else {
5365 call->symbol_table = zend_rebuild_symbol_table();
5366 }
5367
5368 call->prev_execute_data = execute_data;
5369 i_init_code_execute_data(call, new_op_array, return_value);
5370 zend_observer_fcall_begin_specialized(call, false);
5371 if (EXPECTED(zend_execute_ex == execute_ex)) {
5372 FREE_OP(opline->op1_type, opline->op1.var);
5373 ZEND_VM_ENTER();
5374 } else {
5375 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
5376 zend_execute_ex(call);
5377 zend_vm_stack_free_call_frame(call);
5378 }
5379
5380 zend_destroy_static_vars(new_op_array);
5381 destroy_op_array(new_op_array);
5382 efree_size(new_op_array, sizeof(zend_op_array));
5383 if (UNEXPECTED(EG(exception) != NULL)) {
5384 zend_rethrow_exception(execute_data);
5385 FREE_OP(opline->op1_type, opline->op1.var);
5386 UNDEF_RESULT();
5387 HANDLE_EXCEPTION();
5388 }
5389 }
5390 FREE_OP(opline->op1_type, opline->op1.var);
5391 ZEND_VM_NEXT_OPCODE();
5392}
5393
5394static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5395{
5396 USE_OPLINE
5397 zval *array_ptr, *result;
5398
5399 SAVE_OPLINE();
5400
5401 array_ptr = RT_CONSTANT(opline, opline->op1);
5402 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5403 result = EX_VAR(opline->result.var);
5404 ZVAL_COPY_VALUE(result, array_ptr);
5405 if (IS_CONST != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
5406 Z_ADDREF_P(array_ptr);
5407 }
5408 Z_FE_POS_P(result) = 0;
5409
5410 ZEND_VM_NEXT_OPCODE();
5411 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5412 zend_object *zobj = Z_OBJ_P(array_ptr);
5413 if (!zobj->ce->get_iterator) {
5414 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
5415 zobj = zend_lazy_object_init(zobj);
5416 if (UNEXPECTED(EG(exception))) {
5417 UNDEF_RESULT();
5418
5419 HANDLE_EXCEPTION();
5420 }
5421 }
5422 HashTable *properties = zobj->properties;
5423 if (properties) {
5424 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
5425 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
5426 GC_DELREF(properties);
5427 }
5428 properties = zobj->properties = zend_array_dup(properties);
5429 }
5430 } else {
5431 properties = zobj->handlers->get_properties(zobj);
5432 }
5433
5434 result = EX_VAR(opline->result.var);
5435 ZVAL_COPY_VALUE(result, array_ptr);
5436 if (IS_CONST != IS_TMP_VAR) {
5437 Z_ADDREF_P(array_ptr);
5438 }
5439
5440 if (zend_hash_num_elements(properties) == 0) {
5441 Z_FE_ITER_P(result) = (uint32_t) -1;
5442
5443 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5444 }
5445
5446 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
5447
5448 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5449 } else {
5450 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
5451
5452 if (UNEXPECTED(EG(exception))) {
5453 HANDLE_EXCEPTION();
5454 } else if (is_empty) {
5455 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5456 } else {
5457 ZEND_VM_NEXT_OPCODE();
5458 }
5459 }
5460 } else {
5461 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
5462 ZVAL_UNDEF(EX_VAR(opline->result.var));
5463 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5464
5465 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5466 }
5467}
5468
5469static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5470{
5471 USE_OPLINE
5472 zval *array_ptr, *array_ref;
5473
5474 SAVE_OPLINE();
5475
5476 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5477 array_ref = array_ptr = zend_get_bad_ptr();
5478 if (Z_ISREF_P(array_ref)) {
5479 array_ptr = Z_REFVAL_P(array_ref);
5480 }
5481 } else {
5482 array_ref = array_ptr = RT_CONSTANT(opline, opline->op1);
5483 }
5484
5485 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5486 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5487 if (array_ptr == array_ref) {
5488 ZVAL_NEW_REF(array_ref, array_ref);
5489 array_ptr = Z_REFVAL_P(array_ref);
5490 }
5491 Z_ADDREF_P(array_ref);
5492 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5493 } else {
5494 array_ref = EX_VAR(opline->result.var);
5495 ZVAL_NEW_REF(array_ref, array_ptr);
5496 array_ptr = Z_REFVAL_P(array_ref);
5497 }
5498 if (IS_CONST == IS_CONST) {
5499 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
5500 } else {
5501 SEPARATE_ARRAY(array_ptr);
5502 }
5503 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
5504
5505 ZEND_VM_NEXT_OPCODE();
5506 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5507 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
5508 zend_object *zobj = Z_OBJ_P(array_ptr);
5509 HashTable *properties;
5510 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
5511 zobj = zend_lazy_object_init(zobj);
5512 if (UNEXPECTED(EG(exception))) {
5513 UNDEF_RESULT();
5514
5515 HANDLE_EXCEPTION();
5516 }
5517 }
5518 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5519 if (array_ptr == array_ref) {
5520 ZVAL_NEW_REF(array_ref, array_ref);
5521 array_ptr = Z_REFVAL_P(array_ref);
5522 }
5523 Z_ADDREF_P(array_ref);
5524 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5525 } else {
5526 array_ptr = EX_VAR(opline->result.var);
5527 ZVAL_COPY_VALUE(array_ptr, array_ref);
5528 }
5529 if (Z_OBJ_P(array_ptr)->properties
5530 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
5531 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
5532 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
5533 }
5534 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
5535 }
5536
5537 properties = Z_OBJPROP_P(array_ptr);
5538 if (zend_hash_num_elements(properties) == 0) {
5539 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
5540
5541 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5542 }
5543
5544 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
5545
5546 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5547 } else {
5548 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
5549
5550 if (UNEXPECTED(EG(exception))) {
5551 HANDLE_EXCEPTION();
5552 } else if (is_empty) {
5553 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5554 } else {
5555 ZEND_VM_NEXT_OPCODE();
5556 }
5557 }
5558 } else {
5559 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
5560 ZVAL_UNDEF(EX_VAR(opline->result.var));
5561 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5562
5563 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5564 }
5565}
5566
5567static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5568{
5569 USE_OPLINE
5570 zval *value;
5571 zend_reference *ref = NULL;
5572 bool ret;
5573
5574 SAVE_OPLINE();
5575 value = RT_CONSTANT(opline, opline->op1);
5576
5577 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && Z_ISREF_P(value)) {
5578 if (IS_CONST == IS_VAR) {
5579 ref = Z_REF_P(value);
5580 }
5581 value = Z_REFVAL_P(value);
5582 }
5583
5584 ret = i_zend_is_true(value);
5585
5586 if (UNEXPECTED(EG(exception))) {
5587
5588 ZVAL_UNDEF(EX_VAR(opline->result.var));
5589 HANDLE_EXCEPTION();
5590 }
5591
5592 if (ret) {
5593 zval *result = EX_VAR(opline->result.var);
5594
5595 ZVAL_COPY_VALUE(result, value);
5596 if (IS_CONST == IS_CONST) {
5597 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5598 } else if (IS_CONST == IS_CV) {
5599 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5600 } else if (IS_CONST == IS_VAR && ref) {
5601 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5602 efree_size(ref, sizeof(zend_reference));
5603 } else if (Z_OPT_REFCOUNTED_P(result)) {
5604 Z_ADDREF_P(result);
5605 }
5606 }
5607 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5608 }
5609
5610 ZEND_VM_NEXT_OPCODE();
5611}
5612
5613static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5614{
5615 USE_OPLINE
5616 zval *value;
5617 zend_reference *ref = NULL;
5618
5619 SAVE_OPLINE();
5620 value = RT_CONSTANT(opline, opline->op1);
5621
5622 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
5623 if (IS_CONST & IS_VAR) {
5624 ref = Z_REF_P(value);
5625 }
5626 value = Z_REFVAL_P(value);
5627 }
5628
5629 if (Z_TYPE_P(value) > IS_NULL) {
5630 zval *result = EX_VAR(opline->result.var);
5631 ZVAL_COPY_VALUE(result, value);
5632 if (IS_CONST == IS_CONST) {
5633 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5634 } else if (IS_CONST == IS_CV) {
5635 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5636 } else if ((IS_CONST & IS_VAR) && ref) {
5637 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5638 efree_size(ref, sizeof(zend_reference));
5639 } else if (Z_OPT_REFCOUNTED_P(result)) {
5640 Z_ADDREF_P(result);
5641 }
5642 }
5643 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5644 }
5645
5646 if ((IS_CONST & IS_VAR) && ref) {
5647 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5648 efree_size(ref, sizeof(zend_reference));
5649 }
5650 }
5651 ZEND_VM_NEXT_OPCODE();
5652}
5653
5654static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5655{
5656 USE_OPLINE
5657 zval *val, *result;
5658
5659 val = RT_CONSTANT(opline, opline->op1);
5660
5661 if (Z_TYPE_P(val) > IS_NULL) {
5662 do {
5663 if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
5664 val = Z_REFVAL_P(val);
5665 if (Z_TYPE_P(val) <= IS_NULL) {
5666
5667 break;
5668 }
5669 }
5670 ZEND_VM_NEXT_OPCODE();
5671 } while (0);
5672 }
5673
5674 result = EX_VAR(opline->result.var);
5675 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
5676 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
5677 ZVAL_NULL(result);
5678 if (IS_CONST == IS_CV
5679 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
5680 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
5681 ) {
5682 SAVE_OPLINE();
5683 ZVAL_UNDEFINED_OP1();
5684 if (UNEXPECTED(EG(exception) != NULL)) {
5685 HANDLE_EXCEPTION();
5686 }
5687 }
5688 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
5689 ZVAL_FALSE(result);
5690 } else {
5691 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
5692 ZVAL_TRUE(result);
5693 }
5694
5695 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5696}
5697
5698static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5699{
5700 USE_OPLINE
5701 zval *value;
5702 zval *result = EX_VAR(opline->result.var);
5703
5704 value = RT_CONSTANT(opline, opline->op1);
5705 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5706 SAVE_OPLINE();
5707 ZVAL_UNDEFINED_OP1();
5708 ZVAL_NULL(result);
5709 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5710 }
5711
5712 if (IS_CONST == IS_CV) {
5713 ZVAL_COPY_DEREF(result, value);
5714 } else if (IS_CONST == IS_VAR) {
5715 if (UNEXPECTED(Z_ISREF_P(value))) {
5716 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
5717 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
5718 efree_size(Z_REF_P(value), sizeof(zend_reference));
5719 } else if (Z_OPT_REFCOUNTED_P(result)) {
5720 Z_ADDREF_P(result);
5721 }
5722 } else {
5723 ZVAL_COPY_VALUE(result, value);
5724 }
5725 } else {
5726 ZVAL_COPY_VALUE(result, value);
5727 if (IS_CONST == IS_CONST) {
5728 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
5729 Z_ADDREF_P(result);
5730 }
5731 }
5732 }
5733 ZEND_VM_NEXT_OPCODE();
5734}
5735
5736static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5737{
5738 USE_OPLINE
5739
5740 SAVE_OPLINE();
5741 do_bind_class(RT_CONSTANT(opline, opline->op1), (opline->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL);
5742 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5743}
5744
5745static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5746{
5747 USE_OPLINE
5748 zend_function *func;
5749 zval *object;
5750 zend_class_entry *called_scope;
5751
5752 func = (zend_function *) EX(func)->op_array.dynamic_func_defs[opline->op2.num];
5753 if (Z_TYPE(EX(This)) == IS_OBJECT) {
5754 called_scope = Z_OBJCE(EX(This));
5755 if (UNEXPECTED((func->common.fn_flags & ZEND_ACC_STATIC) ||
5756 (EX(func)->common.fn_flags & ZEND_ACC_STATIC))) {
5757 object = NULL;
5758 } else {
5759 object = &EX(This);
5760 }
5761 } else {
5762 called_scope = Z_CE(EX(This));
5763 object = NULL;
5764 }
5765 SAVE_OPLINE();
5766 zend_create_closure(EX_VAR(opline->result.var), func,
5767 EX(func)->op_array.scope, called_scope, object);
5768
5769 ZEND_VM_NEXT_OPCODE();
5770}
5771
5772static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5773{
5774 USE_OPLINE
5775 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
5776 zval *val;
5777
5778 SAVE_OPLINE();
5779 val = RT_CONSTANT(opline, opline->op1);
5780
5781 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
5782 zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
5783
5784 UNDEF_RESULT();
5785 HANDLE_EXCEPTION();
5786 }
5787
5788yield_from_try_again:
5789 if (Z_TYPE_P(val) == IS_ARRAY) {
5790 ZVAL_COPY_VALUE(&generator->values, val);
5791 if (Z_OPT_REFCOUNTED_P(val)) {
5792 Z_ADDREF_P(val);
5793 }
5794 Z_FE_POS(generator->values) = 0;
5795
5796 } else if (IS_CONST != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
5797 zend_class_entry *ce = Z_OBJCE_P(val);
5798 if (ce == zend_ce_generator) {
5799 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
5800
5801 Z_ADDREF_P(val);
5802
5803 if (UNEXPECTED(new_gen->execute_data == NULL)) {
5804 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
5805 zval_ptr_dtor(val);
5806 UNDEF_RESULT();
5807 HANDLE_EXCEPTION();
5808 } else if (Z_ISUNDEF(new_gen->retval)) {
5809 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
5810 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
5811 zval_ptr_dtor(val);
5812 UNDEF_RESULT();
5813 HANDLE_EXCEPTION();
5814 } else {
5815 zend_generator_yield_from(generator, new_gen);
5816 }
5817 } else {
5818 if (RETURN_VALUE_USED(opline)) {
5819 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
5820 }
5821 ZEND_VM_NEXT_OPCODE();
5822 }
5823 } else {
5824 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
5825
5826 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
5827 if (!EG(exception)) {
5828 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
5829 }
5830 UNDEF_RESULT();
5831 HANDLE_EXCEPTION();
5832 }
5833
5834 iter->index = 0;
5835 if (iter->funcs->rewind) {
5836 iter->funcs->rewind(iter);
5837 if (UNEXPECTED(EG(exception) != NULL)) {
5838 OBJ_RELEASE(&iter->std);
5839 UNDEF_RESULT();
5840 HANDLE_EXCEPTION();
5841 }
5842 }
5843
5844 ZVAL_OBJ(&generator->values, &iter->std);
5845 }
5846 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
5847 val = Z_REFVAL_P(val);
5848 goto yield_from_try_again;
5849 } else {
5850 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
5851
5852 UNDEF_RESULT();
5853 HANDLE_EXCEPTION();
5854 }
5855
5856 /* This is the default return value
5857 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
5858 if (RETURN_VALUE_USED(opline)) {
5859 ZVAL_NULL(EX_VAR(opline->result.var));
5860 }
5861
5862 /* This generator has no send target (though the generator we delegate to might have one) */
5863 generator->send_target = NULL;
5864
5865 /* The GOTO VM uses a local opline variable. We need to set the opline
5866 * variable in execute_data so we don't resume at an old position. */
5867 SAVE_OPLINE();
5868
5869 ZEND_VM_RETURN();
5870}
5871
5872static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5873{
5874 USE_OPLINE
5875 zval *value;
5876
5877 value = RT_CONSTANT(opline, opline->op1);
5878 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
5879 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
5880 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
5881 zval_ptr_dtor_str(value);
5882 }
5883 ZEND_VM_NEXT_OPCODE();
5884 } else {
5885 bool strict;
5886
5887 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
5888 value = Z_REFVAL_P(value);
5889 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
5890 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
5891
5892 ZEND_VM_NEXT_OPCODE();
5893 }
5894 }
5895
5896 SAVE_OPLINE();
5897 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5898 value = ZVAL_UNDEFINED_OP1();
5899 }
5900 strict = EX_USES_STRICT_TYPES();
5901 do {
5902 if (EXPECTED(!strict)) {
5903 zend_string *str;
5904 zval tmp;
5905
5906 if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
5907 zend_error(E_DEPRECATED,
5908 "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
5909 ZVAL_LONG(EX_VAR(opline->result.var), 0);
5910 if (UNEXPECTED(EG(exception))) {
5911 HANDLE_EXCEPTION();
5912 }
5913 break;
5914 }
5915
5916 ZVAL_COPY(&tmp, value);
5917 if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
5918 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
5919 zval_ptr_dtor(&tmp);
5920 break;
5921 }
5922 zval_ptr_dtor(&tmp);
5923 }
5924 if (!EG(exception)) {
5925 zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
5926 }
5927 ZVAL_UNDEF(EX_VAR(opline->result.var));
5928 } while (0);
5929 }
5930
5931 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5932}
5933
5934static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5935{
5936 USE_OPLINE
5937 zval *value;
5938 int result = 0;
5939
5940 value = RT_CONSTANT(opline, opline->op1);
5941 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
5942type_check_resource:
5943 if (opline->extended_value != MAY_BE_RESOURCE
5944 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
5945 result = 1;
5946 }
5947 } else if ((IS_CONST & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
5948 value = Z_REFVAL_P(value);
5949 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
5950 goto type_check_resource;
5951 }
5952 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5953 result = ((1 << IS_NULL) & opline->extended_value) != 0;
5954 SAVE_OPLINE();
5955 ZVAL_UNDEFINED_OP1();
5956 if (UNEXPECTED(EG(exception))) {
5957 ZVAL_UNDEF(EX_VAR(opline->result.var));
5958 HANDLE_EXCEPTION();
5959 }
5960 }
5961 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
5962 SAVE_OPLINE();
5963
5964 ZEND_VM_SMART_BRANCH(result, 1);
5965 } else {
5966 ZEND_VM_SMART_BRANCH(result, 0);
5967 }
5968}
5969
5970static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5971{
5972 USE_OPLINE
5973 zend_constant *c;
5974
5975 c = CACHED_PTR(opline->extended_value);
5976 if (EXPECTED(c != NULL)) {
5977 if (!IS_SPECIAL_CACHE_VAL(c)) {
5978defined_true:
5979 ZEND_VM_SMART_BRANCH_TRUE();
5980 } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
5981defined_false:
5982 ZEND_VM_SMART_BRANCH_FALSE();
5983 }
5984 }
5985 if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
5986 CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants))));
5987 goto defined_false;
5988 } else {
5989 goto defined_true;
5990 }
5991}
5992
5993static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5994{
5995 USE_OPLINE
5996 zend_jmp_fl_result result = (uintptr_t)CACHED_PTR(opline->extended_value);
5997try_again:
5998 if (EXPECTED(result == ZEND_JMP_FL_HIT)) {
5999 OPLINE = OP_JMP_ADDR(opline, opline->op2);
6000 ZEND_VM_CONTINUE();
6001 } else if (EXPECTED(result == ZEND_JMP_FL_MISS)) {
6002 ZEND_VM_NEXT_OPCODE();
6003 } else {
6004 ZEND_ASSERT(result == ZEND_JMP_FL_UNPRIMED);
6005 /* func_name refers to the function in the local namespace, e.g. foo\substr. */
6006 zval *func_name = (zval *)RT_CONSTANT(opline, opline->op1);
6007 /* If it cannot be found locally, we must be referring to the global function. */
6008 zval *func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name));
6009 /* ZEND_JMP_FL_MISS = 1, ZEND_JMP_FL_HIT = 2 */
6010 result = (func == NULL) + 1;
6011 CACHE_PTR(opline->extended_value, (void *)result);
6012 goto try_again;
6013 }
6014}
6015
6016static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6017{
6018 USE_OPLINE
6019 zval *value;
6020
6021 value = RT_CONSTANT(opline, opline->op1);
6022 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
6023 ZEND_VM_NEXT_OPCODE();
6024}
6025
6026static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6027{
6028 USE_OPLINE
6029 zval *value;
6030
6031 value = RT_CONSTANT(opline, opline->op1);
6032 ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
6033 ZEND_VM_NEXT_OPCODE();
6034}
6035
6036static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6037{
6038 USE_OPLINE
6039 zval *value;
6040
6041 value = RT_CONSTANT(opline, opline->op1);
6042 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
6043 ZEND_VM_NEXT_OPCODE();
6044}
6045
6046static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6047{
6048 USE_OPLINE
6049 zval *value, *arg;
6050
6051 value = RT_CONSTANT(opline, opline->op1);
6052 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
6053 ZVAL_COPY_VALUE(arg, value);
6054 ZEND_VM_NEXT_OPCODE();
6055}
6056
6057static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6058{
6059 USE_OPLINE
6060 zval *value, *arg;
6061 uint32_t arg_num = opline->op2.num;
6062
6063 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
6064 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
6065 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6066 }
6067 value = RT_CONSTANT(opline, opline->op1);
6068 ZVAL_COPY_VALUE(arg, value);
6069 ZEND_VM_NEXT_OPCODE();
6070}
6071
6072static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6073{
6074 USE_OPLINE
6075 zval *op1, *op2, *result;
6076 double d1, d2;
6077
6078 op1 = RT_CONSTANT(opline, opline->op1);
6079 op2 = RT_CONSTANT(opline, opline->op2);
6080 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6081 /* pass */
6082 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6083 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6084 result = EX_VAR(opline->result.var);
6085 fast_long_add_function(result, op1, op2);
6086 ZEND_VM_NEXT_OPCODE();
6087 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6088 d1 = (double)Z_LVAL_P(op1);
6089 d2 = Z_DVAL_P(op2);
6090 goto add_double;
6091 }
6092 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6093 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6094 d1 = Z_DVAL_P(op1);
6095 d2 = Z_DVAL_P(op2);
6096add_double:
6097 result = EX_VAR(opline->result.var);
6098 ZVAL_DOUBLE(result, d1 + d2);
6099 ZEND_VM_NEXT_OPCODE();
6100 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6101 d1 = Z_DVAL_P(op1);
6102 d2 = (double)Z_LVAL_P(op2);
6103 goto add_double;
6104 }
6105 }
6106
6107 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6108}
6109
6110static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6111{
6112 USE_OPLINE
6113 zval *op1, *op2, *result;
6114 double d1, d2;
6115
6116 op1 = RT_CONSTANT(opline, opline->op1);
6117 op2 = RT_CONSTANT(opline, opline->op2);
6118 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6119 /* pass */
6120 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6121 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6122 result = EX_VAR(opline->result.var);
6123 fast_long_sub_function(result, op1, op2);
6124 ZEND_VM_NEXT_OPCODE();
6125 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6126 d1 = (double)Z_LVAL_P(op1);
6127 d2 = Z_DVAL_P(op2);
6128 goto sub_double;
6129 }
6130 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6131 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6132 d1 = Z_DVAL_P(op1);
6133 d2 = Z_DVAL_P(op2);
6134sub_double:
6135 result = EX_VAR(opline->result.var);
6136 ZVAL_DOUBLE(result, d1 - d2);
6137 ZEND_VM_NEXT_OPCODE();
6138 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6139 d1 = Z_DVAL_P(op1);
6140 d2 = (double)Z_LVAL_P(op2);
6141 goto sub_double;
6142 }
6143 }
6144
6145 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6146}
6147
6148static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6149{
6150 USE_OPLINE
6151 zval *op1, *op2, *result;
6152 double d1, d2;
6153
6154 op1 = RT_CONSTANT(opline, opline->op1);
6155 op2 = RT_CONSTANT(opline, opline->op2);
6156 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6157 /* pass */
6158 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6159 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6160 zend_long overflow;
6161
6162 result = EX_VAR(opline->result.var);
6163 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
6164 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
6165 ZEND_VM_NEXT_OPCODE();
6166 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6167 d1 = (double)Z_LVAL_P(op1);
6168 d2 = Z_DVAL_P(op2);
6169 goto mul_double;
6170 }
6171 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6172 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6173 d1 = Z_DVAL_P(op1);
6174 d2 = Z_DVAL_P(op2);
6175mul_double:
6176 result = EX_VAR(opline->result.var);
6177 ZVAL_DOUBLE(result, d1 * d2);
6178 ZEND_VM_NEXT_OPCODE();
6179 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6180 d1 = Z_DVAL_P(op1);
6181 d2 = (double)Z_LVAL_P(op2);
6182 goto mul_double;
6183 }
6184 }
6185
6186 ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6187}
6188
6189static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6190{
6191 USE_OPLINE
6192 zval *op1, *op2;
6193
6194 SAVE_OPLINE();
6195 op1 = RT_CONSTANT(opline, opline->op1);
6196 op2 = RT_CONSTANT(opline, opline->op2);
6197 div_function(EX_VAR(opline->result.var), op1, op2);
6198
6199
6200 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6201}
6202
6203static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6204{
6205 USE_OPLINE
6206 zval *op1, *op2, *result;
6207
6208 op1 = RT_CONSTANT(opline, opline->op1);
6209 op2 = RT_CONSTANT(opline, opline->op2);
6210 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6211 /* pass */
6212 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6213 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6214 result = EX_VAR(opline->result.var);
6215 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
6216 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6217 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
6218 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
6219 ZVAL_LONG(result, 0);
6220 } else {
6221 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
6222 }
6223 ZEND_VM_NEXT_OPCODE();
6224 }
6225 }
6226
6227 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6228}
6229
6230static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6231{
6232 USE_OPLINE
6233 zval *op1, *op2;
6234
6235 op1 = RT_CONSTANT(opline, opline->op1);
6236 op2 = RT_CONSTANT(opline, opline->op2);
6237 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6238 /* pass */
6239 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6240 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
6241 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
6242 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
6243 ZVAL_LONG(EX_VAR(opline->result.var),
6244 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
6245 ZEND_VM_NEXT_OPCODE();
6246 }
6247
6248 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6249}
6250
6251static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6252{
6253 USE_OPLINE
6254 zval *op1, *op2;
6255
6256 op1 = RT_CONSTANT(opline, opline->op1);
6257 op2 = RT_CONSTANT(opline, opline->op2);
6258 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6259 /* pass */
6260 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6261 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
6262 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
6263 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
6264 ZEND_VM_NEXT_OPCODE();
6265 }
6266
6267 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6268}
6269
6270static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6271{
6272 USE_OPLINE
6273 zval *op1, *op2;
6274
6275 SAVE_OPLINE();
6276 op1 = RT_CONSTANT(opline, opline->op1);
6277 op2 = RT_CONSTANT(opline, opline->op2);
6278 pow_function(EX_VAR(opline->result.var), op1, op2);
6279
6280
6281 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6282}
6283
6284static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6285{
6286 USE_OPLINE
6287 zval *op1, *op2;
6288 bool result;
6289
6290 SAVE_OPLINE();
6291 op1 = RT_CONSTANT(opline, opline->op1);
6292 op2 = RT_CONSTANT(opline, opline->op2);
6293 result = fast_is_identical_function(op1, op2);
6294
6295
6296 ZEND_VM_SMART_BRANCH(result, 1);
6297}
6298
6299static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6300{
6301 USE_OPLINE
6302 zval *op1, *op2;
6303 bool result;
6304
6305 SAVE_OPLINE();
6306 op1 = RT_CONSTANT(opline, opline->op1);
6307 op2 = RT_CONSTANT(opline, opline->op2);
6308 result = fast_is_not_identical_function(op1, op2);
6309
6310
6311 ZEND_VM_SMART_BRANCH(result, 1);
6312}
6313
6314static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6315{
6316 USE_OPLINE
6317 zval *op1, *op2;
6318 double d1, d2;
6319
6320 op1 = RT_CONSTANT(opline, opline->op1);
6321 op2 = RT_CONSTANT(opline, opline->op2);
6322 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6323 /* pass */
6324 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
6325 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6326 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
6327is_equal_true:
6328 ZEND_VM_SMART_BRANCH_TRUE();
6329 } else {
6330is_equal_false:
6331 ZEND_VM_SMART_BRANCH_FALSE();
6332 }
6333 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6334 d1 = (double)Z_LVAL_P(op1);
6335 d2 = Z_DVAL_P(op2);
6336 goto is_equal_double;
6337 }
6338 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
6339 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6340 d1 = Z_DVAL_P(op1);
6341 d2 = Z_DVAL_P(op2);
6342is_equal_double:
6343 if (d1 == d2) {
6344 goto is_equal_true;
6345 } else {
6346 goto is_equal_false;
6347 }
6348 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6349 d1 = Z_DVAL_P(op1);
6350 d2 = (double)Z_LVAL_P(op2);
6351 goto is_equal_double;
6352 }
6353 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6354 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6355 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
6356 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6357 zval_ptr_dtor_str(op1);
6358 }
6359 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6360 zval_ptr_dtor_str(op2);
6361 }
6362 if (result) {
6363 goto is_equal_true;
6364 } else {
6365 goto is_equal_false;
6366 }
6367 }
6368 }
6369 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6370}
6371
6372static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6373{
6374 USE_OPLINE
6375 zval *op1, *op2;
6376 double d1, d2;
6377
6378 op1 = RT_CONSTANT(opline, opline->op1);
6379 op2 = RT_CONSTANT(opline, opline->op2);
6380 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6381 /* pass */
6382 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
6383 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6384 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
6385is_not_equal_true:
6386 ZEND_VM_SMART_BRANCH_TRUE();
6387 } else {
6388is_not_equal_false:
6389 ZEND_VM_SMART_BRANCH_FALSE();
6390 }
6391 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6392 d1 = (double)Z_LVAL_P(op1);
6393 d2 = Z_DVAL_P(op2);
6394 goto is_not_equal_double;
6395 }
6396 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
6397 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6398 d1 = Z_DVAL_P(op1);
6399 d2 = Z_DVAL_P(op2);
6400is_not_equal_double:
6401 if (d1 != d2) {
6402 goto is_not_equal_true;
6403 } else {
6404 goto is_not_equal_false;
6405 }
6406 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6407 d1 = Z_DVAL_P(op1);
6408 d2 = (double)Z_LVAL_P(op2);
6409 goto is_not_equal_double;
6410 }
6411 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6412 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6413 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
6414 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6415 zval_ptr_dtor_str(op1);
6416 }
6417 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6418 zval_ptr_dtor_str(op2);
6419 }
6420 if (!result) {
6421 goto is_not_equal_true;
6422 } else {
6423 goto is_not_equal_false;
6424 }
6425 }
6426 }
6427 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6428}
6429
6430static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6431{
6432 USE_OPLINE
6433 zval *op1, *op2;
6434 double d1, d2;
6435
6436 op1 = RT_CONSTANT(opline, opline->op1);
6437 op2 = RT_CONSTANT(opline, opline->op2);
6438 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6439 /* pass */
6440 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6441 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6442 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
6443is_smaller_true:
6444 ZEND_VM_SMART_BRANCH_TRUE();
6445 } else {
6446is_smaller_false:
6447 ZEND_VM_SMART_BRANCH_FALSE();
6448 }
6449 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6450 d1 = (double)Z_LVAL_P(op1);
6451 d2 = Z_DVAL_P(op2);
6452 goto is_smaller_double;
6453 }
6454 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6455 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6456 d1 = Z_DVAL_P(op1);
6457 d2 = Z_DVAL_P(op2);
6458is_smaller_double:
6459 if (d1 < d2) {
6460 goto is_smaller_true;
6461 } else {
6462 goto is_smaller_false;
6463 }
6464 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6465 d1 = Z_DVAL_P(op1);
6466 d2 = (double)Z_LVAL_P(op2);
6467 goto is_smaller_double;
6468 }
6469 }
6470 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6471}
6472
6473static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6474{
6475 USE_OPLINE
6476 zval *op1, *op2;
6477 double d1, d2;
6478
6479 op1 = RT_CONSTANT(opline, opline->op1);
6480 op2 = RT_CONSTANT(opline, opline->op2);
6481 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6482 /* pass */
6483 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6484 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6485 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
6486is_smaller_or_equal_true:
6487 ZEND_VM_SMART_BRANCH_TRUE();
6488 ZVAL_TRUE(EX_VAR(opline->result.var));
6489 ZEND_VM_NEXT_OPCODE();
6490 } else {
6491is_smaller_or_equal_false:
6492 ZEND_VM_SMART_BRANCH_FALSE();
6493 ZVAL_FALSE(EX_VAR(opline->result.var));
6494 ZEND_VM_NEXT_OPCODE();
6495 }
6496 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6497 d1 = (double)Z_LVAL_P(op1);
6498 d2 = Z_DVAL_P(op2);
6499 goto is_smaller_or_equal_double;
6500 }
6501 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6502 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6503 d1 = Z_DVAL_P(op1);
6504 d2 = Z_DVAL_P(op2);
6505is_smaller_or_equal_double:
6506 if (d1 <= d2) {
6507 goto is_smaller_or_equal_true;
6508 } else {
6509 goto is_smaller_or_equal_false;
6510 }
6511 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6512 d1 = Z_DVAL_P(op1);
6513 d2 = (double)Z_LVAL_P(op2);
6514 goto is_smaller_or_equal_double;
6515 }
6516 }
6517 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6518}
6519
6520static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6521{
6522 USE_OPLINE
6523 zval *op1, *op2;
6524
6525 SAVE_OPLINE();
6526 op1 = RT_CONSTANT(opline, opline->op1);
6527 op2 = RT_CONSTANT(opline, opline->op2);
6528 compare_function(EX_VAR(opline->result.var), op1, op2);
6529
6530
6531 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6532}
6533
6534static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6535{
6536 USE_OPLINE
6537 zval *op1, *op2;
6538
6539 op1 = RT_CONSTANT(opline, opline->op1);
6540 op2 = RT_CONSTANT(opline, opline->op2);
6541 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6542 /* pass */
6543 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6544 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6545 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
6546 ZEND_VM_NEXT_OPCODE();
6547 }
6548
6549 ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6550}
6551
6552static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6553{
6554 USE_OPLINE
6555 zval *op1, *op2;
6556
6557 op1 = RT_CONSTANT(opline, opline->op1);
6558 op2 = RT_CONSTANT(opline, opline->op2);
6559 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6560 /* pass */
6561 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6562 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6563 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
6564 ZEND_VM_NEXT_OPCODE();
6565 }
6566
6567 ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6568}
6569
6570static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6571{
6572 USE_OPLINE
6573 zval *op1, *op2;
6574
6575 op1 = RT_CONSTANT(opline, opline->op1);
6576 op2 = RT_CONSTANT(opline, opline->op2);
6577 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6578 /* pass */
6579 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6580 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6581 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
6582 ZEND_VM_NEXT_OPCODE();
6583 }
6584
6585 ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6586}
6587
6588static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6589{
6590 USE_OPLINE
6591 zval *op1, *op2;
6592
6593 SAVE_OPLINE();
6594 op1 = RT_CONSTANT(opline, opline->op1);
6595 op2 = RT_CONSTANT(opline, opline->op2);
6596 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
6597
6598
6599 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6600}
6601
6602static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6603{
6604 USE_OPLINE
6605 zval *container, *dim, *value;
6606
6607 SAVE_OPLINE();
6608 container = RT_CONSTANT(opline, opline->op1);
6609 dim = RT_CONSTANT(opline, opline->op2);
6610 if (IS_CONST != IS_CONST) {
6611 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6612fetch_dim_r_array:
6613 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
6614 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
6615 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
6616 container = Z_REFVAL_P(container);
6617 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6618 goto fetch_dim_r_array;
6619 } else {
6620 goto fetch_dim_r_slow;
6621 }
6622 } else {
6623fetch_dim_r_slow:
6624 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
6625 dim++;
6626 }
6627 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
6628 }
6629 } else {
6630 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6631 }
6632
6633
6634 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6635}
6636
6637static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6638{
6639 USE_OPLINE
6640 zval *container;
6641
6642 SAVE_OPLINE();
6643 container = RT_CONSTANT(opline, opline->op1);
6644 zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6645
6646
6647 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6648}
6649
6650static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6651{
6652#if 0
6653 USE_OPLINE
6654#endif
6655
6656 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
6657 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
6658 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6659 }
6660 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6661 } else {
6662 if (IS_CONST == IS_UNUSED) {
6663 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6664 }
6665 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6666 }
6667}
6668
6669static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6670{
6671 USE_OPLINE
6672 zval *container;
6673 void **cache_slot = NULL;
6674
6675 SAVE_OPLINE();
6676 container = RT_CONSTANT(opline, opline->op1);
6677
6678 if (IS_CONST == IS_CONST ||
6679 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
6680 do {
6681 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6682 container = Z_REFVAL_P(container);
6683 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
6684 break;
6685 }
6686 }
6687 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
6688 ZVAL_UNDEFINED_OP1();
6689 }
6690 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
6691 ZVAL_NULL(EX_VAR(opline->result.var));
6692 goto fetch_obj_r_finish;
6693 } while (0);
6694 }
6695
6696 /* here we are sure we are dealing with an object */
6697 do {
6698 zend_object *zobj = Z_OBJ_P(container);
6699 zend_string *name, *tmp_name;
6700 zval *retval;
6701
6702 if (IS_CONST == IS_CONST) {
6703 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
6704
6705 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
6706 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
6707
6708 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
6709fetch_obj_r_simple:
6710 retval = OBJ_PROP(zobj, prop_offset);
6711 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
6712 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6713 goto fetch_obj_r_copy;
6714 } else {
6715fetch_obj_r_fast_copy:
6716 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6717 ZEND_VM_NEXT_OPCODE();
6718 }
6719 }
6720 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
6721 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
6722 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
6723 prop_offset = prop_info->offset;
6724 goto fetch_obj_r_simple;
6725 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
6726 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
6727 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
6728 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
6729
6730 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
6731 if (IS_CONST & IS_CV) {
6732 GC_ADDREF(zobj);
6733 }
6734 if (IS_CONST & (IS_CV|IS_VAR|IS_TMP_VAR)) {
6735 call_info |= ZEND_CALL_RELEASE_THIS;
6736 }
6737 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
6738 call->prev_execute_data = execute_data;
6739 call->call = NULL;
6740 call->return_value = EX_VAR(opline->result.var);
6741 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
6742
6743 execute_data = call;
6744 EG(current_execute_data) = execute_data;
6745 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
6746
6747#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
6748 opline = hook->op_array.opcodes;
6749#else
6750 EX(opline) = hook->op_array.opcodes;
6751#endif
6752 LOAD_OPLINE_EX();
6753
6754
6755 ZEND_VM_ENTER_EX();
6756 }
6757 /* Fall through to read_property for hooks. */
6758 } else if (EXPECTED(zobj->properties != NULL)) {
6759 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
6760 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6761 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
6762 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
6763
6764 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
6765 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
6766
6767 if (EXPECTED(p->key == name) ||
6768 (EXPECTED(p->h == ZSTR_H(name)) &&
6769 EXPECTED(p->key != NULL) &&
6770 EXPECTED(zend_string_equal_content(p->key, name)))) {
6771 retval = &p->val;
6772 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6773 goto fetch_obj_r_copy;
6774 } else {
6775 goto fetch_obj_r_fast_copy;
6776 }
6777 }
6778 }
6779 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
6780 }
6781 retval = zend_hash_find_known_hash(zobj->properties, name);
6782 if (EXPECTED(retval)) {
6783 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
6784 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
6785 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6786 goto fetch_obj_r_copy;
6787 } else {
6788 goto fetch_obj_r_fast_copy;
6789 }
6790 }
6791 }
6792 }
6793 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6794 } else {
6795 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
6796 if (UNEXPECTED(!name)) {
6797 ZVAL_UNDEF(EX_VAR(opline->result.var));
6798 break;
6799 }
6800 }
6801
6802#if ZEND_DEBUG
6803 /* For non-standard object handlers, verify a declared property type in debug builds.
6804 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
6805 zend_property_info *prop_info = NULL;
6806 if (zobj->handlers->read_property != zend_std_read_property) {
6807 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
6808 }
6809#endif
6810 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
6811#if ZEND_DEBUG
6812 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
6813 && ZEND_TYPE_IS_SET(prop_info->type)) {
6814 ZVAL_OPT_DEREF(retval);
6815 zend_verify_property_type(prop_info, retval, /* strict */ true);
6816 }
6817#endif
6818
6819 if (IS_CONST != IS_CONST) {
6820 zend_tmp_string_release(tmp_name);
6821 }
6822
6823 if (retval != EX_VAR(opline->result.var)) {
6824fetch_obj_r_copy:
6825 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6826 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
6827 zend_unwrap_reference(retval);
6828 }
6829 } while (0);
6830
6831fetch_obj_r_finish:
6832
6833
6834 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6835}
6836
6837static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6838{
6839 USE_OPLINE
6840 zval *container;
6841 void **cache_slot = NULL;
6842
6843 SAVE_OPLINE();
6844 container = RT_CONSTANT(opline, opline->op1);
6845
6846 if (IS_CONST == IS_CONST ||
6847 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
6848 do {
6849 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6850 container = Z_REFVAL_P(container);
6851 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
6852 break;
6853 }
6854 }
6855 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
6856 ZVAL_UNDEFINED_OP2();
6857 }
6858 ZVAL_NULL(EX_VAR(opline->result.var));
6859 goto fetch_obj_is_finish;
6860 } while (0);
6861 }
6862
6863 /* here we are sure we are dealing with an object */
6864 do {
6865 zend_object *zobj = Z_OBJ_P(container);
6866 zend_string *name, *tmp_name;
6867 zval *retval;
6868
6869 if (IS_CONST == IS_CONST) {
6870 cache_slot = CACHE_ADDR(opline->extended_value);
6871
6872 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
6873 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
6874
6875 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
6876fetch_obj_is_simple:
6877 retval = OBJ_PROP(zobj, prop_offset);
6878 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
6879 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6880 goto fetch_obj_is_copy;
6881 } else {
6882fetch_obj_is_fast_copy:
6883 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6884 ZEND_VM_NEXT_OPCODE();
6885 }
6886 }
6887 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
6888 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
6889 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
6890 prop_offset = prop_info->offset;
6891 goto fetch_obj_is_simple;
6892 }
6893 /* Fall through to read_property for hooks. */
6894 } else if (EXPECTED(zobj->properties != NULL)) {
6895 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
6896 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6897 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
6898 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
6899
6900 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
6901 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
6902
6903 if (EXPECTED(p->key == name) ||
6904 (EXPECTED(p->h == ZSTR_H(name)) &&
6905 EXPECTED(p->key != NULL) &&
6906 EXPECTED(zend_string_equal_content(p->key, name)))) {
6907 retval = &p->val;
6908 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6909 goto fetch_obj_is_copy;
6910 } else {
6911 goto fetch_obj_is_fast_copy;
6912 }
6913 }
6914 }
6915 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
6916 }
6917 retval = zend_hash_find_known_hash(zobj->properties, name);
6918 if (EXPECTED(retval)) {
6919 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
6920 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
6921 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6922 goto fetch_obj_is_copy;
6923 } else {
6924 goto fetch_obj_is_fast_copy;
6925 }
6926 }
6927 }
6928 }
6929 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6930 } else {
6931 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
6932 if (UNEXPECTED(!name)) {
6933 ZVAL_UNDEF(EX_VAR(opline->result.var));
6934 break;
6935 }
6936 }
6937
6938 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
6939
6940 if (IS_CONST != IS_CONST) {
6941 zend_tmp_string_release(tmp_name);
6942 }
6943
6944 if (retval != EX_VAR(opline->result.var)) {
6945fetch_obj_is_copy:
6946 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6947 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
6948 zend_unwrap_reference(retval);
6949 }
6950 } while (0);
6951
6952fetch_obj_is_finish:
6953
6954
6955 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6956}
6957
6958static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6959{
6960#if 0
6961 USE_OPLINE
6962#endif
6963
6964 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
6965 /* Behave like FETCH_OBJ_W */
6966 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
6967 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6968 }
6969 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6970 } else {
6971 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6972 }
6973}
6974
6975static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6976{
6977 USE_OPLINE
6978 zval *container;
6979
6980 SAVE_OPLINE();
6981 container = RT_CONSTANT(opline, opline->op1);
6982 zend_fetch_dimension_address_LIST_r(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6983
6984 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6985}
6986
6987static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6988{
6989 USE_OPLINE
6990 zval *op1, *op2;
6991 zend_string *op1_str, *op2_str, *str;
6992
6993
6994 op1 = RT_CONSTANT(opline, opline->op1);
6995 op2 = RT_CONSTANT(opline, opline->op2);
6996 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
6997 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
6998 zend_string *op1_str = Z_STR_P(op1);
6999 zend_string *op2_str = Z_STR_P(op2);
7000 zend_string *str;
7001 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
7002
7003 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
7004 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
7005 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
7006 } else {
7007 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
7008 }
7009 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7010 zend_string_release_ex(op1_str, 0);
7011 }
7012 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
7013 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
7014 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
7015 } else {
7016 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
7017 }
7018 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7019 zend_string_release_ex(op2_str, 0);
7020 }
7021 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
7022 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
7023 size_t len = ZSTR_LEN(op1_str);
7024
7025 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
7026 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
7027 GC_ADD_FLAGS(str, flags);
7028 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
7029 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7030 zend_string_release_ex(op2_str, 0);
7031 }
7032 } else {
7033 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
7034 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
7035 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
7036 GC_ADD_FLAGS(str, flags);
7037 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
7038 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7039 zend_string_release_ex(op1_str, 0);
7040 }
7041 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7042 zend_string_release_ex(op2_str, 0);
7043 }
7044 }
7045 ZEND_VM_NEXT_OPCODE();
7046 }
7047
7048 SAVE_OPLINE();
7049 if (IS_CONST == IS_CONST) {
7050 op1_str = Z_STR_P(op1);
7051 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
7052 op1_str = zend_string_copy(Z_STR_P(op1));
7053 } else {
7054 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
7055 ZVAL_UNDEFINED_OP1();
7056 }
7057 op1_str = zval_get_string_func(op1);
7058 }
7059 if (IS_CONST == IS_CONST) {
7060 op2_str = Z_STR_P(op2);
7061 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
7062 op2_str = zend_string_copy(Z_STR_P(op2));
7063 } else {
7064 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
7065 ZVAL_UNDEFINED_OP2();
7066 }
7067 op2_str = zval_get_string_func(op2);
7068 }
7069 do {
7070 if (IS_CONST != IS_CONST) {
7071 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
7072 if (IS_CONST == IS_CONST) {
7073 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
7074 GC_ADDREF(op2_str);
7075 }
7076 }
7077 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
7078 zend_string_release_ex(op1_str, 0);
7079 break;
7080 }
7081 }
7082 if (IS_CONST != IS_CONST) {
7083 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
7084 if (IS_CONST == IS_CONST) {
7085 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
7086 GC_ADDREF(op1_str);
7087 }
7088 }
7089 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
7090 zend_string_release_ex(op2_str, 0);
7091 break;
7092 }
7093 }
7094 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
7095 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
7096 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
7097
7098 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
7099 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
7100 if (IS_CONST != IS_CONST) {
7101 zend_string_release_ex(op1_str, 0);
7102 }
7103 if (IS_CONST != IS_CONST) {
7104 zend_string_release_ex(op2_str, 0);
7105 }
7106 } while (0);
7107
7108
7109 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7110}
7111
7112static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7113{
7114 USE_OPLINE
7115 zval *function_name;
7116 zval *object;
7117 zend_function *fbc;
7118 zend_class_entry *called_scope;
7119 zend_object *obj;
7120 zend_execute_data *call;
7121 uint32_t call_info;
7122
7123 SAVE_OPLINE();
7124
7125 object = RT_CONSTANT(opline, opline->op1);
7126
7127 if (IS_CONST != IS_CONST) {
7128 function_name = RT_CONSTANT(opline, opline->op2);
7129 }
7130
7131 if (IS_CONST != IS_CONST &&
7132 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
7133 do {
7134 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
7135 function_name = Z_REFVAL_P(function_name);
7136 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
7137 break;
7138 }
7139 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
7140 ZVAL_UNDEFINED_OP2();
7141 if (UNEXPECTED(EG(exception) != NULL)) {
7142
7143 HANDLE_EXCEPTION();
7144 }
7145 }
7146 zend_throw_error(NULL, "Method name must be a string");
7147
7148
7149 HANDLE_EXCEPTION();
7150 } while (0);
7151 }
7152
7153 if (IS_CONST == IS_UNUSED) {
7154 obj = Z_OBJ_P(object);
7155 } else {
7156 do {
7157 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
7158 obj = Z_OBJ_P(object);
7159 } else {
7160 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
7161 zend_reference *ref = Z_REF_P(object);
7162
7163 object = &ref->val;
7164 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
7165 obj = Z_OBJ_P(object);
7166 if (IS_CONST & IS_VAR) {
7167 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
7168 efree_size(ref, sizeof(zend_reference));
7169 } else {
7170 Z_ADDREF_P(object);
7171 }
7172 }
7173 break;
7174 }
7175 }
7176 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
7177 object = ZVAL_UNDEFINED_OP1();
7178 if (UNEXPECTED(EG(exception) != NULL)) {
7179 if (IS_CONST != IS_CONST) {
7180
7181 }
7182 HANDLE_EXCEPTION();
7183 }
7184 }
7185 if (IS_CONST == IS_CONST) {
7186 function_name = RT_CONSTANT(opline, opline->op2);
7187 }
7188 zend_invalid_method_call(object, function_name);
7189
7190
7191 HANDLE_EXCEPTION();
7192 }
7193 } while (0);
7194 }
7195
7196 called_scope = obj->ce;
7197
7198 if (IS_CONST == IS_CONST &&
7199 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
7200 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
7201 } else {
7202 zend_object *orig_obj = obj;
7203
7204 if (IS_CONST == IS_CONST) {
7205 function_name = RT_CONSTANT(opline, opline->op2);
7206 }
7207
7208 /* First, locate the function. */
7209 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
7210 if (UNEXPECTED(fbc == NULL)) {
7211 if (EXPECTED(!EG(exception))) {
7212 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
7213 }
7214
7215 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
7216 zend_objects_store_del(orig_obj);
7217 }
7218 HANDLE_EXCEPTION();
7219 }
7220 if (IS_CONST == IS_CONST &&
7221 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
7222 EXPECTED(obj == orig_obj)) {
7223 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
7224 }
7225 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
7226 GC_ADDREF(obj); /* For $this pointer */
7227 if (GC_DELREF(orig_obj) == 0) {
7228 zend_objects_store_del(orig_obj);
7229 }
7230 }
7231 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7232 init_func_run_time_cache(&fbc->op_array);
7233 }
7234 }
7235
7236 if (IS_CONST != IS_CONST) {
7237
7238 }
7239
7240 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
7241 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
7242 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
7243 zend_objects_store_del(obj);
7244 if (UNEXPECTED(EG(exception))) {
7245 HANDLE_EXCEPTION();
7246 }
7247 }
7248 /* call static method */
7249 obj = (zend_object*)called_scope;
7250 call_info = ZEND_CALL_NESTED_FUNCTION;
7251 } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
7252 if (IS_CONST == IS_CV) {
7253 GC_ADDREF(obj); /* For $this pointer */
7254 }
7255 /* CV may be changed indirectly (e.g. when it's a reference) */
7256 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
7257 }
7258
7259 call = zend_vm_stack_push_call_frame(call_info,
7260 fbc, opline->extended_value, obj);
7261 call->prev_execute_data = EX(call);
7262 EX(call) = call;
7263
7264 ZEND_VM_NEXT_OPCODE();
7265}
7266
7267static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7268{
7269 USE_OPLINE
7270 zval *function_name;
7271 zend_class_entry *ce;
7272 uint32_t call_info;
7273 zend_function *fbc;
7274 zend_execute_data *call;
7275
7276 SAVE_OPLINE();
7277
7278 if (IS_CONST == IS_CONST) {
7279 /* no function found. try a static method in class */
7280 ce = CACHED_PTR(opline->result.num);
7281 if (UNEXPECTED(ce == NULL)) {
7282 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);
7283 if (UNEXPECTED(ce == NULL)) {
7284
7285 HANDLE_EXCEPTION();
7286 }
7287 if (IS_CONST != IS_CONST) {
7288 CACHE_PTR(opline->result.num, ce);
7289 }
7290 }
7291 } else if (IS_CONST == IS_UNUSED) {
7292 ce = zend_fetch_class(NULL, opline->op1.num);
7293 if (UNEXPECTED(ce == NULL)) {
7294
7295 HANDLE_EXCEPTION();
7296 }
7297 } else {
7298 ce = Z_CE_P(EX_VAR(opline->op1.var));
7299 }
7300
7301 if (IS_CONST == IS_CONST &&
7302 IS_CONST == IS_CONST &&
7303 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
7304 /* nothing to do */
7305 } else if (IS_CONST != IS_CONST &&
7306 IS_CONST == IS_CONST &&
7307 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
7308 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
7309 } else if (IS_CONST != IS_UNUSED) {
7310 function_name = RT_CONSTANT(opline, opline->op2);
7311 if (IS_CONST != IS_CONST) {
7312 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
7313 do {
7314 if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
7315 function_name = Z_REFVAL_P(function_name);
7316 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
7317 break;
7318 }
7319 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
7320 ZVAL_UNDEFINED_OP2();
7321 if (UNEXPECTED(EG(exception) != NULL)) {
7322 HANDLE_EXCEPTION();
7323 }
7324 }
7325 zend_throw_error(NULL, "Method name must be a string");
7326
7327 HANDLE_EXCEPTION();
7328 } while (0);
7329 }
7330 }
7331
7332 if (ce->get_static_method) {
7333 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
7334 } else {
7335 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
7336 }
7337 if (UNEXPECTED(fbc == NULL)) {
7338 if (EXPECTED(!EG(exception))) {
7339 zend_undefined_method(ce, Z_STR_P(function_name));
7340 }
7341
7342 HANDLE_EXCEPTION();
7343 }
7344 if (IS_CONST == IS_CONST &&
7345 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
7346 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
7347 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
7348 }
7349 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7350 init_func_run_time_cache(&fbc->op_array);
7351 }
7352 if (IS_CONST != IS_CONST) {
7353
7354 }
7355 } else {
7356 if (UNEXPECTED(ce->constructor == NULL)) {
7357 zend_throw_error(NULL, "Cannot call constructor");
7358 HANDLE_EXCEPTION();
7359 }
7360 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
7361 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
7362 HANDLE_EXCEPTION();
7363 }
7364 fbc = ce->constructor;
7365 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7366 init_func_run_time_cache(&fbc->op_array);
7367 }
7368 }
7369
7370 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
7371 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
7372 ce = (zend_class_entry*)Z_OBJ(EX(This));
7373 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
7374 } else {
7375 zend_non_static_method_call(fbc);
7376 HANDLE_EXCEPTION();
7377 }
7378 } else {
7379 /* previous opcode is ZEND_FETCH_CLASS */
7380 if (IS_CONST == IS_UNUSED
7381 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
7382 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
7383 if (Z_TYPE(EX(This)) == IS_OBJECT) {
7384 ce = Z_OBJCE(EX(This));
7385 } else {
7386 ce = Z_CE(EX(This));
7387 }
7388 }
7389 call_info = ZEND_CALL_NESTED_FUNCTION;
7390 }
7391
7392 call = zend_vm_stack_push_call_frame(call_info,
7393 fbc, opline->extended_value, ce);
7394 call->prev_execute_data = EX(call);
7395 EX(call) = call;
7396
7397 ZEND_VM_NEXT_OPCODE();
7398}
7399
7400static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7401{
7402 USE_OPLINE
7403 zval *function_name;
7404 zend_fcall_info_cache fcc;
7405 char *error = NULL;
7406 zend_function *func;
7407 void *object_or_called_scope;
7408 zend_execute_data *call;
7409 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
7410
7411 SAVE_OPLINE();
7412 function_name = RT_CONSTANT(opline, opline->op2);
7413 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
7414 ZEND_ASSERT(!error);
7415
7416 /* Deprecation can be emitted from zend_is_callable_ex(), which can
7417 * invoke a user error handler and throw an exception.
7418 * For the CONST and CV case we reuse the same exception block below
7419 * to make sure we don't increase VM size too much. */
7420 if (!(IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
7421
7422 HANDLE_EXCEPTION();
7423 }
7424
7425 func = fcc.function_handler;
7426 object_or_called_scope = fcc.called_scope;
7427 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
7428 /* Delay closure destruction until its invocation */
7429 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
7430 call_info |= ZEND_CALL_CLOSURE;
7431 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
7432 call_info |= ZEND_CALL_FAKE_CLOSURE;
7433 }
7434 if (fcc.object) {
7435 object_or_called_scope = fcc.object;
7436 call_info |= ZEND_CALL_HAS_THIS;
7437 }
7438 } else if (fcc.object) {
7439 GC_ADDREF(fcc.object); /* For $this pointer */
7440 object_or_called_scope = fcc.object;
7441 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
7442 }
7443
7444 if ((IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
7445 if (call_info & ZEND_CALL_CLOSURE) {
7446 zend_object_release(ZEND_CLOSURE_OBJECT(func));
7447 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
7448 zend_object_release(fcc.object);
7449 }
7450 HANDLE_EXCEPTION();
7451 }
7452
7453 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
7454 init_func_run_time_cache(&func->op_array);
7455 }
7456 } else {
7457 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
7458 efree(error);
7459
7460 HANDLE_EXCEPTION();
7461 }
7462
7463 call = zend_vm_stack_push_call_frame(call_info,
7464 func, opline->extended_value, object_or_called_scope);
7465 call->prev_execute_data = EX(call);
7466 EX(call) = call;
7467
7468 ZEND_VM_NEXT_OPCODE();
7469}
7470
7471static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7472{
7473 USE_OPLINE
7474 zval *value, *arg;
7475
7476 if (IS_CONST == IS_CONST) {
7477 SAVE_OPLINE();
7478 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7479 uint32_t arg_num;
7480 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7481 if (UNEXPECTED(!arg)) {
7482
7483 HANDLE_EXCEPTION();
7484 }
7485 } else {
7486 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7487 }
7488
7489 value = RT_CONSTANT(opline, opline->op1);
7490 ZVAL_COPY_VALUE(arg, value);
7491 if (IS_CONST == IS_CONST) {
7492 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7493 Z_ADDREF_P(arg);
7494 }
7495 }
7496 ZEND_VM_NEXT_OPCODE();
7497}
7498
7499static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7500{
7501 USE_OPLINE
7502 zval *value, *arg;
7503 uint32_t arg_num;
7504
7505 if (IS_CONST == IS_CONST) {
7506 SAVE_OPLINE();
7507 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7508 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7509 if (UNEXPECTED(!arg)) {
7510
7511 HANDLE_EXCEPTION();
7512 }
7513 } else {
7514 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7515 arg_num = opline->op2.num;
7516 }
7517
7518 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
7519 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7520 goto send_val_by_ref;
7521 }
7522 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7523send_val_by_ref:
7524 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
7525 }
7526 value = RT_CONSTANT(opline, opline->op1);
7527 ZVAL_COPY_VALUE(arg, value);
7528 if (IS_CONST == IS_CONST) {
7529 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7530 Z_ADDREF_P(arg);
7531 }
7532 }
7533 ZEND_VM_NEXT_OPCODE();
7534}
7535
7536static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7537{
7538 zend_class_entry *ce, *scope;
7539 zend_class_constant *c;
7540 zval *value, *zv, *constant_zv;
7541 zend_string *constant_name;
7542 USE_OPLINE
7543
7544 SAVE_OPLINE();
7545
7546 do {
7547 if (IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
7548 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
7549 value = CACHED_PTR(opline->extended_value + sizeof(void*));
7550 break;
7551 }
7552 }
7553 if (IS_CONST == IS_CONST) {
7554 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
7555 ce = CACHED_PTR(opline->extended_value);
7556 } else {
7557 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);
7558 if (UNEXPECTED(ce == NULL)) {
7559 ZVAL_UNDEF(EX_VAR(opline->result.var));
7560
7561 HANDLE_EXCEPTION();
7562 }
7563 CACHE_PTR(opline->extended_value, ce);
7564 }
7565 } else if (IS_CONST == IS_UNUSED) {
7566 ce = zend_fetch_class(NULL, opline->op1.num);
7567 if (UNEXPECTED(ce == NULL)) {
7568 ZVAL_UNDEF(EX_VAR(opline->result.var));
7569
7570 HANDLE_EXCEPTION();
7571 }
7572 } else {
7573 ce = Z_CE_P(EX_VAR(opline->op1.var));
7574 }
7575 if (IS_CONST != IS_CONST
7576 && IS_CONST == IS_CONST
7577 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
7578 value = CACHED_PTR(opline->extended_value + sizeof(void*));
7579 break;
7580 }
7581
7582 constant_zv = RT_CONSTANT(opline, opline->op2);
7583 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
7584 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
7585 ZVAL_UNDEF(EX_VAR(opline->result.var));
7586
7587 HANDLE_EXCEPTION();
7588 }
7589 constant_name = Z_STR_P(constant_zv);
7590 /* Magic 'class' for constant OP2 is caught at compile-time */
7591 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
7592 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
7593
7594 ZEND_VM_NEXT_OPCODE();
7595 }
7596 zv = IS_CONST == IS_CONST
7597 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
7598 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
7599
7600 if (EXPECTED(zv != NULL)) {
7601 c = Z_PTR_P(zv);
7602 scope = EX(func)->op_array.scope;
7603 if (!zend_verify_const_access(c, scope)) {
7604 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));
7605 ZVAL_UNDEF(EX_VAR(opline->result.var));
7606
7607 HANDLE_EXCEPTION();
7608 }
7609
7610 if (ce->ce_flags & ZEND_ACC_TRAIT) {
7611 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7612 ZVAL_UNDEF(EX_VAR(opline->result.var));
7613
7614 HANDLE_EXCEPTION();
7615 }
7616
7617 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
7618 if (UNEXPECTED(is_constant_deprecated)) {
7619 zend_deprecated_class_constant(c, constant_name);
7620
7621 if (EG(exception)) {
7622 ZVAL_UNDEF(EX_VAR(opline->result.var));
7623
7624 HANDLE_EXCEPTION();
7625 }
7626 }
7627
7628 value = &c->value;
7629 // Enums require loading of all class constants to build the backed enum table
7630 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)) {
7631 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
7632 ZVAL_UNDEF(EX_VAR(opline->result.var));
7633
7634 HANDLE_EXCEPTION();
7635 }
7636 }
7637 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
7638 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
7639 ZVAL_UNDEF(EX_VAR(opline->result.var));
7640
7641 HANDLE_EXCEPTION();
7642 }
7643 }
7644 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
7645 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
7646 }
7647 } else {
7648 zend_throw_error(NULL, "Undefined constant %s::%s",
7649 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7650 ZVAL_UNDEF(EX_VAR(opline->result.var));
7651
7652 HANDLE_EXCEPTION();
7653 }
7654 } while (0);
7655
7656 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
7657
7658 ZEND_VM_NEXT_OPCODE();
7659}
7660
7661static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7662{
7663 USE_OPLINE
7664 zval *expr_ptr, new_expr;
7665
7666 SAVE_OPLINE();
7667 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
7668 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
7669 expr_ptr = zend_get_bad_ptr();
7670 if (Z_ISREF_P(expr_ptr)) {
7671 Z_ADDREF_P(expr_ptr);
7672 } else {
7673 ZVAL_MAKE_REF_EX(expr_ptr, 2);
7674 }
7675
7676 } else {
7677 expr_ptr = RT_CONSTANT(opline, opline->op1);
7678 if (IS_CONST == IS_TMP_VAR) {
7679 /* pass */
7680 } else if (IS_CONST == IS_CONST) {
7681 Z_TRY_ADDREF_P(expr_ptr);
7682 } else if (IS_CONST == IS_CV) {
7683 ZVAL_DEREF(expr_ptr);
7684 Z_TRY_ADDREF_P(expr_ptr);
7685 } else /* if (IS_CONST == IS_VAR) */ {
7686 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
7687 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
7688
7689 expr_ptr = Z_REFVAL_P(expr_ptr);
7690 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
7691 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
7692 expr_ptr = &new_expr;
7693 efree_size(ref, sizeof(zend_reference));
7694 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
7695 Z_ADDREF_P(expr_ptr);
7696 }
7697 }
7698 }
7699 }
7700
7701 if (IS_CONST != IS_UNUSED) {
7702 zval *offset = RT_CONSTANT(opline, opline->op2);
7703 zend_string *str;
7704 zend_ulong hval;
7705
7706add_again:
7707 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7708 str = Z_STR_P(offset);
7709 if (IS_CONST != IS_CONST) {
7710 if (ZEND_HANDLE_NUMERIC(str, hval)) {
7711 goto num_index;
7712 }
7713 }
7714str_index:
7715 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
7716 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7717 hval = Z_LVAL_P(offset);
7718num_index:
7719 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
7720 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
7721 offset = Z_REFVAL_P(offset);
7722 goto add_again;
7723 } else if (Z_TYPE_P(offset) == IS_NULL) {
7724 str = ZSTR_EMPTY_ALLOC();
7725 goto str_index;
7726 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
7727 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
7728 goto num_index;
7729 } else if (Z_TYPE_P(offset) == IS_FALSE) {
7730 hval = 0;
7731 goto num_index;
7732 } else if (Z_TYPE_P(offset) == IS_TRUE) {
7733 hval = 1;
7734 goto num_index;
7735 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
7736 zend_use_resource_as_offset(offset);
7737 hval = Z_RES_HANDLE_P(offset);
7738 goto num_index;
7739 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
7740 ZVAL_UNDEFINED_OP2();
7741 str = ZSTR_EMPTY_ALLOC();
7742 goto str_index;
7743 } else {
7744 zend_illegal_array_offset_access(offset);
7745 zval_ptr_dtor_nogc(expr_ptr);
7746 }
7747
7748 } else {
7749 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
7750 zend_cannot_add_element();
7751 zval_ptr_dtor_nogc(expr_ptr);
7752 }
7753 }
7754 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7755}
7756
7757static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7758{
7759 zval *array;
7760 uint32_t size;
7761 USE_OPLINE
7762
7763 SAVE_OPLINE();
7764 array = EX_VAR(opline->result.var);
7765 if (IS_CONST != IS_UNUSED) {
7766 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
7767 ZVAL_ARR(array, zend_new_array(size));
7768 /* Explicitly initialize array as not-packed if flag is set */
7769 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
7770 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
7771 }
7772 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7773 } else {
7774 ZVAL_ARR(array, zend_new_array(0));
7775 ZEND_VM_NEXT_OPCODE();
7776 }
7777}
7778
7779static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7780{
7781 USE_OPLINE
7782 zval *container;
7783 bool result;
7784 zend_ulong hval;
7785 zval *offset;
7786
7787 SAVE_OPLINE();
7788 container = RT_CONSTANT(opline, opline->op1);
7789 offset = RT_CONSTANT(opline, opline->op2);
7790
7791 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7792 HashTable *ht;
7793 zval *value;
7794 zend_string *str;
7795
7796isset_dim_obj_array:
7797 ht = Z_ARRVAL_P(container);
7798isset_again:
7799 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7800 str = Z_STR_P(offset);
7801 if (IS_CONST != IS_CONST) {
7802 if (ZEND_HANDLE_NUMERIC(str, hval)) {
7803 goto num_index_prop;
7804 }
7805 }
7806 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
7807 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7808 hval = Z_LVAL_P(offset);
7809num_index_prop:
7810 value = zend_hash_index_find(ht, hval);
7811 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
7812 offset = Z_REFVAL_P(offset);
7813 goto isset_again;
7814 } else {
7815 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
7816 if (UNEXPECTED(EG(exception))) {
7817 result = 0;
7818 goto isset_dim_obj_exit;
7819 }
7820 }
7821
7822 if (!(opline->extended_value & ZEND_ISEMPTY)) {
7823 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
7824 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
7825 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
7826
7827 if (IS_CONST & (IS_CONST|IS_CV)) {
7828 /* avoid exception check */
7829
7830 ZEND_VM_SMART_BRANCH(result, 0);
7831 }
7832 } else {
7833 result = (value == NULL || !i_zend_is_true(value));
7834 }
7835 goto isset_dim_obj_exit;
7836 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
7837 container = Z_REFVAL_P(container);
7838 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7839 goto isset_dim_obj_array;
7840 }
7841 }
7842
7843 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
7844 offset++;
7845 }
7846 if (!(opline->extended_value & ZEND_ISEMPTY)) {
7847 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
7848 } else {
7849 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
7850 }
7851
7852isset_dim_obj_exit:
7853
7854
7855 ZEND_VM_SMART_BRANCH(result, 1);
7856}
7857
7858static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7859{
7860 USE_OPLINE
7861 zval *container;
7862 int result;
7863 zval *offset;
7864 zend_string *name, *tmp_name;
7865
7866 SAVE_OPLINE();
7867 container = RT_CONSTANT(opline, opline->op1);
7868 offset = RT_CONSTANT(opline, opline->op2);
7869
7870 if (IS_CONST == IS_CONST ||
7871 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
7872 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
7873 container = Z_REFVAL_P(container);
7874 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
7875 result = (opline->extended_value & ZEND_ISEMPTY);
7876 goto isset_object_finish;
7877 }
7878 } else {
7879 result = (opline->extended_value & ZEND_ISEMPTY);
7880 goto isset_object_finish;
7881 }
7882 }
7883
7884 if (IS_CONST == IS_CONST) {
7885 name = Z_STR_P(offset);
7886 } else {
7887 name = zval_try_get_tmp_string(offset, &tmp_name);
7888 if (UNEXPECTED(!name)) {
7889 result = 0;
7890 goto isset_object_finish;
7891 }
7892 }
7893
7894 result =
7895 (opline->extended_value & ZEND_ISEMPTY) ^
7896 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));
7897
7898 if (IS_CONST != IS_CONST) {
7899 zend_tmp_string_release(tmp_name);
7900 }
7901
7902isset_object_finish:
7903
7904
7905 ZEND_VM_SMART_BRANCH(result, 1);
7906}
7907
7908static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7909{
7910 USE_OPLINE
7911
7912 zval *key, *subject;
7913 HashTable *ht;
7914 bool result;
7915
7916 SAVE_OPLINE();
7917
7918 key = RT_CONSTANT(opline, opline->op1);
7919 subject = RT_CONSTANT(opline, opline->op2);
7920
7921 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7922array_key_exists_array:
7923 ht = Z_ARRVAL_P(subject);
7924 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
7925 } else {
7926 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
7927 subject = Z_REFVAL_P(subject);
7928 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7929 goto array_key_exists_array;
7930 }
7931 }
7932 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
7933 result = 0;
7934 }
7935
7936
7937 ZEND_VM_SMART_BRANCH(result, 1);
7938}
7939
7940static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7941{
7942 USE_OPLINE
7943
7944 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
7945 if (ce == NULL) {
7946 zval *lcname = RT_CONSTANT(opline, opline->op1);
7947 zval *zv = zend_hash_find_known_hash(EG(class_table), Z_STR_P(lcname + 1));
7948 if (zv) {
7949 SAVE_OPLINE();
7950 ce = zend_bind_class_in_slot(zv, lcname, Z_STR_P(RT_CONSTANT(opline, opline->op2)));
7951 if (!ce) {
7952 HANDLE_EXCEPTION();
7953 }
7954 }
7955 CACHE_PTR(opline->extended_value, ce);
7956 }
7957 ZEND_VM_NEXT_OPCODE();
7958}
7959
7960static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7961{
7962 USE_OPLINE
7963 zval *name;
7964 zval *val;
7965 zend_constant c;
7966
7967 SAVE_OPLINE();
7968 name = RT_CONSTANT(opline, opline->op1);
7969 val = RT_CONSTANT(opline, opline->op2);
7970
7971 ZVAL_COPY(&c.value, val);
7972 if (Z_OPT_CONSTANT(c.value)) {
7973 if (UNEXPECTED(zval_update_constant_ex(&c.value, EX(func)->op_array.scope) != SUCCESS)) {
7974 zval_ptr_dtor_nogc(&c.value);
7975
7976
7977 HANDLE_EXCEPTION();
7978 }
7979 }
7980 /* non persistent, case sensitive */
7981 ZEND_CONSTANT_SET_FLAGS(&c, 0, PHP_USER_CONSTANT);
7982 c.name = zend_string_copy(Z_STR_P(name));
7983
7984 if (zend_register_constant(&c) == FAILURE) {
7985 }
7986
7987
7988 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7989}
7990
7991static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7992{
7993 USE_OPLINE
7994
7995 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
7996
7997 SAVE_OPLINE();
7998 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
7999 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
8000 }
8001
8002 /* Destroy the previously yielded value */
8003 zval_ptr_dtor(&generator->value);
8004
8005 /* Destroy the previously yielded key */
8006 zval_ptr_dtor(&generator->key);
8007
8008 /* Set the new yielded value */
8009 if (IS_CONST != IS_UNUSED) {
8010 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
8011 /* Constants and temporary variables aren't yieldable by reference,
8012 * but we still allow them with a notice. */
8013 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
8014 zval *value;
8015
8016 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
8017
8018 value = RT_CONSTANT(opline, opline->op1);
8019 ZVAL_COPY_VALUE(&generator->value, value);
8020 if (IS_CONST == IS_CONST) {
8021 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
8022 Z_ADDREF(generator->value);
8023 }
8024 }
8025 } else {
8026 zval *value_ptr = zend_get_bad_ptr();
8027
8028 /* If a function call result is yielded and the function did
8029 * not return by reference we throw a notice. */
8030 do {
8031 if (IS_CONST == IS_VAR) {
8032 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
8033 if (opline->extended_value == ZEND_RETURNS_FUNCTION
8034 && !Z_ISREF_P(value_ptr)) {
8035 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
8036 ZVAL_COPY(&generator->value, value_ptr);
8037 break;
8038 }
8039 }
8040 if (Z_ISREF_P(value_ptr)) {
8041 Z_ADDREF_P(value_ptr);
8042 } else {
8043 ZVAL_MAKE_REF_EX(value_ptr, 2);
8044 }
8045 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
8046 } while (0);
8047
8048 }
8049 } else {
8050 zval *value = RT_CONSTANT(opline, opline->op1);
8051
8052 /* Consts, temporary variables and references need copying */
8053 if (IS_CONST == IS_CONST) {
8054 ZVAL_COPY_VALUE(&generator->value, value);
8055 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
8056 Z_ADDREF(generator->value);
8057 }
8058 } else if (IS_CONST == IS_TMP_VAR) {
8059 ZVAL_COPY_VALUE(&generator->value, value);
8060 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
8061 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
8062
8063 } else {
8064 ZVAL_COPY_VALUE(&generator->value, value);
8065 if (IS_CONST == IS_CV) {
8066 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
8067 }
8068 }
8069 }
8070 } else {
8071 /* If no value was specified yield null */
8072 ZVAL_NULL(&generator->value);
8073 }
8074
8075 /* Set the new yielded key */
8076 if (IS_CONST != IS_UNUSED) {
8077 zval *key = RT_CONSTANT(opline, opline->op2);
8078 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
8079 key = Z_REFVAL_P(key);
8080 }
8081 ZVAL_COPY(&generator->key, key);
8082
8083 if (Z_TYPE(generator->key) == IS_LONG
8084 && Z_LVAL(generator->key) > generator->largest_used_integer_key
8085 ) {
8086 generator->largest_used_integer_key = Z_LVAL(generator->key);
8087 }
8088 } else {
8089 /* If no key was specified we use auto-increment keys */
8090 generator->largest_used_integer_key++;
8091 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
8092 }
8093
8094 if (RETURN_VALUE_USED(opline)) {
8095 /* If the return value of yield is used set the send
8096 * target and initialize it to NULL */
8097 generator->send_target = EX_VAR(opline->result.var);
8098 ZVAL_NULL(generator->send_target);
8099 } else {
8100 generator->send_target = NULL;
8101 }
8102
8103 /* The GOTO VM uses a local opline variable. We need to set the opline
8104 * variable in execute_data so we don't resume at an old position. */
8105 SAVE_OPLINE();
8106
8107 ZEND_VM_RETURN();
8108}
8109
8110static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8111{
8112 USE_OPLINE
8113 zval *op, *jump_zv;
8114 HashTable *jumptable;
8115
8116 op = RT_CONSTANT(opline, opline->op1);
8117
8118 if (Z_TYPE_P(op) != IS_LONG) {
8119 ZVAL_DEREF(op);
8120 if (Z_TYPE_P(op) != IS_LONG) {
8121 /* Wrong type, fall back to ZEND_CASE chain */
8122 ZEND_VM_NEXT_OPCODE();
8123 }
8124 }
8125
8126 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8127 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
8128 if (jump_zv != NULL) {
8129 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8130 ZEND_VM_CONTINUE();
8131 } else {
8132 /* default */
8133 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8134 ZEND_VM_CONTINUE();
8135 }
8136}
8137
8138static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8139{
8140 USE_OPLINE
8141 zval *op, *jump_zv;
8142 HashTable *jumptable;
8143
8144 op = RT_CONSTANT(opline, opline->op1);
8145
8146 if (Z_TYPE_P(op) != IS_STRING) {
8147 if (IS_CONST == IS_CONST) {
8148 /* Wrong type, fall back to ZEND_CASE chain */
8149 ZEND_VM_NEXT_OPCODE();
8150 } else {
8151 ZVAL_DEREF(op);
8152 if (Z_TYPE_P(op) != IS_STRING) {
8153 /* Wrong type, fall back to ZEND_CASE chain */
8154 ZEND_VM_NEXT_OPCODE();
8155 }
8156 }
8157 }
8158
8159 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8160 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
8161 if (jump_zv != NULL) {
8162 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8163 ZEND_VM_CONTINUE();
8164 } else {
8165 /* default */
8166 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8167 ZEND_VM_CONTINUE();
8168 }
8169}
8170
8171static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8172{
8173 USE_OPLINE
8174 zval *op, *jump_zv;
8175 HashTable *jumptable;
8176
8177 op = RT_CONSTANT(opline, opline->op1);
8178 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8179
8180match_try_again:
8181 if (Z_TYPE_P(op) == IS_LONG) {
8182 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
8183 } else if (Z_TYPE_P(op) == IS_STRING) {
8184 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
8185 } else if (Z_TYPE_P(op) == IS_REFERENCE) {
8186 op = Z_REFVAL_P(op);
8187 goto match_try_again;
8188 } else {
8189 if (UNEXPECTED((IS_CONST & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
8190 SAVE_OPLINE();
8191 op = ZVAL_UNDEFINED_OP1();
8192 if (UNEXPECTED(EG(exception))) {
8193 HANDLE_EXCEPTION();
8194 }
8195 goto match_try_again;
8196 }
8197
8198 goto default_branch;
8199 }
8200
8201 if (jump_zv != NULL) {
8202 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8203 ZEND_VM_CONTINUE();
8204 } else {
8205default_branch:
8206 /* default */
8207 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8208 ZEND_VM_CONTINUE();
8209 }
8210}
8211
8212static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8213{
8214 USE_OPLINE
8215 zval *op1;
8216 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8217 zval *result;
8218
8219 op1 = RT_CONSTANT(opline, opline->op1);
8220 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8221 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CONST == IS_CONST);
8222 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
8223 zval_ptr_dtor_str(op1);
8224 }
8225 ZEND_VM_SMART_BRANCH(result, 0);
8226 }
8227
8228 if (opline->extended_value) {
8229 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
8230 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
8231 ZEND_VM_SMART_BRANCH(result, 0);
8232 }
8233 SAVE_OPLINE();
8234 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
8235 op1 = Z_REFVAL_P(op1);
8236 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8237 result = zend_hash_find(ht, Z_STR_P(op1));
8238
8239 ZEND_VM_SMART_BRANCH(result, 0);
8240 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
8241 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
8242
8243 ZEND_VM_SMART_BRANCH(result, 0);
8244 }
8245 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8246 ZVAL_UNDEFINED_OP1();
8247 }
8248 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
8249 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8250 SAVE_OPLINE();
8251 ZVAL_UNDEFINED_OP1();
8252 if (UNEXPECTED(EG(exception) != NULL)) {
8253 HANDLE_EXCEPTION();
8254 }
8255 }
8256 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
8257 ZEND_VM_SMART_BRANCH(result, 0);
8258 } else {
8259 zend_string *key;
8260 zval key_tmp;
8261
8262 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
8263 op1 = Z_REFVAL_P(op1);
8264 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8265 result = zend_hash_find(ht, Z_STR_P(op1));
8266
8267 ZEND_VM_SMART_BRANCH(result, 0);
8268 }
8269 }
8270
8271 SAVE_OPLINE();
8272 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
8273 ZVAL_STR(&key_tmp, key);
8274 if (zend_compare(op1, &key_tmp) == 0) {
8275
8276 ZEND_VM_SMART_BRANCH(1, 1);
8277 }
8278 } ZEND_HASH_FOREACH_END();
8279 }
8280
8281 ZEND_VM_SMART_BRANCH(0, 1);
8282}
8283
8284static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8285{
8286 USE_OPLINE
8287 zval *op1, *op2, *result;
8288 double d1, d2;
8289
8290 op1 = RT_CONSTANT(opline, opline->op1);
8291 op2 = EX_VAR(opline->op2.var);
8292 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8293 /* pass */
8294 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8295 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8296 result = EX_VAR(opline->result.var);
8297 fast_long_add_function(result, op1, op2);
8298 ZEND_VM_NEXT_OPCODE();
8299 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8300 d1 = (double)Z_LVAL_P(op1);
8301 d2 = Z_DVAL_P(op2);
8302 goto add_double;
8303 }
8304 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8305 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8306 d1 = Z_DVAL_P(op1);
8307 d2 = Z_DVAL_P(op2);
8308add_double:
8309 result = EX_VAR(opline->result.var);
8310 ZVAL_DOUBLE(result, d1 + d2);
8311 ZEND_VM_NEXT_OPCODE();
8312 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8313 d1 = Z_DVAL_P(op1);
8314 d2 = (double)Z_LVAL_P(op2);
8315 goto add_double;
8316 }
8317 }
8318
8319 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8320}
8321
8322static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8323{
8324 USE_OPLINE
8325 zval *op1, *op2, *result;
8326 double d1, d2;
8327
8328 op1 = RT_CONSTANT(opline, opline->op1);
8329 op2 = EX_VAR(opline->op2.var);
8330 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8331 /* pass */
8332 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8333 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8334 result = EX_VAR(opline->result.var);
8335 fast_long_sub_function(result, op1, op2);
8336 ZEND_VM_NEXT_OPCODE();
8337 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8338 d1 = (double)Z_LVAL_P(op1);
8339 d2 = Z_DVAL_P(op2);
8340 goto sub_double;
8341 }
8342 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8343 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8344 d1 = Z_DVAL_P(op1);
8345 d2 = Z_DVAL_P(op2);
8346sub_double:
8347 result = EX_VAR(opline->result.var);
8348 ZVAL_DOUBLE(result, d1 - d2);
8349 ZEND_VM_NEXT_OPCODE();
8350 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8351 d1 = Z_DVAL_P(op1);
8352 d2 = (double)Z_LVAL_P(op2);
8353 goto sub_double;
8354 }
8355 }
8356
8357 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8358}
8359
8360static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8361{
8362 USE_OPLINE
8363 zval *op1, *op2, *result;
8364
8365 op1 = RT_CONSTANT(opline, opline->op1);
8366 op2 = EX_VAR(opline->op2.var);
8367 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8368 /* pass */
8369 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8370 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8371 result = EX_VAR(opline->result.var);
8372 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
8373 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
8374 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
8375 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
8376 ZVAL_LONG(result, 0);
8377 } else {
8378 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
8379 }
8380 ZEND_VM_NEXT_OPCODE();
8381 }
8382 }
8383
8384 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8385}
8386
8387static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8388{
8389 USE_OPLINE
8390 zval *op1, *op2;
8391
8392 op1 = RT_CONSTANT(opline, opline->op1);
8393 op2 = EX_VAR(opline->op2.var);
8394 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8395 /* pass */
8396 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8397 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8398 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8399 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
8400 ZVAL_LONG(EX_VAR(opline->result.var),
8401 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
8402 ZEND_VM_NEXT_OPCODE();
8403 }
8404
8405 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8406}
8407
8408static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8409{
8410 USE_OPLINE
8411 zval *op1, *op2;
8412
8413 op1 = RT_CONSTANT(opline, opline->op1);
8414 op2 = EX_VAR(opline->op2.var);
8415 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8416 /* pass */
8417 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8418 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8419 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8420 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
8421 ZEND_VM_NEXT_OPCODE();
8422 }
8423
8424 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8425}
8426
8427static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8428{
8429 USE_OPLINE
8430 zval *op1, *op2;
8431 double d1, d2;
8432
8433 op1 = RT_CONSTANT(opline, opline->op1);
8434 op2 = EX_VAR(opline->op2.var);
8435 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8436 /* pass */
8437 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8438 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8439 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8440is_smaller_true:
8441 ZEND_VM_SMART_BRANCH_TRUE_NONE();
8442 } else {
8443is_smaller_false:
8444 ZEND_VM_SMART_BRANCH_FALSE_NONE();
8445 }
8446 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8447 d1 = (double)Z_LVAL_P(op1);
8448 d2 = Z_DVAL_P(op2);
8449 goto is_smaller_double;
8450 }
8451 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8452 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8453 d1 = Z_DVAL_P(op1);
8454 d2 = Z_DVAL_P(op2);
8455is_smaller_double:
8456 if (d1 < d2) {
8457 goto is_smaller_true;
8458 } else {
8459 goto is_smaller_false;
8460 }
8461 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8462 d1 = Z_DVAL_P(op1);
8463 d2 = (double)Z_LVAL_P(op2);
8464 goto is_smaller_double;
8465 }
8466 }
8467 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8468}
8469
8470static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8471{
8472 USE_OPLINE
8473 zval *op1, *op2;
8474 double d1, d2;
8475
8476 op1 = RT_CONSTANT(opline, opline->op1);
8477 op2 = EX_VAR(opline->op2.var);
8478 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8479 /* pass */
8480 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8481 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8482 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8483is_smaller_true:
8484 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8485 } else {
8486is_smaller_false:
8487 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8488 }
8489 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8490 d1 = (double)Z_LVAL_P(op1);
8491 d2 = Z_DVAL_P(op2);
8492 goto is_smaller_double;
8493 }
8494 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8495 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8496 d1 = Z_DVAL_P(op1);
8497 d2 = Z_DVAL_P(op2);
8498is_smaller_double:
8499 if (d1 < d2) {
8500 goto is_smaller_true;
8501 } else {
8502 goto is_smaller_false;
8503 }
8504 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8505 d1 = Z_DVAL_P(op1);
8506 d2 = (double)Z_LVAL_P(op2);
8507 goto is_smaller_double;
8508 }
8509 }
8510 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8511}
8512
8513static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8514{
8515 USE_OPLINE
8516 zval *op1, *op2;
8517 double d1, d2;
8518
8519 op1 = RT_CONSTANT(opline, opline->op1);
8520 op2 = EX_VAR(opline->op2.var);
8521 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8522 /* pass */
8523 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8524 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8525 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8526is_smaller_true:
8527 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8528 } else {
8529is_smaller_false:
8530 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8531 }
8532 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8533 d1 = (double)Z_LVAL_P(op1);
8534 d2 = Z_DVAL_P(op2);
8535 goto is_smaller_double;
8536 }
8537 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8538 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8539 d1 = Z_DVAL_P(op1);
8540 d2 = Z_DVAL_P(op2);
8541is_smaller_double:
8542 if (d1 < d2) {
8543 goto is_smaller_true;
8544 } else {
8545 goto is_smaller_false;
8546 }
8547 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8548 d1 = Z_DVAL_P(op1);
8549 d2 = (double)Z_LVAL_P(op2);
8550 goto is_smaller_double;
8551 }
8552 }
8553 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8554}
8555
8556static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8557{
8558 USE_OPLINE
8559 zval *op1, *op2;
8560 double d1, d2;
8561
8562 op1 = RT_CONSTANT(opline, opline->op1);
8563 op2 = EX_VAR(opline->op2.var);
8564 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8565 /* pass */
8566 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8567 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8568 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8569is_smaller_or_equal_true:
8570 ZEND_VM_SMART_BRANCH_TRUE_NONE();
8571 ZVAL_TRUE(EX_VAR(opline->result.var));
8572 ZEND_VM_NEXT_OPCODE();
8573 } else {
8574is_smaller_or_equal_false:
8575 ZEND_VM_SMART_BRANCH_FALSE_NONE();
8576 ZVAL_FALSE(EX_VAR(opline->result.var));
8577 ZEND_VM_NEXT_OPCODE();
8578 }
8579 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8580 d1 = (double)Z_LVAL_P(op1);
8581 d2 = Z_DVAL_P(op2);
8582 goto is_smaller_or_equal_double;
8583 }
8584 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8585 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8586 d1 = Z_DVAL_P(op1);
8587 d2 = Z_DVAL_P(op2);
8588is_smaller_or_equal_double:
8589 if (d1 <= d2) {
8590 goto is_smaller_or_equal_true;
8591 } else {
8592 goto is_smaller_or_equal_false;
8593 }
8594 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8595 d1 = Z_DVAL_P(op1);
8596 d2 = (double)Z_LVAL_P(op2);
8597 goto is_smaller_or_equal_double;
8598 }
8599 }
8600 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8601}
8602
8603static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8604{
8605 USE_OPLINE
8606 zval *op1, *op2;
8607 double d1, d2;
8608
8609 op1 = RT_CONSTANT(opline, opline->op1);
8610 op2 = EX_VAR(opline->op2.var);
8611 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8612 /* pass */
8613 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8614 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8615 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8616is_smaller_or_equal_true:
8617 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8618 ZVAL_TRUE(EX_VAR(opline->result.var));
8619 ZEND_VM_NEXT_OPCODE();
8620 } else {
8621is_smaller_or_equal_false:
8622 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8623 ZVAL_FALSE(EX_VAR(opline->result.var));
8624 ZEND_VM_NEXT_OPCODE();
8625 }
8626 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8627 d1 = (double)Z_LVAL_P(op1);
8628 d2 = Z_DVAL_P(op2);
8629 goto is_smaller_or_equal_double;
8630 }
8631 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8632 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8633 d1 = Z_DVAL_P(op1);
8634 d2 = Z_DVAL_P(op2);
8635is_smaller_or_equal_double:
8636 if (d1 <= d2) {
8637 goto is_smaller_or_equal_true;
8638 } else {
8639 goto is_smaller_or_equal_false;
8640 }
8641 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8642 d1 = Z_DVAL_P(op1);
8643 d2 = (double)Z_LVAL_P(op2);
8644 goto is_smaller_or_equal_double;
8645 }
8646 }
8647 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8648}
8649
8650static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8651{
8652 USE_OPLINE
8653 zval *op1, *op2;
8654 double d1, d2;
8655
8656 op1 = RT_CONSTANT(opline, opline->op1);
8657 op2 = EX_VAR(opline->op2.var);
8658 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8659 /* pass */
8660 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8661 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8662 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8663is_smaller_or_equal_true:
8664 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8665 ZVAL_TRUE(EX_VAR(opline->result.var));
8666 ZEND_VM_NEXT_OPCODE();
8667 } else {
8668is_smaller_or_equal_false:
8669 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8670 ZVAL_FALSE(EX_VAR(opline->result.var));
8671 ZEND_VM_NEXT_OPCODE();
8672 }
8673 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8674 d1 = (double)Z_LVAL_P(op1);
8675 d2 = Z_DVAL_P(op2);
8676 goto is_smaller_or_equal_double;
8677 }
8678 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8679 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8680 d1 = Z_DVAL_P(op1);
8681 d2 = Z_DVAL_P(op2);
8682is_smaller_or_equal_double:
8683 if (d1 <= d2) {
8684 goto is_smaller_or_equal_true;
8685 } else {
8686 goto is_smaller_or_equal_false;
8687 }
8688 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8689 d1 = Z_DVAL_P(op1);
8690 d2 = (double)Z_LVAL_P(op2);
8691 goto is_smaller_or_equal_double;
8692 }
8693 }
8694 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8695}
8696
8697static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8698{
8699 zend_class_entry *ce, *scope;
8700 zend_class_constant *c;
8701 zval *value, *zv, *constant_zv;
8702 zend_string *constant_name;
8703 USE_OPLINE
8704
8705 SAVE_OPLINE();
8706
8707 do {
8708 if (IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8709 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
8710 value = CACHED_PTR(opline->extended_value + sizeof(void*));
8711 break;
8712 }
8713 }
8714 if (IS_CONST == IS_CONST) {
8715 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
8716 ce = CACHED_PTR(opline->extended_value);
8717 } else {
8718 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);
8719 if (UNEXPECTED(ce == NULL)) {
8720 ZVAL_UNDEF(EX_VAR(opline->result.var));
8721 FREE_OP(opline->op2_type, opline->op2.var);
8722 HANDLE_EXCEPTION();
8723 }
8724 CACHE_PTR(opline->extended_value, ce);
8725 }
8726 } else if (IS_CONST == IS_UNUSED) {
8727 ce = zend_fetch_class(NULL, opline->op1.num);
8728 if (UNEXPECTED(ce == NULL)) {
8729 ZVAL_UNDEF(EX_VAR(opline->result.var));
8730 FREE_OP(opline->op2_type, opline->op2.var);
8731 HANDLE_EXCEPTION();
8732 }
8733 } else {
8734 ce = Z_CE_P(EX_VAR(opline->op1.var));
8735 }
8736 if (IS_CONST != IS_CONST
8737 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8738 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
8739 value = CACHED_PTR(opline->extended_value + sizeof(void*));
8740 break;
8741 }
8742
8743 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
8744 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
8745 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
8746 ZVAL_UNDEF(EX_VAR(opline->result.var));
8747 FREE_OP(opline->op2_type, opline->op2.var);
8748 HANDLE_EXCEPTION();
8749 }
8750 constant_name = Z_STR_P(constant_zv);
8751 /* Magic 'class' for constant OP2 is caught at compile-time */
8752 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
8753 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
8754 FREE_OP(opline->op2_type, opline->op2.var);
8755 ZEND_VM_NEXT_OPCODE();
8756 }
8757 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8758 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
8759 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
8760
8761 if (EXPECTED(zv != NULL)) {
8762 c = Z_PTR_P(zv);
8763 scope = EX(func)->op_array.scope;
8764 if (!zend_verify_const_access(c, scope)) {
8765 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));
8766 ZVAL_UNDEF(EX_VAR(opline->result.var));
8767 FREE_OP(opline->op2_type, opline->op2.var);
8768 HANDLE_EXCEPTION();
8769 }
8770
8771 if (ce->ce_flags & ZEND_ACC_TRAIT) {
8772 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8773 ZVAL_UNDEF(EX_VAR(opline->result.var));
8774 FREE_OP(opline->op2_type, opline->op2.var);
8775 HANDLE_EXCEPTION();
8776 }
8777
8778 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
8779 if (UNEXPECTED(is_constant_deprecated)) {
8780 zend_deprecated_class_constant(c, constant_name);
8781
8782 if (EG(exception)) {
8783 ZVAL_UNDEF(EX_VAR(opline->result.var));
8784 FREE_OP(opline->op2_type, opline->op2.var);
8785 HANDLE_EXCEPTION();
8786 }
8787 }
8788
8789 value = &c->value;
8790 // Enums require loading of all class constants to build the backed enum table
8791 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)) {
8792 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
8793 ZVAL_UNDEF(EX_VAR(opline->result.var));
8794 FREE_OP(opline->op2_type, opline->op2.var);
8795 HANDLE_EXCEPTION();
8796 }
8797 }
8798 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
8799 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
8800 ZVAL_UNDEF(EX_VAR(opline->result.var));
8801 FREE_OP(opline->op2_type, opline->op2.var);
8802 HANDLE_EXCEPTION();
8803 }
8804 }
8805 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
8806 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
8807 }
8808 } else {
8809 zend_throw_error(NULL, "Undefined constant %s::%s",
8810 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8811 ZVAL_UNDEF(EX_VAR(opline->result.var));
8812 FREE_OP(opline->op2_type, opline->op2.var);
8813 HANDLE_EXCEPTION();
8814 }
8815 } while (0);
8816
8817 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
8818
8819 FREE_OP(opline->op2_type, opline->op2.var);
8820 ZEND_VM_NEXT_OPCODE();
8821}
8822
8823static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8824{
8825 USE_OPLINE
8826 zval *op1, *op2, *result;
8827
8828 op1 = RT_CONSTANT(opline, opline->op1);
8829 op2 = EX_VAR(opline->op2.var);
8830 result = EX_VAR(opline->result.var);
8831 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
8832 ZEND_VM_NEXT_OPCODE();
8833}
8834
8835static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8836{
8837 USE_OPLINE
8838 zval *op1, *op2, *result;
8839
8840 op1 = RT_CONSTANT(opline, opline->op1);
8841 op2 = EX_VAR(opline->op2.var);
8842 result = EX_VAR(opline->result.var);
8843 fast_long_sub_function(result, op1, op2);
8844 ZEND_VM_NEXT_OPCODE();
8845}
8846
8847static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8848{
8849 USE_OPLINE
8850 zval *op1, *op2, *result;
8851
8852 op1 = RT_CONSTANT(opline, opline->op1);
8853 op2 = EX_VAR(opline->op2.var);
8854 result = EX_VAR(opline->result.var);
8855 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
8856 ZEND_VM_NEXT_OPCODE();
8857}
8858
8859static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8860{
8861 USE_OPLINE
8862 zval *op1, *op2;
8863 bool result;
8864
8865 op1 = RT_CONSTANT(opline, opline->op1);
8866 op2 = EX_VAR(opline->op2.var);
8867 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8868 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8869}
8870
8871static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8872{
8873 USE_OPLINE
8874 zval *op1, *op2;
8875 bool result;
8876
8877 op1 = RT_CONSTANT(opline, opline->op1);
8878 op2 = EX_VAR(opline->op2.var);
8879 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8880 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8881}
8882
8883static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8884{
8885 USE_OPLINE
8886 zval *op1, *op2;
8887 bool result;
8888
8889 op1 = RT_CONSTANT(opline, opline->op1);
8890 op2 = EX_VAR(opline->op2.var);
8891 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8892 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8893}
8894
8895static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8896{
8897 USE_OPLINE
8898 zval *op1, *op2;
8899 bool result;
8900
8901 op1 = RT_CONSTANT(opline, opline->op1);
8902 op2 = EX_VAR(opline->op2.var);
8903 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8904 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8905}
8906
8907static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8908{
8909 USE_OPLINE
8910 zval *op1, *op2;
8911 bool result;
8912
8913 op1 = RT_CONSTANT(opline, opline->op1);
8914 op2 = EX_VAR(opline->op2.var);
8915 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8916 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8917}
8918
8919static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8920{
8921 USE_OPLINE
8922 zval *op1, *op2;
8923 bool result;
8924
8925 op1 = RT_CONSTANT(opline, opline->op1);
8926 op2 = EX_VAR(opline->op2.var);
8927 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8928 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8929}
8930
8931static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8932{
8933 USE_OPLINE
8934 zval *op1, *op2;
8935 bool result;
8936
8937 op1 = RT_CONSTANT(opline, opline->op1);
8938 op2 = EX_VAR(opline->op2.var);
8939 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8940 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8941}
8942
8943static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8944{
8945 USE_OPLINE
8946 zval *op1, *op2;
8947 bool result;
8948
8949 op1 = RT_CONSTANT(opline, opline->op1);
8950 op2 = EX_VAR(opline->op2.var);
8951 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8952 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8953}
8954
8955static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8956{
8957 USE_OPLINE
8958 zval *op1, *op2;
8959 bool result;
8960
8961 op1 = RT_CONSTANT(opline, opline->op1);
8962 op2 = EX_VAR(opline->op2.var);
8963 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8964 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8965}
8966
8967static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8968{
8969 USE_OPLINE
8970 zval *op1, *op2;
8971 bool result;
8972
8973 op1 = RT_CONSTANT(opline, opline->op1);
8974 op2 = EX_VAR(opline->op2.var);
8975 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
8976 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8977}
8978
8979static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8980{
8981 USE_OPLINE
8982 zval *op1, *op2;
8983 bool result;
8984
8985 op1 = RT_CONSTANT(opline, opline->op1);
8986 op2 = EX_VAR(opline->op2.var);
8987 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
8988 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8989}
8990
8991static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8992{
8993 USE_OPLINE
8994 zval *op1, *op2;
8995 bool result;
8996
8997 op1 = RT_CONSTANT(opline, opline->op1);
8998 op2 = EX_VAR(opline->op2.var);
8999 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
9000 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
9001}
9002
9003static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9004{
9005 USE_OPLINE
9006 zval *container, *dim, *value;
9007 zend_long offset;
9008 HashTable *ht;
9009
9010 container = RT_CONSTANT(opline, opline->op1);
9011 dim = EX_VAR(opline->op2.var);
9012 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9013fetch_dim_r_index_array:
9014 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
9015 offset = Z_LVAL_P(dim);
9016 } else {
9017 SAVE_OPLINE();
9018 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
9019
9020 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9021 }
9022 ht = Z_ARRVAL_P(container);
9023 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
9024 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
9025 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9026 SAVE_OPLINE();
9027
9028 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9029 } else {
9030 ZEND_VM_NEXT_OPCODE();
9031 }
9032 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
9033 container = Z_REFVAL_P(container);
9034 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9035 goto fetch_dim_r_index_array;
9036 } else {
9037 goto fetch_dim_r_index_slow;
9038 }
9039 } else {
9040fetch_dim_r_index_slow:
9041 SAVE_OPLINE();
9042 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
9043 dim++;
9044 }
9045 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
9046
9047 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9048 }
9049
9050fetch_dim_r_index_undef:
9051 ZVAL_NULL(EX_VAR(opline->result.var));
9052 SAVE_OPLINE();
9053 zend_undefined_offset(offset);
9054
9055 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9056}
9057
9058static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9059{
9060 USE_OPLINE
9061 zval *op1, *op2;
9062
9063 SAVE_OPLINE();
9064 op1 = RT_CONSTANT(opline, opline->op1);
9065 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9066 div_function(EX_VAR(opline->result.var), op1, op2);
9067
9068 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9069 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9070}
9071
9072static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9073{
9074 USE_OPLINE
9075 zval *op1, *op2;
9076
9077 SAVE_OPLINE();
9078 op1 = RT_CONSTANT(opline, opline->op1);
9079 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9080 pow_function(EX_VAR(opline->result.var), op1, op2);
9081
9082 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9083 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9084}
9085
9086static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9087{
9088 USE_OPLINE
9089 zval *op1, *op2;
9090
9091 op1 = RT_CONSTANT(opline, opline->op1);
9092 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9093
9094 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
9095 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
9096 zend_string *op1_str = Z_STR_P(op1);
9097 zend_string *op2_str = Z_STR_P(op2);
9098 zend_string *str;
9099 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
9100
9101 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9102 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
9103 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
9104 } else {
9105 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9106 }
9107 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9108 zend_string_release_ex(op1_str, 0);
9109 }
9110 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9111 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
9112 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
9113 } else {
9114 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9115 }
9116 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9117 zend_string_release_ex(op2_str, 0);
9118 }
9119 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
9120 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
9121 size_t len = ZSTR_LEN(op1_str);
9122
9123 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
9124 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
9125 }
9126 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
9127 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9128 GC_ADD_FLAGS(str, flags);
9129 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9130 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9131 zend_string_release_ex(op2_str, 0);
9132 }
9133 } else {
9134 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9135 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9136 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9137 GC_ADD_FLAGS(str, flags);
9138 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9139 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9140 zend_string_release_ex(op1_str, 0);
9141 }
9142 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9143 zend_string_release_ex(op2_str, 0);
9144 }
9145 }
9146 ZEND_VM_NEXT_OPCODE();
9147 } else {
9148 SAVE_OPLINE();
9149
9150 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
9151 op1 = ZVAL_UNDEFINED_OP1();
9152 }
9153 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
9154 op2 = ZVAL_UNDEFINED_OP2();
9155 }
9156 concat_function(EX_VAR(opline->result.var), op1, op2);
9157
9158 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9159 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9160 }
9161}
9162
9163static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9164{
9165 USE_OPLINE
9166 zval *op1, *op2;
9167
9168 SAVE_OPLINE();
9169 op1 = RT_CONSTANT(opline, opline->op1);
9170 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9171 compare_function(EX_VAR(opline->result.var), op1, op2);
9172
9173 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9174 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9175}
9176
9177static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9178{
9179 USE_OPLINE
9180 zval *container, *dim, *value;
9181
9182 SAVE_OPLINE();
9183 container = RT_CONSTANT(opline, opline->op1);
9184 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9185 if (IS_CONST != IS_CONST) {
9186 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9187fetch_dim_r_array:
9188 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
9189 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
9190 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
9191 container = Z_REFVAL_P(container);
9192 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9193 goto fetch_dim_r_array;
9194 } else {
9195 goto fetch_dim_r_slow;
9196 }
9197 } else {
9198fetch_dim_r_slow:
9199 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
9200 dim++;
9201 }
9202 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
9203 }
9204 } else {
9205 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
9206 }
9207 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9208
9209 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9210}
9211
9212static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9213{
9214 USE_OPLINE
9215 zval *container;
9216
9217 SAVE_OPLINE();
9218 container = RT_CONSTANT(opline, opline->op1);
9219 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);
9220 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9221
9222 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9223}
9224
9225static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9226{
9227#if 0
9228 USE_OPLINE
9229#endif
9230
9231 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
9232 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
9233 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9234 }
9235 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9236 } else {
9237 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
9238 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9239 }
9240 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9241 }
9242}
9243
9244static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9245{
9246 USE_OPLINE
9247 zval *container;
9248 void **cache_slot = NULL;
9249
9250 SAVE_OPLINE();
9251 container = RT_CONSTANT(opline, opline->op1);
9252
9253 if (IS_CONST == IS_CONST ||
9254 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9255 do {
9256 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9257 container = Z_REFVAL_P(container);
9258 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9259 break;
9260 }
9261 }
9262 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
9263 ZVAL_UNDEFINED_OP1();
9264 }
9265 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9266 ZVAL_NULL(EX_VAR(opline->result.var));
9267 goto fetch_obj_r_finish;
9268 } while (0);
9269 }
9270
9271 /* here we are sure we are dealing with an object */
9272 do {
9273 zend_object *zobj = Z_OBJ_P(container);
9274 zend_string *name, *tmp_name;
9275 zval *retval;
9276
9277 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9278 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
9279
9280 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9281 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9282
9283 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9284fetch_obj_r_simple:
9285 retval = OBJ_PROP(zobj, prop_offset);
9286 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
9287 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9288 goto fetch_obj_r_copy;
9289 } else {
9290fetch_obj_r_fast_copy:
9291 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9292 ZEND_VM_NEXT_OPCODE();
9293 }
9294 }
9295 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
9296 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
9297 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
9298 prop_offset = prop_info->offset;
9299 goto fetch_obj_r_simple;
9300 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
9301 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
9302 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
9303 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
9304
9305 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9306 if (IS_CONST & IS_CV) {
9307 GC_ADDREF(zobj);
9308 }
9309 if (IS_CONST & (IS_CV|IS_VAR|IS_TMP_VAR)) {
9310 call_info |= ZEND_CALL_RELEASE_THIS;
9311 }
9312 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
9313 call->prev_execute_data = execute_data;
9314 call->call = NULL;
9315 call->return_value = EX_VAR(opline->result.var);
9316 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
9317
9318 execute_data = call;
9319 EG(current_execute_data) = execute_data;
9320 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
9321
9322#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
9323 opline = hook->op_array.opcodes;
9324#else
9325 EX(opline) = hook->op_array.opcodes;
9326#endif
9327 LOAD_OPLINE_EX();
9328
9329
9330 ZEND_VM_ENTER_EX();
9331 }
9332 /* Fall through to read_property for hooks. */
9333 } else if (EXPECTED(zobj->properties != NULL)) {
9334 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
9335 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9336 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9337 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9338
9339 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9340 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9341
9342 if (EXPECTED(p->key == name) ||
9343 (EXPECTED(p->h == ZSTR_H(name)) &&
9344 EXPECTED(p->key != NULL) &&
9345 EXPECTED(zend_string_equal_content(p->key, name)))) {
9346 retval = &p->val;
9347 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9348 goto fetch_obj_r_copy;
9349 } else {
9350 goto fetch_obj_r_fast_copy;
9351 }
9352 }
9353 }
9354 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9355 }
9356 retval = zend_hash_find_known_hash(zobj->properties, name);
9357 if (EXPECTED(retval)) {
9358 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9359 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9360 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9361 goto fetch_obj_r_copy;
9362 } else {
9363 goto fetch_obj_r_fast_copy;
9364 }
9365 }
9366 }
9367 }
9368 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9369 } else {
9370 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9371 if (UNEXPECTED(!name)) {
9372 ZVAL_UNDEF(EX_VAR(opline->result.var));
9373 break;
9374 }
9375 }
9376
9377#if ZEND_DEBUG
9378 /* For non-standard object handlers, verify a declared property type in debug builds.
9379 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
9380 zend_property_info *prop_info = NULL;
9381 if (zobj->handlers->read_property != zend_std_read_property) {
9382 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
9383 }
9384#endif
9385 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
9386#if ZEND_DEBUG
9387 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
9388 && ZEND_TYPE_IS_SET(prop_info->type)) {
9389 ZVAL_OPT_DEREF(retval);
9390 zend_verify_property_type(prop_info, retval, /* strict */ true);
9391 }
9392#endif
9393
9394 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9395 zend_tmp_string_release(tmp_name);
9396 }
9397
9398 if (retval != EX_VAR(opline->result.var)) {
9399fetch_obj_r_copy:
9400 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9401 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9402 zend_unwrap_reference(retval);
9403 }
9404 } while (0);
9405
9406fetch_obj_r_finish:
9407 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9408
9409 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9410}
9411
9412static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9413{
9414 USE_OPLINE
9415 zval *container;
9416 void **cache_slot = NULL;
9417
9418 SAVE_OPLINE();
9419 container = RT_CONSTANT(opline, opline->op1);
9420
9421 if (IS_CONST == IS_CONST ||
9422 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9423 do {
9424 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9425 container = Z_REFVAL_P(container);
9426 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9427 break;
9428 }
9429 }
9430 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
9431 ZVAL_UNDEFINED_OP2();
9432 }
9433 ZVAL_NULL(EX_VAR(opline->result.var));
9434 goto fetch_obj_is_finish;
9435 } while (0);
9436 }
9437
9438 /* here we are sure we are dealing with an object */
9439 do {
9440 zend_object *zobj = Z_OBJ_P(container);
9441 zend_string *name, *tmp_name;
9442 zval *retval;
9443
9444 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9445 cache_slot = CACHE_ADDR(opline->extended_value);
9446
9447 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9448 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9449
9450 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9451fetch_obj_is_simple:
9452 retval = OBJ_PROP(zobj, prop_offset);
9453 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
9454 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9455 goto fetch_obj_is_copy;
9456 } else {
9457fetch_obj_is_fast_copy:
9458 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9459 ZEND_VM_NEXT_OPCODE();
9460 }
9461 }
9462 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
9463 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
9464 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
9465 prop_offset = prop_info->offset;
9466 goto fetch_obj_is_simple;
9467 }
9468 /* Fall through to read_property for hooks. */
9469 } else if (EXPECTED(zobj->properties != NULL)) {
9470 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
9471 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9472 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9473 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9474
9475 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9476 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9477
9478 if (EXPECTED(p->key == name) ||
9479 (EXPECTED(p->h == ZSTR_H(name)) &&
9480 EXPECTED(p->key != NULL) &&
9481 EXPECTED(zend_string_equal_content(p->key, name)))) {
9482 retval = &p->val;
9483 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9484 goto fetch_obj_is_copy;
9485 } else {
9486 goto fetch_obj_is_fast_copy;
9487 }
9488 }
9489 }
9490 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9491 }
9492 retval = zend_hash_find_known_hash(zobj->properties, name);
9493 if (EXPECTED(retval)) {
9494 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9495 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9496 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9497 goto fetch_obj_is_copy;
9498 } else {
9499 goto fetch_obj_is_fast_copy;
9500 }
9501 }
9502 }
9503 }
9504 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9505 } else {
9506 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9507 if (UNEXPECTED(!name)) {
9508 ZVAL_UNDEF(EX_VAR(opline->result.var));
9509 break;
9510 }
9511 }
9512
9513 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
9514
9515 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9516 zend_tmp_string_release(tmp_name);
9517 }
9518
9519 if (retval != EX_VAR(opline->result.var)) {
9520fetch_obj_is_copy:
9521 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9522 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9523 zend_unwrap_reference(retval);
9524 }
9525 } while (0);
9526
9527fetch_obj_is_finish:
9528 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9529
9530 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9531}
9532
9533static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9534{
9535#if 0
9536 USE_OPLINE
9537#endif
9538
9539 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
9540 /* Behave like FETCH_OBJ_W */
9541 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
9542 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9543 }
9544 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9545 } else {
9546 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9547 }
9548}
9549
9550static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9551{
9552 USE_OPLINE
9553 zval *container;
9554
9555 SAVE_OPLINE();
9556 container = RT_CONSTANT(opline, opline->op1);
9557 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);
9558 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9559 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9560}
9561
9562static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9563{
9564 USE_OPLINE
9565 zval *op1, *op2;
9566 zend_string *op1_str, *op2_str, *str;
9567
9568
9569 op1 = RT_CONSTANT(opline, opline->op1);
9570 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9571 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
9572 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
9573 zend_string *op1_str = Z_STR_P(op1);
9574 zend_string *op2_str = Z_STR_P(op2);
9575 zend_string *str;
9576 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
9577
9578 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9579 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
9580 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
9581 } else {
9582 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9583 }
9584 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9585 zend_string_release_ex(op1_str, 0);
9586 }
9587 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9588 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
9589 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
9590 } else {
9591 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9592 }
9593 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9594 zend_string_release_ex(op2_str, 0);
9595 }
9596 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
9597 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
9598 size_t len = ZSTR_LEN(op1_str);
9599
9600 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
9601 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9602 GC_ADD_FLAGS(str, flags);
9603 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9604 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9605 zend_string_release_ex(op2_str, 0);
9606 }
9607 } else {
9608 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9609 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9610 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9611 GC_ADD_FLAGS(str, flags);
9612 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9613 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9614 zend_string_release_ex(op1_str, 0);
9615 }
9616 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9617 zend_string_release_ex(op2_str, 0);
9618 }
9619 }
9620 ZEND_VM_NEXT_OPCODE();
9621 }
9622
9623 SAVE_OPLINE();
9624 if (IS_CONST == IS_CONST) {
9625 op1_str = Z_STR_P(op1);
9626 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
9627 op1_str = zend_string_copy(Z_STR_P(op1));
9628 } else {
9629 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
9630 ZVAL_UNDEFINED_OP1();
9631 }
9632 op1_str = zval_get_string_func(op1);
9633 }
9634 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9635 op2_str = Z_STR_P(op2);
9636 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
9637 op2_str = zend_string_copy(Z_STR_P(op2));
9638 } else {
9639 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
9640 ZVAL_UNDEFINED_OP2();
9641 }
9642 op2_str = zval_get_string_func(op2);
9643 }
9644 do {
9645 if (IS_CONST != IS_CONST) {
9646 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9647 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9648 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
9649 GC_ADDREF(op2_str);
9650 }
9651 }
9652 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9653 zend_string_release_ex(op1_str, 0);
9654 break;
9655 }
9656 }
9657 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9658 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9659 if (IS_CONST == IS_CONST) {
9660 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
9661 GC_ADDREF(op1_str);
9662 }
9663 }
9664 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9665 zend_string_release_ex(op2_str, 0);
9666 break;
9667 }
9668 }
9669 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9670 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9671 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9672
9673 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
9674 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9675 if (IS_CONST != IS_CONST) {
9676 zend_string_release_ex(op1_str, 0);
9677 }
9678 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9679 zend_string_release_ex(op2_str, 0);
9680 }
9681 } while (0);
9682
9683 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9684 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9685}
9686
9687static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9688{
9689 USE_OPLINE
9690 zval *function_name;
9691 zval *object;
9692 zend_function *fbc;
9693 zend_class_entry *called_scope;
9694 zend_object *obj;
9695 zend_execute_data *call;
9696 uint32_t call_info;
9697
9698 SAVE_OPLINE();
9699
9700 object = RT_CONSTANT(opline, opline->op1);
9701
9702 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9703 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9704 }
9705
9706 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
9707 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9708 do {
9709 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
9710 function_name = Z_REFVAL_P(function_name);
9711 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
9712 break;
9713 }
9714 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
9715 ZVAL_UNDEFINED_OP2();
9716 if (UNEXPECTED(EG(exception) != NULL)) {
9717
9718 HANDLE_EXCEPTION();
9719 }
9720 }
9721 zend_throw_error(NULL, "Method name must be a string");
9722 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9723
9724 HANDLE_EXCEPTION();
9725 } while (0);
9726 }
9727
9728 if (IS_CONST == IS_UNUSED) {
9729 obj = Z_OBJ_P(object);
9730 } else {
9731 do {
9732 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9733 obj = Z_OBJ_P(object);
9734 } else {
9735 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
9736 zend_reference *ref = Z_REF_P(object);
9737
9738 object = &ref->val;
9739 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9740 obj = Z_OBJ_P(object);
9741 if (IS_CONST & IS_VAR) {
9742 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
9743 efree_size(ref, sizeof(zend_reference));
9744 } else {
9745 Z_ADDREF_P(object);
9746 }
9747 }
9748 break;
9749 }
9750 }
9751 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
9752 object = ZVAL_UNDEFINED_OP1();
9753 if (UNEXPECTED(EG(exception) != NULL)) {
9754 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9755 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9756 }
9757 HANDLE_EXCEPTION();
9758 }
9759 }
9760 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9761 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9762 }
9763 zend_invalid_method_call(object, function_name);
9764 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9765
9766 HANDLE_EXCEPTION();
9767 }
9768 } while (0);
9769 }
9770
9771 called_scope = obj->ce;
9772
9773 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9774 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
9775 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9776 } else {
9777 zend_object *orig_obj = obj;
9778
9779 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9780 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9781 }
9782
9783 /* First, locate the function. */
9784 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));
9785 if (UNEXPECTED(fbc == NULL)) {
9786 if (EXPECTED(!EG(exception))) {
9787 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
9788 }
9789 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9790 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
9791 zend_objects_store_del(orig_obj);
9792 }
9793 HANDLE_EXCEPTION();
9794 }
9795 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9796 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
9797 EXPECTED(obj == orig_obj)) {
9798 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
9799 }
9800 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
9801 GC_ADDREF(obj); /* For $this pointer */
9802 if (GC_DELREF(orig_obj) == 0) {
9803 zend_objects_store_del(orig_obj);
9804 }
9805 }
9806 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9807 init_func_run_time_cache(&fbc->op_array);
9808 }
9809 }
9810
9811 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9812 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9813 }
9814
9815 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9816 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
9817 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
9818 zend_objects_store_del(obj);
9819 if (UNEXPECTED(EG(exception))) {
9820 HANDLE_EXCEPTION();
9821 }
9822 }
9823 /* call static method */
9824 obj = (zend_object*)called_scope;
9825 call_info = ZEND_CALL_NESTED_FUNCTION;
9826 } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
9827 if (IS_CONST == IS_CV) {
9828 GC_ADDREF(obj); /* For $this pointer */
9829 }
9830 /* CV may be changed indirectly (e.g. when it's a reference) */
9831 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
9832 }
9833
9834 call = zend_vm_stack_push_call_frame(call_info,
9835 fbc, opline->extended_value, obj);
9836 call->prev_execute_data = EX(call);
9837 EX(call) = call;
9838
9839 ZEND_VM_NEXT_OPCODE();
9840}
9841
9842static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9843{
9844 USE_OPLINE
9845 zval *function_name;
9846 zend_class_entry *ce;
9847 uint32_t call_info;
9848 zend_function *fbc;
9849 zend_execute_data *call;
9850
9851 SAVE_OPLINE();
9852
9853 if (IS_CONST == IS_CONST) {
9854 /* no function found. try a static method in class */
9855 ce = CACHED_PTR(opline->result.num);
9856 if (UNEXPECTED(ce == NULL)) {
9857 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);
9858 if (UNEXPECTED(ce == NULL)) {
9859 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9860 HANDLE_EXCEPTION();
9861 }
9862 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9863 CACHE_PTR(opline->result.num, ce);
9864 }
9865 }
9866 } else if (IS_CONST == IS_UNUSED) {
9867 ce = zend_fetch_class(NULL, opline->op1.num);
9868 if (UNEXPECTED(ce == NULL)) {
9869 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9870 HANDLE_EXCEPTION();
9871 }
9872 } else {
9873 ce = Z_CE_P(EX_VAR(opline->op1.var));
9874 }
9875
9876 if (IS_CONST == IS_CONST &&
9877 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9878 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
9879 /* nothing to do */
9880 } else if (IS_CONST != IS_CONST &&
9881 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9882 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
9883 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9884 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
9885 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9886 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9887 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9888 do {
9889 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
9890 function_name = Z_REFVAL_P(function_name);
9891 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
9892 break;
9893 }
9894 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
9895 ZVAL_UNDEFINED_OP2();
9896 if (UNEXPECTED(EG(exception) != NULL)) {
9897 HANDLE_EXCEPTION();
9898 }
9899 }
9900 zend_throw_error(NULL, "Method name must be a string");
9901 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9902 HANDLE_EXCEPTION();
9903 } while (0);
9904 }
9905 }
9906
9907 if (ce->get_static_method) {
9908 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
9909 } else {
9910 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));
9911 }
9912 if (UNEXPECTED(fbc == NULL)) {
9913 if (EXPECTED(!EG(exception))) {
9914 zend_undefined_method(ce, Z_STR_P(function_name));
9915 }
9916 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9917 HANDLE_EXCEPTION();
9918 }
9919 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9920 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
9921 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
9922 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
9923 }
9924 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9925 init_func_run_time_cache(&fbc->op_array);
9926 }
9927 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9928 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9929 }
9930 } else {
9931 if (UNEXPECTED(ce->constructor == NULL)) {
9932 zend_throw_error(NULL, "Cannot call constructor");
9933 HANDLE_EXCEPTION();
9934 }
9935 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
9936 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
9937 HANDLE_EXCEPTION();
9938 }
9939 fbc = ce->constructor;
9940 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9941 init_func_run_time_cache(&fbc->op_array);
9942 }
9943 }
9944
9945 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
9946 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
9947 ce = (zend_class_entry*)Z_OBJ(EX(This));
9948 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9949 } else {
9950 zend_non_static_method_call(fbc);
9951 HANDLE_EXCEPTION();
9952 }
9953 } else {
9954 /* previous opcode is ZEND_FETCH_CLASS */
9955 if (IS_CONST == IS_UNUSED
9956 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
9957 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
9958 if (Z_TYPE(EX(This)) == IS_OBJECT) {
9959 ce = Z_OBJCE(EX(This));
9960 } else {
9961 ce = Z_CE(EX(This));
9962 }
9963 }
9964 call_info = ZEND_CALL_NESTED_FUNCTION;
9965 }
9966
9967 call = zend_vm_stack_push_call_frame(call_info,
9968 fbc, opline->extended_value, ce);
9969 call->prev_execute_data = EX(call);
9970 EX(call) = call;
9971
9972 ZEND_VM_NEXT_OPCODE();
9973}
9974
9975static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9976{
9977 USE_OPLINE
9978 zval *function_name;
9979 zend_fcall_info_cache fcc;
9980 char *error = NULL;
9981 zend_function *func;
9982 void *object_or_called_scope;
9983 zend_execute_data *call;
9984 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
9985
9986 SAVE_OPLINE();
9987 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9988 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
9989 ZEND_ASSERT(!error);
9990
9991 /* Deprecation can be emitted from zend_is_callable_ex(), which can
9992 * invoke a user error handler and throw an exception.
9993 * For the CONST and CV case we reuse the same exception block below
9994 * to make sure we don't increase VM size too much. */
9995 if (!((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
9996 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9997 HANDLE_EXCEPTION();
9998 }
9999
10000 func = fcc.function_handler;
10001 object_or_called_scope = fcc.called_scope;
10002 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
10003 /* Delay closure destruction until its invocation */
10004 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
10005 call_info |= ZEND_CALL_CLOSURE;
10006 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
10007 call_info |= ZEND_CALL_FAKE_CLOSURE;
10008 }
10009 if (fcc.object) {
10010 object_or_called_scope = fcc.object;
10011 call_info |= ZEND_CALL_HAS_THIS;
10012 }
10013 } else if (fcc.object) {
10014 GC_ADDREF(fcc.object); /* For $this pointer */
10015 object_or_called_scope = fcc.object;
10016 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
10017 }
10018
10019 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10020 if (((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
10021 if (call_info & ZEND_CALL_CLOSURE) {
10022 zend_object_release(ZEND_CLOSURE_OBJECT(func));
10023 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
10024 zend_object_release(fcc.object);
10025 }
10026 HANDLE_EXCEPTION();
10027 }
10028
10029 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
10030 init_func_run_time_cache(&func->op_array);
10031 }
10032 } else {
10033 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
10034 efree(error);
10035 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10036 HANDLE_EXCEPTION();
10037 }
10038
10039 call = zend_vm_stack_push_call_frame(call_info,
10040 func, opline->extended_value, object_or_called_scope);
10041 call->prev_execute_data = EX(call);
10042 EX(call) = call;
10043
10044 ZEND_VM_NEXT_OPCODE();
10045}
10046
10047static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10048{
10049 USE_OPLINE
10050 zval *expr_ptr, new_expr;
10051
10052 SAVE_OPLINE();
10053 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
10054 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
10055 expr_ptr = zend_get_bad_ptr();
10056 if (Z_ISREF_P(expr_ptr)) {
10057 Z_ADDREF_P(expr_ptr);
10058 } else {
10059 ZVAL_MAKE_REF_EX(expr_ptr, 2);
10060 }
10061
10062 } else {
10063 expr_ptr = RT_CONSTANT(opline, opline->op1);
10064 if (IS_CONST == IS_TMP_VAR) {
10065 /* pass */
10066 } else if (IS_CONST == IS_CONST) {
10067 Z_TRY_ADDREF_P(expr_ptr);
10068 } else if (IS_CONST == IS_CV) {
10069 ZVAL_DEREF(expr_ptr);
10070 Z_TRY_ADDREF_P(expr_ptr);
10071 } else /* if (IS_CONST == IS_VAR) */ {
10072 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
10073 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
10074
10075 expr_ptr = Z_REFVAL_P(expr_ptr);
10076 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
10077 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
10078 expr_ptr = &new_expr;
10079 efree_size(ref, sizeof(zend_reference));
10080 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
10081 Z_ADDREF_P(expr_ptr);
10082 }
10083 }
10084 }
10085 }
10086
10087 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
10088 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10089 zend_string *str;
10090 zend_ulong hval;
10091
10092add_again:
10093 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
10094 str = Z_STR_P(offset);
10095 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10096 if (ZEND_HANDLE_NUMERIC(str, hval)) {
10097 goto num_index;
10098 }
10099 }
10100str_index:
10101 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
10102 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
10103 hval = Z_LVAL_P(offset);
10104num_index:
10105 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
10106 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
10107 offset = Z_REFVAL_P(offset);
10108 goto add_again;
10109 } else if (Z_TYPE_P(offset) == IS_NULL) {
10110 str = ZSTR_EMPTY_ALLOC();
10111 goto str_index;
10112 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
10113 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
10114 goto num_index;
10115 } else if (Z_TYPE_P(offset) == IS_FALSE) {
10116 hval = 0;
10117 goto num_index;
10118 } else if (Z_TYPE_P(offset) == IS_TRUE) {
10119 hval = 1;
10120 goto num_index;
10121 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
10122 zend_use_resource_as_offset(offset);
10123 hval = Z_RES_HANDLE_P(offset);
10124 goto num_index;
10125 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
10126 ZVAL_UNDEFINED_OP2();
10127 str = ZSTR_EMPTY_ALLOC();
10128 goto str_index;
10129 } else {
10130 zend_illegal_array_offset_access(offset);
10131 zval_ptr_dtor_nogc(expr_ptr);
10132 }
10133 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10134 } else {
10135 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
10136 zend_cannot_add_element();
10137 zval_ptr_dtor_nogc(expr_ptr);
10138 }
10139 }
10140 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10141}
10142
10143static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10144{
10145 zval *array;
10146 uint32_t size;
10147 USE_OPLINE
10148
10149 SAVE_OPLINE();
10150 array = EX_VAR(opline->result.var);
10151 if (IS_CONST != IS_UNUSED) {
10152 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
10153 ZVAL_ARR(array, zend_new_array(size));
10154 /* Explicitly initialize array as not-packed if flag is set */
10155 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
10156 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
10157 }
10158 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10159 } else {
10160 ZVAL_ARR(array, zend_new_array(0));
10161 ZEND_VM_NEXT_OPCODE();
10162 }
10163}
10164
10165static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10166{
10167 USE_OPLINE
10168 zval *container;
10169 bool result;
10170 zend_ulong hval;
10171 zval *offset;
10172
10173 SAVE_OPLINE();
10174 container = RT_CONSTANT(opline, opline->op1);
10175 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10176
10177 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
10178 HashTable *ht;
10179 zval *value;
10180 zend_string *str;
10181
10182isset_dim_obj_array:
10183 ht = Z_ARRVAL_P(container);
10184isset_again:
10185 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
10186 str = Z_STR_P(offset);
10187 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10188 if (ZEND_HANDLE_NUMERIC(str, hval)) {
10189 goto num_index_prop;
10190 }
10191 }
10192 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
10193 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
10194 hval = Z_LVAL_P(offset);
10195num_index_prop:
10196 value = zend_hash_index_find(ht, hval);
10197 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
10198 offset = Z_REFVAL_P(offset);
10199 goto isset_again;
10200 } else {
10201 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
10202 if (UNEXPECTED(EG(exception))) {
10203 result = 0;
10204 goto isset_dim_obj_exit;
10205 }
10206 }
10207
10208 if (!(opline->extended_value & ZEND_ISEMPTY)) {
10209 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
10210 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
10211 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
10212
10213 if (IS_CONST & (IS_CONST|IS_CV)) {
10214 /* avoid exception check */
10215 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10216 ZEND_VM_SMART_BRANCH(result, 0);
10217 }
10218 } else {
10219 result = (value == NULL || !i_zend_is_true(value));
10220 }
10221 goto isset_dim_obj_exit;
10222 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
10223 container = Z_REFVAL_P(container);
10224 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
10225 goto isset_dim_obj_array;
10226 }
10227 }
10228
10229 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
10230 offset++;
10231 }
10232 if (!(opline->extended_value & ZEND_ISEMPTY)) {
10233 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
10234 } else {
10235 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
10236 }
10237
10238isset_dim_obj_exit:
10239 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10240
10241 ZEND_VM_SMART_BRANCH(result, 1);
10242}
10243
10244static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10245{
10246 USE_OPLINE
10247 zval *container;
10248 int result;
10249 zval *offset;
10250 zend_string *name, *tmp_name;
10251
10252 SAVE_OPLINE();
10253 container = RT_CONSTANT(opline, opline->op1);
10254 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10255
10256 if (IS_CONST == IS_CONST ||
10257 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
10258 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
10259 container = Z_REFVAL_P(container);
10260 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
10261 result = (opline->extended_value & ZEND_ISEMPTY);
10262 goto isset_object_finish;
10263 }
10264 } else {
10265 result = (opline->extended_value & ZEND_ISEMPTY);
10266 goto isset_object_finish;
10267 }
10268 }
10269
10270 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
10271 name = Z_STR_P(offset);
10272 } else {
10273 name = zval_try_get_tmp_string(offset, &tmp_name);
10274 if (UNEXPECTED(!name)) {
10275 result = 0;
10276 goto isset_object_finish;
10277 }
10278 }
10279
10280 result =
10281 (opline->extended_value & ZEND_ISEMPTY) ^
10282 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));
10283
10284 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10285 zend_tmp_string_release(tmp_name);
10286 }
10287
10288isset_object_finish:
10289 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10290
10291 ZEND_VM_SMART_BRANCH(result, 1);
10292}
10293
10294static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10295{
10296 USE_OPLINE
10297
10298 zval *key, *subject;
10299 HashTable *ht;
10300 bool result;
10301
10302 SAVE_OPLINE();
10303
10304 key = RT_CONSTANT(opline, opline->op1);
10305 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10306
10307 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10308array_key_exists_array:
10309 ht = Z_ARRVAL_P(subject);
10310 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
10311 } else {
10312 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
10313 subject = Z_REFVAL_P(subject);
10314 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10315 goto array_key_exists_array;
10316 }
10317 }
10318 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
10319 result = 0;
10320 }
10321
10322 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10323
10324 ZEND_VM_SMART_BRANCH(result, 1);
10325}
10326
10327static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10328{
10329 USE_OPLINE
10330
10331 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
10332
10333 SAVE_OPLINE();
10334 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
10335 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10336 }
10337
10338 /* Destroy the previously yielded value */
10339 zval_ptr_dtor(&generator->value);
10340
10341 /* Destroy the previously yielded key */
10342 zval_ptr_dtor(&generator->key);
10343
10344 /* Set the new yielded value */
10345 if (IS_CONST != IS_UNUSED) {
10346 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10347 /* Constants and temporary variables aren't yieldable by reference,
10348 * but we still allow them with a notice. */
10349 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
10350 zval *value;
10351
10352 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10353
10354 value = RT_CONSTANT(opline, opline->op1);
10355 ZVAL_COPY_VALUE(&generator->value, value);
10356 if (IS_CONST == IS_CONST) {
10357 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10358 Z_ADDREF(generator->value);
10359 }
10360 }
10361 } else {
10362 zval *value_ptr = zend_get_bad_ptr();
10363
10364 /* If a function call result is yielded and the function did
10365 * not return by reference we throw a notice. */
10366 do {
10367 if (IS_CONST == IS_VAR) {
10368 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
10369 if (opline->extended_value == ZEND_RETURNS_FUNCTION
10370 && !Z_ISREF_P(value_ptr)) {
10371 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10372 ZVAL_COPY(&generator->value, value_ptr);
10373 break;
10374 }
10375 }
10376 if (Z_ISREF_P(value_ptr)) {
10377 Z_ADDREF_P(value_ptr);
10378 } else {
10379 ZVAL_MAKE_REF_EX(value_ptr, 2);
10380 }
10381 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
10382 } while (0);
10383
10384 }
10385 } else {
10386 zval *value = RT_CONSTANT(opline, opline->op1);
10387
10388 /* Consts, temporary variables and references need copying */
10389 if (IS_CONST == IS_CONST) {
10390 ZVAL_COPY_VALUE(&generator->value, value);
10391 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10392 Z_ADDREF(generator->value);
10393 }
10394 } else if (IS_CONST == IS_TMP_VAR) {
10395 ZVAL_COPY_VALUE(&generator->value, value);
10396 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
10397 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
10398
10399 } else {
10400 ZVAL_COPY_VALUE(&generator->value, value);
10401 if (IS_CONST == IS_CV) {
10402 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
10403 }
10404 }
10405 }
10406 } else {
10407 /* If no value was specified yield null */
10408 ZVAL_NULL(&generator->value);
10409 }
10410
10411 /* Set the new yielded key */
10412 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
10413 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10414 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
10415 key = Z_REFVAL_P(key);
10416 }
10417 ZVAL_COPY(&generator->key, key);
10418 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10419
10420 if (Z_TYPE(generator->key) == IS_LONG
10421 && Z_LVAL(generator->key) > generator->largest_used_integer_key
10422 ) {
10423 generator->largest_used_integer_key = Z_LVAL(generator->key);
10424 }
10425 } else {
10426 /* If no key was specified we use auto-increment keys */
10427 generator->largest_used_integer_key++;
10428 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
10429 }
10430
10431 if (RETURN_VALUE_USED(opline)) {
10432 /* If the return value of yield is used set the send
10433 * target and initialize it to NULL */
10434 generator->send_target = EX_VAR(opline->result.var);
10435 ZVAL_NULL(generator->send_target);
10436 } else {
10437 generator->send_target = NULL;
10438 }
10439
10440 /* The GOTO VM uses a local opline variable. We need to set the opline
10441 * variable in execute_data so we don't resume at an old position. */
10442 SAVE_OPLINE();
10443
10444 ZEND_VM_RETURN();
10445}
10446
10447static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
10448{
10449 USE_OPLINE
10450 zval *varname;
10451 zval *retval;
10452 zend_string *name, *tmp_name;
10453 HashTable *target_symbol_table;
10454
10455 SAVE_OPLINE();
10456 varname = RT_CONSTANT(opline, opline->op1);
10457
10458 if (IS_CONST == IS_CONST) {
10459 name = Z_STR_P(varname);
10460 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
10461 name = Z_STR_P(varname);
10462 tmp_name = NULL;
10463 } else {
10464 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
10465 ZVAL_UNDEFINED_OP1();
10466 }
10467 name = zval_try_get_tmp_string(varname, &tmp_name);
10468 if (UNEXPECTED(!name)) {
10469 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10470
10471 }
10472 ZVAL_UNDEF(EX_VAR(opline->result.var));
10473 HANDLE_EXCEPTION();
10474 }
10475 }
10476
10477 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
10478 retval = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
10479 if (retval == NULL) {
10480 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10481fetch_this:
10482 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
10483 if (IS_CONST != IS_CONST) {
10484 zend_tmp_string_release(tmp_name);
10485 }
10486 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10487 }
10488 if (type == BP_VAR_W) {
10489 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
10490 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10491 retval = &EG(uninitialized_zval);
10492 } else {
10493 if (IS_CONST == IS_CV) {
10494 /* Keep name alive in case an error handler tries to free it. */
10495 zend_string_addref(name);
10496 }
10497 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10498 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10499 if (type == BP_VAR_RW && !EG(exception)) {
10500 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
10501 } else {
10502 retval = &EG(uninitialized_zval);
10503 }
10504 if (IS_CONST == IS_CV) {
10505 zend_string_release(name);
10506 }
10507 }
10508 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
10509 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
10510 retval = Z_INDIRECT_P(retval);
10511 if (Z_TYPE_P(retval) == IS_UNDEF) {
10512 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10513 goto fetch_this;
10514 }
10515 if (type == BP_VAR_W) {
10516 ZVAL_NULL(retval);
10517 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10518 retval = &EG(uninitialized_zval);
10519 } else {
10520 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10521 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10522 if (type == BP_VAR_RW && !EG(exception)) {
10523 ZVAL_NULL(retval);
10524 } else {
10525 retval = &EG(uninitialized_zval);
10526 }
10527 }
10528 }
10529 }
10530
10531 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10532
10533 }
10534
10535 if (IS_CONST != IS_CONST) {
10536 zend_tmp_string_release(tmp_name);
10537 }
10538
10539 ZEND_ASSERT(retval != NULL);
10540 if (type == BP_VAR_R || type == BP_VAR_IS) {
10541 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
10542 } else {
10543 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
10544 }
10545 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10546}
10547
10548static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10549{
10550 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10551}
10552
10553static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10554{
10555 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10556}
10557
10558static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10559{
10560 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10561}
10562
10563static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10564{
10565 int fetch_type =
10566 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
10567 BP_VAR_W : BP_VAR_R;
10568 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10569}
10570
10571static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10572{
10573 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10574}
10575
10576static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10577{
10578 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10579}
10580
10581/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
10582static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10583{
10584#if 0
10585 USE_OPLINE
10586#endif
10587
10588 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
10589 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
10590 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10591 }
10592 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10593 } else {
10594 if (IS_UNUSED == IS_UNUSED) {
10595 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10596 }
10597 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10598 }
10599}
10600
10601static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10602{
10603 USE_OPLINE
10604 zval *function_name;
10605 zend_class_entry *ce;
10606 uint32_t call_info;
10607 zend_function *fbc;
10608 zend_execute_data *call;
10609
10610 SAVE_OPLINE();
10611
10612 if (IS_CONST == IS_CONST) {
10613 /* no function found. try a static method in class */
10614 ce = CACHED_PTR(opline->result.num);
10615 if (UNEXPECTED(ce == NULL)) {
10616 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);
10617 if (UNEXPECTED(ce == NULL)) {
10618
10619 HANDLE_EXCEPTION();
10620 }
10621 if (IS_UNUSED != IS_CONST) {
10622 CACHE_PTR(opline->result.num, ce);
10623 }
10624 }
10625 } else if (IS_CONST == IS_UNUSED) {
10626 ce = zend_fetch_class(NULL, opline->op1.num);
10627 if (UNEXPECTED(ce == NULL)) {
10628
10629 HANDLE_EXCEPTION();
10630 }
10631 } else {
10632 ce = Z_CE_P(EX_VAR(opline->op1.var));
10633 }
10634
10635 if (IS_CONST == IS_CONST &&
10636 IS_UNUSED == IS_CONST &&
10637 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
10638 /* nothing to do */
10639 } else if (IS_CONST != IS_CONST &&
10640 IS_UNUSED == IS_CONST &&
10641 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
10642 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
10643 } else if (IS_UNUSED != IS_UNUSED) {
10644 function_name = NULL;
10645 if (IS_UNUSED != IS_CONST) {
10646 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
10647 do {
10648 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
10649 function_name = Z_REFVAL_P(function_name);
10650 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
10651 break;
10652 }
10653 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
10654 ZVAL_UNDEFINED_OP2();
10655 if (UNEXPECTED(EG(exception) != NULL)) {
10656 HANDLE_EXCEPTION();
10657 }
10658 }
10659 zend_throw_error(NULL, "Method name must be a string");
10660
10661 HANDLE_EXCEPTION();
10662 } while (0);
10663 }
10664 }
10665
10666 if (ce->get_static_method) {
10667 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
10668 } else {
10669 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
10670 }
10671 if (UNEXPECTED(fbc == NULL)) {
10672 if (EXPECTED(!EG(exception))) {
10673 zend_undefined_method(ce, Z_STR_P(function_name));
10674 }
10675
10676 HANDLE_EXCEPTION();
10677 }
10678 if (IS_UNUSED == IS_CONST &&
10679 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
10680 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
10681 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
10682 }
10683 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10684 init_func_run_time_cache(&fbc->op_array);
10685 }
10686 if (IS_UNUSED != IS_CONST) {
10687
10688 }
10689 } else {
10690 if (UNEXPECTED(ce->constructor == NULL)) {
10691 zend_throw_error(NULL, "Cannot call constructor");
10692 HANDLE_EXCEPTION();
10693 }
10694 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
10695 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
10696 HANDLE_EXCEPTION();
10697 }
10698 fbc = ce->constructor;
10699 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10700 init_func_run_time_cache(&fbc->op_array);
10701 }
10702 }
10703
10704 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
10705 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
10706 ce = (zend_class_entry*)Z_OBJ(EX(This));
10707 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
10708 } else {
10709 zend_non_static_method_call(fbc);
10710 HANDLE_EXCEPTION();
10711 }
10712 } else {
10713 /* previous opcode is ZEND_FETCH_CLASS */
10714 if (IS_CONST == IS_UNUSED
10715 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
10716 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
10717 if (Z_TYPE(EX(This)) == IS_OBJECT) {
10718 ce = Z_OBJCE(EX(This));
10719 } else {
10720 ce = Z_CE(EX(This));
10721 }
10722 }
10723 call_info = ZEND_CALL_NESTED_FUNCTION;
10724 }
10725
10726 call = zend_vm_stack_push_call_frame(call_info,
10727 fbc, opline->extended_value, ce);
10728 call->prev_execute_data = EX(call);
10729 EX(call) = call;
10730
10731 ZEND_VM_NEXT_OPCODE();
10732}
10733
10734static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10735{
10736 if (IS_CONST == IS_UNUSED) {
10737 SAVE_OPLINE();
10738 zend_verify_missing_return_type(EX(func));
10739 HANDLE_EXCEPTION();
10740 } else {
10741/* prevents "undefined variable opline" errors */
10742#if 0 || (IS_CONST != IS_UNUSED)
10743 USE_OPLINE
10744 zval *retval_ref, *retval_ptr;
10745 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
10746 retval_ref = retval_ptr = RT_CONSTANT(opline, opline->op1);
10747
10748 if (IS_CONST == IS_CONST) {
10749 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
10750 retval_ref = retval_ptr = EX_VAR(opline->result.var);
10751 } else if (IS_CONST == IS_VAR) {
10752 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
10753 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
10754 }
10755 ZVAL_DEREF(retval_ptr);
10756 } else if (IS_CONST == IS_CV) {
10757 ZVAL_DEREF(retval_ptr);
10758 }
10759
10760 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
10761 ZEND_VM_NEXT_OPCODE();
10762 }
10763
10764 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
10765 SAVE_OPLINE();
10766 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
10767 if (UNEXPECTED(EG(exception))) {
10768 HANDLE_EXCEPTION();
10769 }
10770 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
10771 ZEND_VM_NEXT_OPCODE();
10772 }
10773 }
10774
10775 zend_reference *ref = NULL;
10776 void *cache_slot = CACHE_ADDR(opline->op2.num);
10777 if (UNEXPECTED(retval_ref != retval_ptr)) {
10778 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10779 ref = Z_REF_P(retval_ref);
10780 } else {
10781 /* A cast might happen - unwrap the reference if this is a by-value return */
10782 if (Z_REFCOUNT_P(retval_ref) == 1) {
10783 ZVAL_UNREF(retval_ref);
10784 } else {
10785 Z_DELREF_P(retval_ref);
10786 ZVAL_COPY(retval_ref, retval_ptr);
10787 }
10788 retval_ptr = retval_ref;
10789 }
10790 }
10791
10792 SAVE_OPLINE();
10793 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
10794 zend_verify_return_error(EX(func), retval_ptr);
10795 HANDLE_EXCEPTION();
10796 }
10797 ZEND_VM_NEXT_OPCODE();
10798#endif
10799 }
10800}
10801
10802static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10803{
10804 USE_OPLINE
10805 zval *value, *arg;
10806
10807 if (IS_UNUSED == IS_CONST) {
10808 SAVE_OPLINE();
10809 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10810 uint32_t arg_num;
10811 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10812 if (UNEXPECTED(!arg)) {
10813
10814 HANDLE_EXCEPTION();
10815 }
10816 } else {
10817 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10818 }
10819
10820 value = RT_CONSTANT(opline, opline->op1);
10821 ZVAL_COPY_VALUE(arg, value);
10822 if (IS_CONST == IS_CONST) {
10823 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10824 Z_ADDREF_P(arg);
10825 }
10826 }
10827 ZEND_VM_NEXT_OPCODE();
10828}
10829
10830static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10831{
10832 USE_OPLINE
10833 zval *value, *arg;
10834 uint32_t arg_num;
10835
10836 if (IS_UNUSED == IS_CONST) {
10837 SAVE_OPLINE();
10838 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10839 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10840 if (UNEXPECTED(!arg)) {
10841
10842 HANDLE_EXCEPTION();
10843 }
10844 } else {
10845 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10846 arg_num = opline->op2.num;
10847 }
10848
10849 if (EXPECTED(0)) {
10850 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10851 goto send_val_by_ref;
10852 }
10853 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10854send_val_by_ref:
10855 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10856 }
10857 value = RT_CONSTANT(opline, opline->op1);
10858 ZVAL_COPY_VALUE(arg, value);
10859 if (IS_CONST == IS_CONST) {
10860 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10861 Z_ADDREF_P(arg);
10862 }
10863 }
10864 ZEND_VM_NEXT_OPCODE();
10865}
10866
10867static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10868{
10869 USE_OPLINE
10870 zval *value, *arg;
10871 uint32_t arg_num;
10872
10873 if (IS_UNUSED == IS_CONST) {
10874 SAVE_OPLINE();
10875 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10876 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10877 if (UNEXPECTED(!arg)) {
10878
10879 HANDLE_EXCEPTION();
10880 }
10881 } else {
10882 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10883 arg_num = opline->op2.num;
10884 }
10885
10886 if (EXPECTED(1)) {
10887 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10888 goto send_val_by_ref;
10889 }
10890 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10891send_val_by_ref:
10892 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10893 }
10894 value = RT_CONSTANT(opline, opline->op1);
10895 ZVAL_COPY_VALUE(arg, value);
10896 if (IS_CONST == IS_CONST) {
10897 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10898 Z_ADDREF_P(arg);
10899 }
10900 }
10901 ZEND_VM_NEXT_OPCODE();
10902}
10903
10904static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10905{
10906 USE_OPLINE
10907 zval *result;
10908 zend_function *constructor;
10909 zend_class_entry *ce;
10910 zend_execute_data *call;
10911
10912 SAVE_OPLINE();
10913 if (IS_CONST == IS_CONST) {
10914 ce = CACHED_PTR(opline->op2.num);
10915 if (UNEXPECTED(ce == NULL)) {
10916 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);
10917 if (UNEXPECTED(ce == NULL)) {
10918 ZVAL_UNDEF(EX_VAR(opline->result.var));
10919 HANDLE_EXCEPTION();
10920 }
10921 CACHE_PTR(opline->op2.num, ce);
10922 }
10923 } else if (IS_CONST == IS_UNUSED) {
10924 ce = zend_fetch_class(NULL, opline->op1.num);
10925 if (UNEXPECTED(ce == NULL)) {
10926 ZVAL_UNDEF(EX_VAR(opline->result.var));
10927 HANDLE_EXCEPTION();
10928 }
10929 } else {
10930 ce = Z_CE_P(EX_VAR(opline->op1.var));
10931 }
10932
10933 result = EX_VAR(opline->result.var);
10934 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
10935 ZVAL_UNDEF(result);
10936 HANDLE_EXCEPTION();
10937 }
10938
10939 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
10940 if (constructor == NULL) {
10941 if (UNEXPECTED(EG(exception))) {
10942 HANDLE_EXCEPTION();
10943 }
10944
10945 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
10946 * opcode is DO_FCALL in case EXT instructions are used. */
10947 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
10948 ZEND_VM_NEXT_OPCODE_EX(1, 2);
10949 }
10950
10951 /* Perform a dummy function call */
10952 call = zend_vm_stack_push_call_frame(
10953 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
10954 opline->extended_value, NULL);
10955 } else {
10956 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
10957 init_func_run_time_cache(&constructor->op_array);
10958 }
10959 /* We are not handling overloaded classes right now */
10960 call = zend_vm_stack_push_call_frame(
10961 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
10962 constructor,
10963 opline->extended_value,
10964 Z_OBJ_P(result));
10965 Z_ADDREF_P(result);
10966 }
10967
10968 call->prev_execute_data = EX(call);
10969 EX(call) = call;
10970 ZEND_VM_NEXT_OPCODE();
10971}
10972
10973static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10974{
10975 USE_OPLINE
10976 zval *expr_ptr, new_expr;
10977
10978 SAVE_OPLINE();
10979 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
10980 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
10981 expr_ptr = zend_get_bad_ptr();
10982 if (Z_ISREF_P(expr_ptr)) {
10983 Z_ADDREF_P(expr_ptr);
10984 } else {
10985 ZVAL_MAKE_REF_EX(expr_ptr, 2);
10986 }
10987
10988 } else {
10989 expr_ptr = RT_CONSTANT(opline, opline->op1);
10990 if (IS_CONST == IS_TMP_VAR) {
10991 /* pass */
10992 } else if (IS_CONST == IS_CONST) {
10993 Z_TRY_ADDREF_P(expr_ptr);
10994 } else if (IS_CONST == IS_CV) {
10995 ZVAL_DEREF(expr_ptr);
10996 Z_TRY_ADDREF_P(expr_ptr);
10997 } else /* if (IS_CONST == IS_VAR) */ {
10998 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
10999 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
11000
11001 expr_ptr = Z_REFVAL_P(expr_ptr);
11002 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
11003 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
11004 expr_ptr = &new_expr;
11005 efree_size(ref, sizeof(zend_reference));
11006 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
11007 Z_ADDREF_P(expr_ptr);
11008 }
11009 }
11010 }
11011 }
11012
11013 if (IS_UNUSED != IS_UNUSED) {
11014 zval *offset = NULL;
11015 zend_string *str;
11016 zend_ulong hval;
11017
11018add_again:
11019 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
11020 str = Z_STR_P(offset);
11021 if (IS_UNUSED != IS_CONST) {
11022 if (ZEND_HANDLE_NUMERIC(str, hval)) {
11023 goto num_index;
11024 }
11025 }
11026str_index:
11027 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
11028 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
11029 hval = Z_LVAL_P(offset);
11030num_index:
11031 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
11032 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
11033 offset = Z_REFVAL_P(offset);
11034 goto add_again;
11035 } else if (Z_TYPE_P(offset) == IS_NULL) {
11036 str = ZSTR_EMPTY_ALLOC();
11037 goto str_index;
11038 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
11039 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
11040 goto num_index;
11041 } else if (Z_TYPE_P(offset) == IS_FALSE) {
11042 hval = 0;
11043 goto num_index;
11044 } else if (Z_TYPE_P(offset) == IS_TRUE) {
11045 hval = 1;
11046 goto num_index;
11047 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
11048 zend_use_resource_as_offset(offset);
11049 hval = Z_RES_HANDLE_P(offset);
11050 goto num_index;
11051 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
11052 ZVAL_UNDEFINED_OP2();
11053 str = ZSTR_EMPTY_ALLOC();
11054 goto str_index;
11055 } else {
11056 zend_illegal_array_offset_access(offset);
11057 zval_ptr_dtor_nogc(expr_ptr);
11058 }
11059
11060 } else {
11061 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
11062 zend_cannot_add_element();
11063 zval_ptr_dtor_nogc(expr_ptr);
11064 }
11065 }
11066 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11067}
11068
11069static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11070{
11071 zval *array;
11072 uint32_t size;
11073 USE_OPLINE
11074
11075 SAVE_OPLINE();
11076 array = EX_VAR(opline->result.var);
11077 if (IS_CONST != IS_UNUSED) {
11078 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
11079 ZVAL_ARR(array, zend_new_array(size));
11080 /* Explicitly initialize array as not-packed if flag is set */
11081 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
11082 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
11083 }
11084 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11085 } else {
11086 ZVAL_ARR(array, zend_new_array(0));
11087 ZEND_VM_NEXT_OPCODE();
11088 }
11089}
11090
11091static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11092{
11093 USE_OPLINE
11094 zval *varname;
11095 zend_string *name, *tmp_name;
11096 HashTable *target_symbol_table;
11097
11098 SAVE_OPLINE();
11099
11100 varname = RT_CONSTANT(opline, opline->op1);
11101
11102 if (IS_CONST == IS_CONST) {
11103 name = Z_STR_P(varname);
11104 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
11105 name = Z_STR_P(varname);
11106 tmp_name = NULL;
11107 } else {
11108 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
11109 varname = ZVAL_UNDEFINED_OP1();
11110 }
11111 name = zval_try_get_tmp_string(varname, &tmp_name);
11112 if (UNEXPECTED(!name)) {
11113
11114 HANDLE_EXCEPTION();
11115 }
11116 }
11117
11118 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
11119 zend_hash_del_ind(target_symbol_table, name);
11120
11121 if (IS_CONST != IS_CONST) {
11122 zend_tmp_string_release(tmp_name);
11123 }
11124
11125 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11126}
11127
11128/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
11129static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11130{
11131 USE_OPLINE
11132 zval *value;
11133 bool result;
11134 zval *varname;
11135 zend_string *name, *tmp_name;
11136 HashTable *target_symbol_table;
11137
11138 SAVE_OPLINE();
11139 varname = RT_CONSTANT(opline, opline->op1);
11140 if (IS_CONST == IS_CONST) {
11141 name = Z_STR_P(varname);
11142 } else {
11143 name = zval_get_tmp_string(varname, &tmp_name);
11144 }
11145
11146 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
11147 value = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
11148
11149 if (IS_CONST != IS_CONST) {
11150 zend_tmp_string_release(tmp_name);
11151 }
11152
11153 if (!value) {
11154 result = (opline->extended_value & ZEND_ISEMPTY);
11155 } else {
11156 if (Z_TYPE_P(value) == IS_INDIRECT) {
11157 value = Z_INDIRECT_P(value);
11158 }
11159 if (!(opline->extended_value & ZEND_ISEMPTY)) {
11160 if (Z_ISREF_P(value)) {
11161 value = Z_REFVAL_P(value);
11162 }
11163 result = Z_TYPE_P(value) > IS_NULL;
11164 } else {
11165 result = !i_zend_is_true(value);
11166 }
11167 }
11168
11169 ZEND_VM_SMART_BRANCH(result, true);
11170}
11171
11172/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
11173static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11174{
11175 USE_OPLINE
11176
11177 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
11178
11179 SAVE_OPLINE();
11180 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
11181 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11182 }
11183
11184 /* Destroy the previously yielded value */
11185 zval_ptr_dtor(&generator->value);
11186
11187 /* Destroy the previously yielded key */
11188 zval_ptr_dtor(&generator->key);
11189
11190 /* Set the new yielded value */
11191 if (IS_CONST != IS_UNUSED) {
11192 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
11193 /* Constants and temporary variables aren't yieldable by reference,
11194 * but we still allow them with a notice. */
11195 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
11196 zval *value;
11197
11198 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11199
11200 value = RT_CONSTANT(opline, opline->op1);
11201 ZVAL_COPY_VALUE(&generator->value, value);
11202 if (IS_CONST == IS_CONST) {
11203 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
11204 Z_ADDREF(generator->value);
11205 }
11206 }
11207 } else {
11208 zval *value_ptr = zend_get_bad_ptr();
11209
11210 /* If a function call result is yielded and the function did
11211 * not return by reference we throw a notice. */
11212 do {
11213 if (IS_CONST == IS_VAR) {
11214 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
11215 if (opline->extended_value == ZEND_RETURNS_FUNCTION
11216 && !Z_ISREF_P(value_ptr)) {
11217 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11218 ZVAL_COPY(&generator->value, value_ptr);
11219 break;
11220 }
11221 }
11222 if (Z_ISREF_P(value_ptr)) {
11223 Z_ADDREF_P(value_ptr);
11224 } else {
11225 ZVAL_MAKE_REF_EX(value_ptr, 2);
11226 }
11227 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
11228 } while (0);
11229
11230 }
11231 } else {
11232 zval *value = RT_CONSTANT(opline, opline->op1);
11233
11234 /* Consts, temporary variables and references need copying */
11235 if (IS_CONST == IS_CONST) {
11236 ZVAL_COPY_VALUE(&generator->value, value);
11237 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
11238 Z_ADDREF(generator->value);
11239 }
11240 } else if (IS_CONST == IS_TMP_VAR) {
11241 ZVAL_COPY_VALUE(&generator->value, value);
11242 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
11243 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
11244
11245 } else {
11246 ZVAL_COPY_VALUE(&generator->value, value);
11247 if (IS_CONST == IS_CV) {
11248 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
11249 }
11250 }
11251 }
11252 } else {
11253 /* If no value was specified yield null */
11254 ZVAL_NULL(&generator->value);
11255 }
11256
11257 /* Set the new yielded key */
11258 if (IS_UNUSED != IS_UNUSED) {
11259 zval *key = NULL;
11260 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
11261 key = Z_REFVAL_P(key);
11262 }
11263 ZVAL_COPY(&generator->key, key);
11264
11265 if (Z_TYPE(generator->key) == IS_LONG
11266 && Z_LVAL(generator->key) > generator->largest_used_integer_key
11267 ) {
11268 generator->largest_used_integer_key = Z_LVAL(generator->key);
11269 }
11270 } else {
11271 /* If no key was specified we use auto-increment keys */
11272 generator->largest_used_integer_key++;
11273 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
11274 }
11275
11276 if (RETURN_VALUE_USED(opline)) {
11277 /* If the return value of yield is used set the send
11278 * target and initialize it to NULL */
11279 generator->send_target = EX_VAR(opline->result.var);
11280 ZVAL_NULL(generator->send_target);
11281 } else {
11282 generator->send_target = NULL;
11283 }
11284
11285 /* The GOTO VM uses a local opline variable. We need to set the opline
11286 * variable in execute_data so we don't resume at an old position. */
11287 SAVE_OPLINE();
11288
11289 ZEND_VM_RETURN();
11290}
11291
11292static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11293{
11294 USE_OPLINE
11295 zval *op;
11296
11297 SAVE_OPLINE();
11298 op = RT_CONSTANT(opline, opline->op1);
11299 zend_match_unhandled_error(op);
11300 HANDLE_EXCEPTION();
11301}
11302
11303static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11304{
11305 USE_OPLINE
11306 zval *op1;
11307 zend_long count;
11308
11309 SAVE_OPLINE();
11310 op1 = RT_CONSTANT(opline, opline->op1);
11311
11312 while (1) {
11313 if (Z_TYPE_P(op1) == IS_ARRAY) {
11314 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
11315 break;
11316 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
11317 zend_object *zobj = Z_OBJ_P(op1);
11318
11319 /* first, we check if the handler is defined */
11320 if (zobj->handlers->count_elements) {
11321 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
11322 break;
11323 }
11324 if (UNEXPECTED(EG(exception))) {
11325 count = 0;
11326 break;
11327 }
11328 }
11329
11330 /* if not and the object implements Countable we call its count() method */
11331 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
11332 zval retval;
11333
11334 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
11335 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
11336 count = zval_get_long(&retval);
11337 zval_ptr_dtor(&retval);
11338 break;
11339 }
11340
11341 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
11342 } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11343 op1 = Z_REFVAL_P(op1);
11344 continue;
11345 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11346 ZVAL_UNDEFINED_OP1();
11347 }
11348 count = 0;
11349 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));
11350 break;
11351 }
11352
11353 ZVAL_LONG(EX_VAR(opline->result.var), count);
11354
11355 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11356}
11357
11358static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11359{
11360 USE_OPLINE
11361
11362 if (IS_CONST == IS_UNUSED) {
11363 SAVE_OPLINE();
11364 if (UNEXPECTED(!EX(func)->common.scope)) {
11365 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
11366 ZVAL_UNDEF(EX_VAR(opline->result.var));
11367 HANDLE_EXCEPTION();
11368 } else {
11369 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
11370 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
11371 if (UNEXPECTED(EG(exception))) {
11372 HANDLE_EXCEPTION();
11373 }
11374 ZEND_VM_NEXT_OPCODE();
11375 }
11376 } else {
11377 zval *op1;
11378
11379 SAVE_OPLINE();
11380 op1 = RT_CONSTANT(opline, opline->op1);
11381 while (1) {
11382 if (Z_TYPE_P(op1) == IS_OBJECT) {
11383 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
11384 } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11385 op1 = Z_REFVAL_P(op1);
11386 continue;
11387 } else {
11388 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11389 ZVAL_UNDEFINED_OP1();
11390 }
11391 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
11392 ZVAL_UNDEF(EX_VAR(opline->result.var));
11393 }
11394 break;
11395 }
11396
11397 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11398 }
11399}
11400
11401static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11402{
11403 USE_OPLINE
11404 zval *op1;
11405 zend_string *type;
11406
11407 SAVE_OPLINE();
11408 op1 = RT_CONSTANT(opline, opline->op1);
11409 type = zend_zval_get_legacy_type(op1);
11410 if (EXPECTED(type)) {
11411 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
11412 } else {
11413 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
11414 }
11415
11416 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11417}
11418
11419static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11420{
11421 USE_OPLINE
11422 zend_array *ht;
11423 uint32_t arg_count, result_size, skip;
11424
11425 arg_count = EX_NUM_ARGS();
11426 if (IS_CONST == IS_CONST) {
11427 skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
11428 if (arg_count < skip) {
11429 result_size = 0;
11430 } else {
11431 result_size = arg_count - skip;
11432 }
11433 } else {
11434 skip = 0;
11435 result_size = arg_count;
11436 }
11437
11438 if (result_size) {
11439 SAVE_OPLINE();
11440 uint32_t first_extra_arg = EX(func)->op_array.num_args;
11441
11442 ht = zend_new_array(result_size);
11443 ZVAL_ARR(EX_VAR(opline->result.var), ht);
11444 zend_hash_real_init_packed(ht);
11445 ZEND_HASH_FILL_PACKED(ht) {
11446 zval *p, *q;
11447 uint32_t i = skip;
11448 p = EX_VAR_NUM(i);
11449 if (arg_count > first_extra_arg) {
11450 while (i < first_extra_arg) {
11451 q = p;
11452 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11453 ZVAL_DEREF(q);
11454 if (Z_OPT_REFCOUNTED_P(q)) {
11455 Z_ADDREF_P(q);
11456 }
11457 ZEND_HASH_FILL_SET(q);
11458 } else {
11459 ZEND_HASH_FILL_SET_NULL();
11460 }
11461 ZEND_HASH_FILL_NEXT();
11462 p++;
11463 i++;
11464 }
11465 if (skip < first_extra_arg) {
11466 skip = 0;
11467 } else {
11468 skip -= first_extra_arg;
11469 }
11470 p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
11471 }
11472 while (i < arg_count) {
11473 q = p;
11474 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11475 ZVAL_DEREF(q);
11476 if (Z_OPT_REFCOUNTED_P(q)) {
11477 Z_ADDREF_P(q);
11478 }
11479 ZEND_HASH_FILL_SET(q);
11480 } else {
11481 ZEND_HASH_FILL_SET_NULL();
11482 }
11483 ZEND_HASH_FILL_NEXT();
11484 p++;
11485 i++;
11486 }
11487 } ZEND_HASH_FILL_END();
11488 ht->nNumOfElements = result_size;
11489 } else {
11490 ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
11491 }
11492 ZEND_VM_NEXT_OPCODE();
11493}
11494
11495/* Contrary to what its name indicates, ZEND_COPY_TMP may receive and define references. */
11496static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11497{
11498 USE_OPLINE
11499 SAVE_OPLINE();
11500
11501 zend_class_entry *ce = EX(func)->common.scope;
11502 ZEND_ASSERT(ce);
11503
11504 zend_class_entry *parent_ce = ce->parent;
11505 if (!parent_ce) {
11506 zend_throw_error(NULL, "Cannot use \"parent\" when current class scope has no parent");
11507 UNDEF_RESULT();
11508 HANDLE_EXCEPTION();
11509 }
11510
11511 zend_string *property_name = Z_STR_P(RT_CONSTANT(opline, opline->op1));
11512 zend_property_hook_kind hook_kind = opline->op2.num;
11513
11514 zend_property_info *prop_info = zend_hash_find_ptr(&parent_ce->properties_info, property_name);
11515 if (!prop_info) {
11516 zend_throw_error(NULL, "Undefined property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name));
11517 UNDEF_RESULT();
11518 HANDLE_EXCEPTION();
11519 }
11520 if (prop_info->flags & ZEND_ACC_PRIVATE) {
11521 zend_throw_error(NULL, "Cannot access private property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name));
11522 UNDEF_RESULT();
11523 HANDLE_EXCEPTION();
11524 }
11525
11526 zend_function **hooks = prop_info->hooks;
11527 zend_function *hook = hooks ? hooks[hook_kind] : NULL;
11528
11529 zend_execute_data *call;
11530 if (hook) {
11531 call = zend_vm_stack_push_call_frame(
11532 ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS,
11533 hook, opline->extended_value, Z_OBJ_P(ZEND_THIS));
11534 if (EXPECTED(hook->type == ZEND_USER_FUNCTION)) {
11535 if (UNEXPECTED(!RUN_TIME_CACHE(&hook->op_array))) {
11536 init_func_run_time_cache(&hook->op_array);
11537 }
11538 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
11539 }
11540 } else {
11541 zend_function *fbc = zend_get_property_hook_trampoline(prop_info, hook_kind, property_name);
11542 call = zend_vm_stack_push_call_frame(
11543 ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS,
11544 fbc, opline->extended_value, Z_OBJ_P(ZEND_THIS));
11545 }
11546
11547 call->prev_execute_data = EX(call);
11548 EX(call) = call;
11549 ZEND_VM_NEXT_OPCODE();
11550}
11551
11552static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11553{
11554 USE_OPLINE
11555 zval *op1, *op2;
11556
11557 SAVE_OPLINE();
11558 op1 = RT_CONSTANT(opline, opline->op1);
11559 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11560 div_function(EX_VAR(opline->result.var), op1, op2);
11561
11562
11563 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11564}
11565
11566static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11567{
11568 USE_OPLINE
11569 zval *op1, *op2;
11570
11571 SAVE_OPLINE();
11572 op1 = RT_CONSTANT(opline, opline->op1);
11573 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11574 pow_function(EX_VAR(opline->result.var), op1, op2);
11575
11576
11577 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11578}
11579
11580static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11581{
11582 USE_OPLINE
11583 zval *op1, *op2;
11584
11585 op1 = RT_CONSTANT(opline, opline->op1);
11586 op2 = EX_VAR(opline->op2.var);
11587
11588 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
11589 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
11590 zend_string *op1_str = Z_STR_P(op1);
11591 zend_string *op2_str = Z_STR_P(op2);
11592 zend_string *str;
11593 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
11594
11595 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
11596 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
11597 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
11598 } else {
11599 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
11600 }
11601 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11602 zend_string_release_ex(op1_str, 0);
11603 }
11604 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
11605 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
11606 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
11607 } else {
11608 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
11609 }
11610 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11611 zend_string_release_ex(op2_str, 0);
11612 }
11613 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
11614 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
11615 size_t len = ZSTR_LEN(op1_str);
11616
11617 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
11618 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
11619 }
11620 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
11621 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11622 GC_ADD_FLAGS(str, flags);
11623 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11624 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11625 zend_string_release_ex(op2_str, 0);
11626 }
11627 } else {
11628 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
11629 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
11630 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11631 GC_ADD_FLAGS(str, flags);
11632 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11633 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11634 zend_string_release_ex(op1_str, 0);
11635 }
11636 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11637 zend_string_release_ex(op2_str, 0);
11638 }
11639 }
11640 ZEND_VM_NEXT_OPCODE();
11641 } else {
11642 SAVE_OPLINE();
11643
11644 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11645 op1 = ZVAL_UNDEFINED_OP1();
11646 }
11647 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
11648 op2 = ZVAL_UNDEFINED_OP2();
11649 }
11650 concat_function(EX_VAR(opline->result.var), op1, op2);
11651
11652
11653 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11654 }
11655}
11656
11657static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11658{
11659 USE_OPLINE
11660 zval *op1, *op2;
11661
11662 SAVE_OPLINE();
11663 op1 = RT_CONSTANT(opline, opline->op1);
11664 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11665 compare_function(EX_VAR(opline->result.var), op1, op2);
11666
11667
11668 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11669}
11670
11671static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11672{
11673 USE_OPLINE
11674 zval *container, *dim, *value;
11675
11676 SAVE_OPLINE();
11677 container = RT_CONSTANT(opline, opline->op1);
11678 dim = EX_VAR(opline->op2.var);
11679 if (IS_CONST != IS_CONST) {
11680 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11681fetch_dim_r_array:
11682 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
11683 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
11684 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
11685 container = Z_REFVAL_P(container);
11686 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11687 goto fetch_dim_r_array;
11688 } else {
11689 goto fetch_dim_r_slow;
11690 }
11691 } else {
11692fetch_dim_r_slow:
11693 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
11694 dim++;
11695 }
11696 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
11697 }
11698 } else {
11699 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
11700 }
11701
11702
11703 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11704}
11705
11706static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11707{
11708 USE_OPLINE
11709 zval *container;
11710
11711 SAVE_OPLINE();
11712 container = RT_CONSTANT(opline, opline->op1);
11713 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
11714
11715
11716 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11717}
11718
11719static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11720{
11721#if 0
11722 USE_OPLINE
11723#endif
11724
11725 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
11726 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
11727 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11728 }
11729 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11730 } else {
11731 if (IS_CV == IS_UNUSED) {
11732 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11733 }
11734 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11735 }
11736}
11737
11738static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11739{
11740 USE_OPLINE
11741 zval *container;
11742 void **cache_slot = NULL;
11743
11744 SAVE_OPLINE();
11745 container = RT_CONSTANT(opline, opline->op1);
11746
11747 if (IS_CONST == IS_CONST ||
11748 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
11749 do {
11750 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
11751 container = Z_REFVAL_P(container);
11752 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
11753 break;
11754 }
11755 }
11756 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
11757 ZVAL_UNDEFINED_OP1();
11758 }
11759 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11760 ZVAL_NULL(EX_VAR(opline->result.var));
11761 goto fetch_obj_r_finish;
11762 } while (0);
11763 }
11764
11765 /* here we are sure we are dealing with an object */
11766 do {
11767 zend_object *zobj = Z_OBJ_P(container);
11768 zend_string *name, *tmp_name;
11769 zval *retval;
11770
11771 if (IS_CV == IS_CONST) {
11772 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
11773
11774 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
11775 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
11776
11777 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
11778fetch_obj_r_simple:
11779 retval = OBJ_PROP(zobj, prop_offset);
11780 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
11781 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11782 goto fetch_obj_r_copy;
11783 } else {
11784fetch_obj_r_fast_copy:
11785 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11786 ZEND_VM_NEXT_OPCODE();
11787 }
11788 }
11789 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
11790 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
11791 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
11792 prop_offset = prop_info->offset;
11793 goto fetch_obj_r_simple;
11794 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
11795 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
11796 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
11797 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
11798
11799 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
11800 if (IS_CONST & IS_CV) {
11801 GC_ADDREF(zobj);
11802 }
11803 if (IS_CONST & (IS_CV|IS_VAR|IS_TMP_VAR)) {
11804 call_info |= ZEND_CALL_RELEASE_THIS;
11805 }
11806 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
11807 call->prev_execute_data = execute_data;
11808 call->call = NULL;
11809 call->return_value = EX_VAR(opline->result.var);
11810 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
11811
11812 execute_data = call;
11813 EG(current_execute_data) = execute_data;
11814 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
11815
11816#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
11817 opline = hook->op_array.opcodes;
11818#else
11819 EX(opline) = hook->op_array.opcodes;
11820#endif
11821 LOAD_OPLINE_EX();
11822
11823
11824 ZEND_VM_ENTER_EX();
11825 }
11826 /* Fall through to read_property for hooks. */
11827 } else if (EXPECTED(zobj->properties != NULL)) {
11828 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
11829 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11830 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
11831 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
11832
11833 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
11834 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
11835
11836 if (EXPECTED(p->key == name) ||
11837 (EXPECTED(p->h == ZSTR_H(name)) &&
11838 EXPECTED(p->key != NULL) &&
11839 EXPECTED(zend_string_equal_content(p->key, name)))) {
11840 retval = &p->val;
11841 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11842 goto fetch_obj_r_copy;
11843 } else {
11844 goto fetch_obj_r_fast_copy;
11845 }
11846 }
11847 }
11848 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
11849 }
11850 retval = zend_hash_find_known_hash(zobj->properties, name);
11851 if (EXPECTED(retval)) {
11852 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
11853 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
11854 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11855 goto fetch_obj_r_copy;
11856 } else {
11857 goto fetch_obj_r_fast_copy;
11858 }
11859 }
11860 }
11861 }
11862 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11863 } else {
11864 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
11865 if (UNEXPECTED(!name)) {
11866 ZVAL_UNDEF(EX_VAR(opline->result.var));
11867 break;
11868 }
11869 }
11870
11871#if ZEND_DEBUG
11872 /* For non-standard object handlers, verify a declared property type in debug builds.
11873 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
11874 zend_property_info *prop_info = NULL;
11875 if (zobj->handlers->read_property != zend_std_read_property) {
11876 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
11877 }
11878#endif
11879 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
11880#if ZEND_DEBUG
11881 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
11882 && ZEND_TYPE_IS_SET(prop_info->type)) {
11883 ZVAL_OPT_DEREF(retval);
11884 zend_verify_property_type(prop_info, retval, /* strict */ true);
11885 }
11886#endif
11887
11888 if (IS_CV != IS_CONST) {
11889 zend_tmp_string_release(tmp_name);
11890 }
11891
11892 if (retval != EX_VAR(opline->result.var)) {
11893fetch_obj_r_copy:
11894 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11895 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
11896 zend_unwrap_reference(retval);
11897 }
11898 } while (0);
11899
11900fetch_obj_r_finish:
11901
11902
11903 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11904}
11905
11906static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11907{
11908 USE_OPLINE
11909 zval *container;
11910 void **cache_slot = NULL;
11911
11912 SAVE_OPLINE();
11913 container = RT_CONSTANT(opline, opline->op1);
11914
11915 if (IS_CONST == IS_CONST ||
11916 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
11917 do {
11918 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
11919 container = Z_REFVAL_P(container);
11920 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
11921 break;
11922 }
11923 }
11924 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
11925 ZVAL_UNDEFINED_OP2();
11926 }
11927 ZVAL_NULL(EX_VAR(opline->result.var));
11928 goto fetch_obj_is_finish;
11929 } while (0);
11930 }
11931
11932 /* here we are sure we are dealing with an object */
11933 do {
11934 zend_object *zobj = Z_OBJ_P(container);
11935 zend_string *name, *tmp_name;
11936 zval *retval;
11937
11938 if (IS_CV == IS_CONST) {
11939 cache_slot = CACHE_ADDR(opline->extended_value);
11940
11941 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
11942 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
11943
11944 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
11945fetch_obj_is_simple:
11946 retval = OBJ_PROP(zobj, prop_offset);
11947 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
11948 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11949 goto fetch_obj_is_copy;
11950 } else {
11951fetch_obj_is_fast_copy:
11952 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11953 ZEND_VM_NEXT_OPCODE();
11954 }
11955 }
11956 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
11957 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
11958 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
11959 prop_offset = prop_info->offset;
11960 goto fetch_obj_is_simple;
11961 }
11962 /* Fall through to read_property for hooks. */
11963 } else if (EXPECTED(zobj->properties != NULL)) {
11964 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
11965 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11966 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
11967 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
11968
11969 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
11970 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
11971
11972 if (EXPECTED(p->key == name) ||
11973 (EXPECTED(p->h == ZSTR_H(name)) &&
11974 EXPECTED(p->key != NULL) &&
11975 EXPECTED(zend_string_equal_content(p->key, name)))) {
11976 retval = &p->val;
11977 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11978 goto fetch_obj_is_copy;
11979 } else {
11980 goto fetch_obj_is_fast_copy;
11981 }
11982 }
11983 }
11984 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
11985 }
11986 retval = zend_hash_find_known_hash(zobj->properties, name);
11987 if (EXPECTED(retval)) {
11988 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
11989 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
11990 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11991 goto fetch_obj_is_copy;
11992 } else {
11993 goto fetch_obj_is_fast_copy;
11994 }
11995 }
11996 }
11997 }
11998 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11999 } else {
12000 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
12001 if (UNEXPECTED(!name)) {
12002 ZVAL_UNDEF(EX_VAR(opline->result.var));
12003 break;
12004 }
12005 }
12006
12007 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
12008
12009 if (IS_CV != IS_CONST) {
12010 zend_tmp_string_release(tmp_name);
12011 }
12012
12013 if (retval != EX_VAR(opline->result.var)) {
12014fetch_obj_is_copy:
12015 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
12016 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
12017 zend_unwrap_reference(retval);
12018 }
12019 } while (0);
12020
12021fetch_obj_is_finish:
12022
12023
12024 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12025}
12026
12027static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12028{
12029#if 0
12030 USE_OPLINE
12031#endif
12032
12033 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
12034 /* Behave like FETCH_OBJ_W */
12035 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
12036 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12037 }
12038 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12039 } else {
12040 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12041 }
12042}
12043
12044static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12045{
12046 USE_OPLINE
12047 zval *container;
12048
12049 SAVE_OPLINE();
12050 container = RT_CONSTANT(opline, opline->op1);
12051 zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
12052
12053 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12054}
12055
12056static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12057{
12058 USE_OPLINE
12059 zval *op1, *op2;
12060 zend_string *op1_str, *op2_str, *str;
12061
12062
12063 op1 = RT_CONSTANT(opline, opline->op1);
12064 op2 = EX_VAR(opline->op2.var);
12065 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
12066 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
12067 zend_string *op1_str = Z_STR_P(op1);
12068 zend_string *op2_str = Z_STR_P(op2);
12069 zend_string *str;
12070 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
12071
12072 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
12073 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
12074 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
12075 } else {
12076 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
12077 }
12078 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
12079 zend_string_release_ex(op1_str, 0);
12080 }
12081 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
12082 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
12083 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
12084 } else {
12085 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
12086 }
12087 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12088 zend_string_release_ex(op2_str, 0);
12089 }
12090 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
12091 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
12092 size_t len = ZSTR_LEN(op1_str);
12093
12094 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
12095 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12096 GC_ADD_FLAGS(str, flags);
12097 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12098 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12099 zend_string_release_ex(op2_str, 0);
12100 }
12101 } else {
12102 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
12103 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
12104 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12105 GC_ADD_FLAGS(str, flags);
12106 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12107 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
12108 zend_string_release_ex(op1_str, 0);
12109 }
12110 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12111 zend_string_release_ex(op2_str, 0);
12112 }
12113 }
12114 ZEND_VM_NEXT_OPCODE();
12115 }
12116
12117 SAVE_OPLINE();
12118 if (IS_CONST == IS_CONST) {
12119 op1_str = Z_STR_P(op1);
12120 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
12121 op1_str = zend_string_copy(Z_STR_P(op1));
12122 } else {
12123 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
12124 ZVAL_UNDEFINED_OP1();
12125 }
12126 op1_str = zval_get_string_func(op1);
12127 }
12128 if (IS_CV == IS_CONST) {
12129 op2_str = Z_STR_P(op2);
12130 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
12131 op2_str = zend_string_copy(Z_STR_P(op2));
12132 } else {
12133 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
12134 ZVAL_UNDEFINED_OP2();
12135 }
12136 op2_str = zval_get_string_func(op2);
12137 }
12138 do {
12139 if (IS_CONST != IS_CONST) {
12140 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
12141 if (IS_CV == IS_CONST) {
12142 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
12143 GC_ADDREF(op2_str);
12144 }
12145 }
12146 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
12147 zend_string_release_ex(op1_str, 0);
12148 break;
12149 }
12150 }
12151 if (IS_CV != IS_CONST) {
12152 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
12153 if (IS_CONST == IS_CONST) {
12154 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
12155 GC_ADDREF(op1_str);
12156 }
12157 }
12158 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
12159 zend_string_release_ex(op2_str, 0);
12160 break;
12161 }
12162 }
12163 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
12164 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
12165 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12166
12167 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
12168 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12169 if (IS_CONST != IS_CONST) {
12170 zend_string_release_ex(op1_str, 0);
12171 }
12172 if (IS_CV != IS_CONST) {
12173 zend_string_release_ex(op2_str, 0);
12174 }
12175 } while (0);
12176
12177
12178 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12179}
12180
12181static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12182{
12183 USE_OPLINE
12184 zval *function_name;
12185 zval *object;
12186 zend_function *fbc;
12187 zend_class_entry *called_scope;
12188 zend_object *obj;
12189 zend_execute_data *call;
12190 uint32_t call_info;
12191
12192 SAVE_OPLINE();
12193
12194 object = RT_CONSTANT(opline, opline->op1);
12195
12196 if (IS_CV != IS_CONST) {
12197 function_name = EX_VAR(opline->op2.var);
12198 }
12199
12200 if (IS_CV != IS_CONST &&
12201 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
12202 do {
12203 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
12204 function_name = Z_REFVAL_P(function_name);
12205 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
12206 break;
12207 }
12208 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
12209 ZVAL_UNDEFINED_OP2();
12210 if (UNEXPECTED(EG(exception) != NULL)) {
12211
12212 HANDLE_EXCEPTION();
12213 }
12214 }
12215 zend_throw_error(NULL, "Method name must be a string");
12216
12217
12218 HANDLE_EXCEPTION();
12219 } while (0);
12220 }
12221
12222 if (IS_CONST == IS_UNUSED) {
12223 obj = Z_OBJ_P(object);
12224 } else {
12225 do {
12226 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
12227 obj = Z_OBJ_P(object);
12228 } else {
12229 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
12230 zend_reference *ref = Z_REF_P(object);
12231
12232 object = &ref->val;
12233 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
12234 obj = Z_OBJ_P(object);
12235 if (IS_CONST & IS_VAR) {
12236 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
12237 efree_size(ref, sizeof(zend_reference));
12238 } else {
12239 Z_ADDREF_P(object);
12240 }
12241 }
12242 break;
12243 }
12244 }
12245 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
12246 object = ZVAL_UNDEFINED_OP1();
12247 if (UNEXPECTED(EG(exception) != NULL)) {
12248 if (IS_CV != IS_CONST) {
12249
12250 }
12251 HANDLE_EXCEPTION();
12252 }
12253 }
12254 if (IS_CV == IS_CONST) {
12255 function_name = EX_VAR(opline->op2.var);
12256 }
12257 zend_invalid_method_call(object, function_name);
12258
12259
12260 HANDLE_EXCEPTION();
12261 }
12262 } while (0);
12263 }
12264
12265 called_scope = obj->ce;
12266
12267 if (IS_CV == IS_CONST &&
12268 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
12269 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
12270 } else {
12271 zend_object *orig_obj = obj;
12272
12273 if (IS_CV == IS_CONST) {
12274 function_name = EX_VAR(opline->op2.var);
12275 }
12276
12277 /* First, locate the function. */
12278 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
12279 if (UNEXPECTED(fbc == NULL)) {
12280 if (EXPECTED(!EG(exception))) {
12281 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
12282 }
12283
12284 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
12285 zend_objects_store_del(orig_obj);
12286 }
12287 HANDLE_EXCEPTION();
12288 }
12289 if (IS_CV == IS_CONST &&
12290 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
12291 EXPECTED(obj == orig_obj)) {
12292 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
12293 }
12294 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
12295 GC_ADDREF(obj); /* For $this pointer */
12296 if (GC_DELREF(orig_obj) == 0) {
12297 zend_objects_store_del(orig_obj);
12298 }
12299 }
12300 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12301 init_func_run_time_cache(&fbc->op_array);
12302 }
12303 }
12304
12305 if (IS_CV != IS_CONST) {
12306
12307 }
12308
12309 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
12310 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
12311 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
12312 zend_objects_store_del(obj);
12313 if (UNEXPECTED(EG(exception))) {
12314 HANDLE_EXCEPTION();
12315 }
12316 }
12317 /* call static method */
12318 obj = (zend_object*)called_scope;
12319 call_info = ZEND_CALL_NESTED_FUNCTION;
12320 } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
12321 if (IS_CONST == IS_CV) {
12322 GC_ADDREF(obj); /* For $this pointer */
12323 }
12324 /* CV may be changed indirectly (e.g. when it's a reference) */
12325 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
12326 }
12327
12328 call = zend_vm_stack_push_call_frame(call_info,
12329 fbc, opline->extended_value, obj);
12330 call->prev_execute_data = EX(call);
12331 EX(call) = call;
12332
12333 ZEND_VM_NEXT_OPCODE();
12334}
12335
12336static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12337{
12338 USE_OPLINE
12339 zval *function_name;
12340 zend_class_entry *ce;
12341 uint32_t call_info;
12342 zend_function *fbc;
12343 zend_execute_data *call;
12344
12345 SAVE_OPLINE();
12346
12347 if (IS_CONST == IS_CONST) {
12348 /* no function found. try a static method in class */
12349 ce = CACHED_PTR(opline->result.num);
12350 if (UNEXPECTED(ce == NULL)) {
12351 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);
12352 if (UNEXPECTED(ce == NULL)) {
12353
12354 HANDLE_EXCEPTION();
12355 }
12356 if (IS_CV != IS_CONST) {
12357 CACHE_PTR(opline->result.num, ce);
12358 }
12359 }
12360 } else if (IS_CONST == IS_UNUSED) {
12361 ce = zend_fetch_class(NULL, opline->op1.num);
12362 if (UNEXPECTED(ce == NULL)) {
12363
12364 HANDLE_EXCEPTION();
12365 }
12366 } else {
12367 ce = Z_CE_P(EX_VAR(opline->op1.var));
12368 }
12369
12370 if (IS_CONST == IS_CONST &&
12371 IS_CV == IS_CONST &&
12372 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
12373 /* nothing to do */
12374 } else if (IS_CONST != IS_CONST &&
12375 IS_CV == IS_CONST &&
12376 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
12377 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
12378 } else if (IS_CV != IS_UNUSED) {
12379 function_name = EX_VAR(opline->op2.var);
12380 if (IS_CV != IS_CONST) {
12381 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
12382 do {
12383 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
12384 function_name = Z_REFVAL_P(function_name);
12385 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
12386 break;
12387 }
12388 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
12389 ZVAL_UNDEFINED_OP2();
12390 if (UNEXPECTED(EG(exception) != NULL)) {
12391 HANDLE_EXCEPTION();
12392 }
12393 }
12394 zend_throw_error(NULL, "Method name must be a string");
12395
12396 HANDLE_EXCEPTION();
12397 } while (0);
12398 }
12399 }
12400
12401 if (ce->get_static_method) {
12402 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
12403 } else {
12404 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
12405 }
12406 if (UNEXPECTED(fbc == NULL)) {
12407 if (EXPECTED(!EG(exception))) {
12408 zend_undefined_method(ce, Z_STR_P(function_name));
12409 }
12410
12411 HANDLE_EXCEPTION();
12412 }
12413 if (IS_CV == IS_CONST &&
12414 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
12415 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
12416 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
12417 }
12418 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12419 init_func_run_time_cache(&fbc->op_array);
12420 }
12421 if (IS_CV != IS_CONST) {
12422
12423 }
12424 } else {
12425 if (UNEXPECTED(ce->constructor == NULL)) {
12426 zend_throw_error(NULL, "Cannot call constructor");
12427 HANDLE_EXCEPTION();
12428 }
12429 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
12430 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
12431 HANDLE_EXCEPTION();
12432 }
12433 fbc = ce->constructor;
12434 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12435 init_func_run_time_cache(&fbc->op_array);
12436 }
12437 }
12438
12439 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
12440 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
12441 ce = (zend_class_entry*)Z_OBJ(EX(This));
12442 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
12443 } else {
12444 zend_non_static_method_call(fbc);
12445 HANDLE_EXCEPTION();
12446 }
12447 } else {
12448 /* previous opcode is ZEND_FETCH_CLASS */
12449 if (IS_CONST == IS_UNUSED
12450 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
12451 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
12452 if (Z_TYPE(EX(This)) == IS_OBJECT) {
12453 ce = Z_OBJCE(EX(This));
12454 } else {
12455 ce = Z_CE(EX(This));
12456 }
12457 }
12458 call_info = ZEND_CALL_NESTED_FUNCTION;
12459 }
12460
12461 call = zend_vm_stack_push_call_frame(call_info,
12462 fbc, opline->extended_value, ce);
12463 call->prev_execute_data = EX(call);
12464 EX(call) = call;
12465
12466 ZEND_VM_NEXT_OPCODE();
12467}
12468
12469static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12470{
12471 USE_OPLINE
12472 zval *function_name;
12473 zend_fcall_info_cache fcc;
12474 char *error = NULL;
12475 zend_function *func;
12476 void *object_or_called_scope;
12477 zend_execute_data *call;
12478 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
12479
12480 SAVE_OPLINE();
12481 function_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12482 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
12483 ZEND_ASSERT(!error);
12484
12485 /* Deprecation can be emitted from zend_is_callable_ex(), which can
12486 * invoke a user error handler and throw an exception.
12487 * For the CONST and CV case we reuse the same exception block below
12488 * to make sure we don't increase VM size too much. */
12489 if (!(IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
12490
12491 HANDLE_EXCEPTION();
12492 }
12493
12494 func = fcc.function_handler;
12495 object_or_called_scope = fcc.called_scope;
12496 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
12497 /* Delay closure destruction until its invocation */
12498 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
12499 call_info |= ZEND_CALL_CLOSURE;
12500 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
12501 call_info |= ZEND_CALL_FAKE_CLOSURE;
12502 }
12503 if (fcc.object) {
12504 object_or_called_scope = fcc.object;
12505 call_info |= ZEND_CALL_HAS_THIS;
12506 }
12507 } else if (fcc.object) {
12508 GC_ADDREF(fcc.object); /* For $this pointer */
12509 object_or_called_scope = fcc.object;
12510 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
12511 }
12512
12513 if ((IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
12514 if (call_info & ZEND_CALL_CLOSURE) {
12515 zend_object_release(ZEND_CLOSURE_OBJECT(func));
12516 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
12517 zend_object_release(fcc.object);
12518 }
12519 HANDLE_EXCEPTION();
12520 }
12521
12522 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
12523 init_func_run_time_cache(&func->op_array);
12524 }
12525 } else {
12526 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
12527 efree(error);
12528
12529 HANDLE_EXCEPTION();
12530 }
12531
12532 call = zend_vm_stack_push_call_frame(call_info,
12533 func, opline->extended_value, object_or_called_scope);
12534 call->prev_execute_data = EX(call);
12535 EX(call) = call;
12536
12537 ZEND_VM_NEXT_OPCODE();
12538}
12539
12540static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12541{
12542 USE_OPLINE
12543 zval *expr_ptr, new_expr;
12544
12545 SAVE_OPLINE();
12546 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
12547 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
12548 expr_ptr = zend_get_bad_ptr();
12549 if (Z_ISREF_P(expr_ptr)) {
12550 Z_ADDREF_P(expr_ptr);
12551 } else {
12552 ZVAL_MAKE_REF_EX(expr_ptr, 2);
12553 }
12554
12555 } else {
12556 expr_ptr = RT_CONSTANT(opline, opline->op1);
12557 if (IS_CONST == IS_TMP_VAR) {
12558 /* pass */
12559 } else if (IS_CONST == IS_CONST) {
12560 Z_TRY_ADDREF_P(expr_ptr);
12561 } else if (IS_CONST == IS_CV) {
12562 ZVAL_DEREF(expr_ptr);
12563 Z_TRY_ADDREF_P(expr_ptr);
12564 } else /* if (IS_CONST == IS_VAR) */ {
12565 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
12566 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
12567
12568 expr_ptr = Z_REFVAL_P(expr_ptr);
12569 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
12570 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
12571 expr_ptr = &new_expr;
12572 efree_size(ref, sizeof(zend_reference));
12573 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
12574 Z_ADDREF_P(expr_ptr);
12575 }
12576 }
12577 }
12578 }
12579
12580 if (IS_CV != IS_UNUSED) {
12581 zval *offset = EX_VAR(opline->op2.var);
12582 zend_string *str;
12583 zend_ulong hval;
12584
12585add_again:
12586 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12587 str = Z_STR_P(offset);
12588 if (IS_CV != IS_CONST) {
12589 if (ZEND_HANDLE_NUMERIC(str, hval)) {
12590 goto num_index;
12591 }
12592 }
12593str_index:
12594 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
12595 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12596 hval = Z_LVAL_P(offset);
12597num_index:
12598 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
12599 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
12600 offset = Z_REFVAL_P(offset);
12601 goto add_again;
12602 } else if (Z_TYPE_P(offset) == IS_NULL) {
12603 str = ZSTR_EMPTY_ALLOC();
12604 goto str_index;
12605 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
12606 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
12607 goto num_index;
12608 } else if (Z_TYPE_P(offset) == IS_FALSE) {
12609 hval = 0;
12610 goto num_index;
12611 } else if (Z_TYPE_P(offset) == IS_TRUE) {
12612 hval = 1;
12613 goto num_index;
12614 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
12615 zend_use_resource_as_offset(offset);
12616 hval = Z_RES_HANDLE_P(offset);
12617 goto num_index;
12618 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
12619 ZVAL_UNDEFINED_OP2();
12620 str = ZSTR_EMPTY_ALLOC();
12621 goto str_index;
12622 } else {
12623 zend_illegal_array_offset_access(offset);
12624 zval_ptr_dtor_nogc(expr_ptr);
12625 }
12626
12627 } else {
12628 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
12629 zend_cannot_add_element();
12630 zval_ptr_dtor_nogc(expr_ptr);
12631 }
12632 }
12633 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12634}
12635
12636static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12637{
12638 zval *array;
12639 uint32_t size;
12640 USE_OPLINE
12641
12642 SAVE_OPLINE();
12643 array = EX_VAR(opline->result.var);
12644 if (IS_CONST != IS_UNUSED) {
12645 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
12646 ZVAL_ARR(array, zend_new_array(size));
12647 /* Explicitly initialize array as not-packed if flag is set */
12648 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
12649 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
12650 }
12651 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12652 } else {
12653 ZVAL_ARR(array, zend_new_array(0));
12654 ZEND_VM_NEXT_OPCODE();
12655 }
12656}
12657
12658static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12659{
12660 USE_OPLINE
12661 zval *container;
12662 bool result;
12663 zend_ulong hval;
12664 zval *offset;
12665
12666 SAVE_OPLINE();
12667 container = RT_CONSTANT(opline, opline->op1);
12668 offset = EX_VAR(opline->op2.var);
12669
12670 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12671 HashTable *ht;
12672 zval *value;
12673 zend_string *str;
12674
12675isset_dim_obj_array:
12676 ht = Z_ARRVAL_P(container);
12677isset_again:
12678 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12679 str = Z_STR_P(offset);
12680 if (IS_CV != IS_CONST) {
12681 if (ZEND_HANDLE_NUMERIC(str, hval)) {
12682 goto num_index_prop;
12683 }
12684 }
12685 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
12686 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12687 hval = Z_LVAL_P(offset);
12688num_index_prop:
12689 value = zend_hash_index_find(ht, hval);
12690 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
12691 offset = Z_REFVAL_P(offset);
12692 goto isset_again;
12693 } else {
12694 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
12695 if (UNEXPECTED(EG(exception))) {
12696 result = 0;
12697 goto isset_dim_obj_exit;
12698 }
12699 }
12700
12701 if (!(opline->extended_value & ZEND_ISEMPTY)) {
12702 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
12703 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
12704 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
12705
12706 if (IS_CONST & (IS_CONST|IS_CV)) {
12707 /* avoid exception check */
12708
12709 ZEND_VM_SMART_BRANCH(result, 0);
12710 }
12711 } else {
12712 result = (value == NULL || !i_zend_is_true(value));
12713 }
12714 goto isset_dim_obj_exit;
12715 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
12716 container = Z_REFVAL_P(container);
12717 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12718 goto isset_dim_obj_array;
12719 }
12720 }
12721
12722 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
12723 offset++;
12724 }
12725 if (!(opline->extended_value & ZEND_ISEMPTY)) {
12726 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
12727 } else {
12728 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
12729 }
12730
12731isset_dim_obj_exit:
12732
12733
12734 ZEND_VM_SMART_BRANCH(result, 1);
12735}
12736
12737static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12738{
12739 USE_OPLINE
12740 zval *container;
12741 int result;
12742 zval *offset;
12743 zend_string *name, *tmp_name;
12744
12745 SAVE_OPLINE();
12746 container = RT_CONSTANT(opline, opline->op1);
12747 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12748
12749 if (IS_CONST == IS_CONST ||
12750 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
12751 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
12752 container = Z_REFVAL_P(container);
12753 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
12754 result = (opline->extended_value & ZEND_ISEMPTY);
12755 goto isset_object_finish;
12756 }
12757 } else {
12758 result = (opline->extended_value & ZEND_ISEMPTY);
12759 goto isset_object_finish;
12760 }
12761 }
12762
12763 if (IS_CV == IS_CONST) {
12764 name = Z_STR_P(offset);
12765 } else {
12766 name = zval_try_get_tmp_string(offset, &tmp_name);
12767 if (UNEXPECTED(!name)) {
12768 result = 0;
12769 goto isset_object_finish;
12770 }
12771 }
12772
12773 result =
12774 (opline->extended_value & ZEND_ISEMPTY) ^
12775 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));
12776
12777 if (IS_CV != IS_CONST) {
12778 zend_tmp_string_release(tmp_name);
12779 }
12780
12781isset_object_finish:
12782
12783
12784 ZEND_VM_SMART_BRANCH(result, 1);
12785}
12786
12787static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12788{
12789 USE_OPLINE
12790
12791 zval *key, *subject;
12792 HashTable *ht;
12793 bool result;
12794
12795 SAVE_OPLINE();
12796
12797 key = RT_CONSTANT(opline, opline->op1);
12798 subject = EX_VAR(opline->op2.var);
12799
12800 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12801array_key_exists_array:
12802 ht = Z_ARRVAL_P(subject);
12803 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
12804 } else {
12805 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
12806 subject = Z_REFVAL_P(subject);
12807 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12808 goto array_key_exists_array;
12809 }
12810 }
12811 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
12812 result = 0;
12813 }
12814
12815
12816 ZEND_VM_SMART_BRANCH(result, 1);
12817}
12818
12819static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12820{
12821 USE_OPLINE
12822
12823 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
12824
12825 SAVE_OPLINE();
12826 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
12827 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12828 }
12829
12830 /* Destroy the previously yielded value */
12831 zval_ptr_dtor(&generator->value);
12832
12833 /* Destroy the previously yielded key */
12834 zval_ptr_dtor(&generator->key);
12835
12836 /* Set the new yielded value */
12837 if (IS_CONST != IS_UNUSED) {
12838 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
12839 /* Constants and temporary variables aren't yieldable by reference,
12840 * but we still allow them with a notice. */
12841 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
12842 zval *value;
12843
12844 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12845
12846 value = RT_CONSTANT(opline, opline->op1);
12847 ZVAL_COPY_VALUE(&generator->value, value);
12848 if (IS_CONST == IS_CONST) {
12849 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12850 Z_ADDREF(generator->value);
12851 }
12852 }
12853 } else {
12854 zval *value_ptr = zend_get_bad_ptr();
12855
12856 /* If a function call result is yielded and the function did
12857 * not return by reference we throw a notice. */
12858 do {
12859 if (IS_CONST == IS_VAR) {
12860 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
12861 if (opline->extended_value == ZEND_RETURNS_FUNCTION
12862 && !Z_ISREF_P(value_ptr)) {
12863 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12864 ZVAL_COPY(&generator->value, value_ptr);
12865 break;
12866 }
12867 }
12868 if (Z_ISREF_P(value_ptr)) {
12869 Z_ADDREF_P(value_ptr);
12870 } else {
12871 ZVAL_MAKE_REF_EX(value_ptr, 2);
12872 }
12873 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
12874 } while (0);
12875
12876 }
12877 } else {
12878 zval *value = RT_CONSTANT(opline, opline->op1);
12879
12880 /* Consts, temporary variables and references need copying */
12881 if (IS_CONST == IS_CONST) {
12882 ZVAL_COPY_VALUE(&generator->value, value);
12883 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12884 Z_ADDREF(generator->value);
12885 }
12886 } else if (IS_CONST == IS_TMP_VAR) {
12887 ZVAL_COPY_VALUE(&generator->value, value);
12888 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
12889 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
12890
12891 } else {
12892 ZVAL_COPY_VALUE(&generator->value, value);
12893 if (IS_CONST == IS_CV) {
12894 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
12895 }
12896 }
12897 }
12898 } else {
12899 /* If no value was specified yield null */
12900 ZVAL_NULL(&generator->value);
12901 }
12902
12903 /* Set the new yielded key */
12904 if (IS_CV != IS_UNUSED) {
12905 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12906 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
12907 key = Z_REFVAL_P(key);
12908 }
12909 ZVAL_COPY(&generator->key, key);
12910
12911 if (Z_TYPE(generator->key) == IS_LONG
12912 && Z_LVAL(generator->key) > generator->largest_used_integer_key
12913 ) {
12914 generator->largest_used_integer_key = Z_LVAL(generator->key);
12915 }
12916 } else {
12917 /* If no key was specified we use auto-increment keys */
12918 generator->largest_used_integer_key++;
12919 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
12920 }
12921
12922 if (RETURN_VALUE_USED(opline)) {
12923 /* If the return value of yield is used set the send
12924 * target and initialize it to NULL */
12925 generator->send_target = EX_VAR(opline->result.var);
12926 ZVAL_NULL(generator->send_target);
12927 } else {
12928 generator->send_target = NULL;
12929 }
12930
12931 /* The GOTO VM uses a local opline variable. We need to set the opline
12932 * variable in execute_data so we don't resume at an old position. */
12933 SAVE_OPLINE();
12934
12935 ZEND_VM_RETURN();
12936}
12937
12938static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12939{
12940 USE_OPLINE
12941 zval *op1;
12942
12943 op1 = EX_VAR(opline->op1.var);
12944 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12945 ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
12946 ZEND_VM_NEXT_OPCODE();
12947 }
12948
12949 ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(op1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12950}
12951
12952static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12953{
12954 USE_OPLINE
12955 zval *value;
12956
12957 value = EX_VAR(opline->op1.var);
12958 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
12959 ZEND_VM_NEXT_OPCODE();
12960}
12961
12962static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12963{
12964 USE_OPLINE
12965 zval *value;
12966
12967 value = EX_VAR(opline->op1.var);
12968 ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
12969 ZEND_VM_NEXT_OPCODE();
12970}
12971
12972static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12973{
12974 USE_OPLINE
12975 zval *value;
12976
12977 value = EX_VAR(opline->op1.var);
12978 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
12979 ZEND_VM_NEXT_OPCODE();
12980}
12981
12982static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12983{
12984 USE_OPLINE
12985 zval *op1, *op2, *result;
12986 double d1, d2;
12987
12988 op1 = EX_VAR(opline->op1.var);
12989 op2 = RT_CONSTANT(opline, opline->op2);
12990 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12991 /* pass */
12992 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12993 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12994 result = EX_VAR(opline->result.var);
12995 fast_long_add_function(result, op1, op2);
12996 ZEND_VM_NEXT_OPCODE();
12997 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12998 d1 = (double)Z_LVAL_P(op1);
12999 d2 = Z_DVAL_P(op2);
13000 goto add_double;
13001 }
13002 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13003 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13004 d1 = Z_DVAL_P(op1);
13005 d2 = Z_DVAL_P(op2);
13006add_double:
13007 result = EX_VAR(opline->result.var);
13008 ZVAL_DOUBLE(result, d1 + d2);
13009 ZEND_VM_NEXT_OPCODE();
13010 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13011 d1 = Z_DVAL_P(op1);
13012 d2 = (double)Z_LVAL_P(op2);
13013 goto add_double;
13014 }
13015 }
13016
13017 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13018}
13019
13020static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13021{
13022 USE_OPLINE
13023 zval *op1, *op2, *result;
13024 double d1, d2;
13025
13026 op1 = EX_VAR(opline->op1.var);
13027 op2 = RT_CONSTANT(opline, opline->op2);
13028 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13029 /* pass */
13030 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13031 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13032 result = EX_VAR(opline->result.var);
13033 fast_long_sub_function(result, op1, op2);
13034 ZEND_VM_NEXT_OPCODE();
13035 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13036 d1 = (double)Z_LVAL_P(op1);
13037 d2 = Z_DVAL_P(op2);
13038 goto sub_double;
13039 }
13040 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13041 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13042 d1 = Z_DVAL_P(op1);
13043 d2 = Z_DVAL_P(op2);
13044sub_double:
13045 result = EX_VAR(opline->result.var);
13046 ZVAL_DOUBLE(result, d1 - d2);
13047 ZEND_VM_NEXT_OPCODE();
13048 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13049 d1 = Z_DVAL_P(op1);
13050 d2 = (double)Z_LVAL_P(op2);
13051 goto sub_double;
13052 }
13053 }
13054
13055 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13056}
13057
13058static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13059{
13060 USE_OPLINE
13061 zval *op1, *op2, *result;
13062 double d1, d2;
13063
13064 op1 = EX_VAR(opline->op1.var);
13065 op2 = RT_CONSTANT(opline, opline->op2);
13066 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13067 /* pass */
13068 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13069 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13070 zend_long overflow;
13071
13072 result = EX_VAR(opline->result.var);
13073 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13074 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13075 ZEND_VM_NEXT_OPCODE();
13076 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13077 d1 = (double)Z_LVAL_P(op1);
13078 d2 = Z_DVAL_P(op2);
13079 goto mul_double;
13080 }
13081 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13082 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13083 d1 = Z_DVAL_P(op1);
13084 d2 = Z_DVAL_P(op2);
13085mul_double:
13086 result = EX_VAR(opline->result.var);
13087 ZVAL_DOUBLE(result, d1 * d2);
13088 ZEND_VM_NEXT_OPCODE();
13089 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13090 d1 = Z_DVAL_P(op1);
13091 d2 = (double)Z_LVAL_P(op2);
13092 goto mul_double;
13093 }
13094 }
13095
13096 ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13097}
13098
13099static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13100{
13101 USE_OPLINE
13102 zval *op1, *op2, *result;
13103
13104 op1 = EX_VAR(opline->op1.var);
13105 op2 = RT_CONSTANT(opline, opline->op2);
13106 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13107 /* pass */
13108 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13109 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13110 result = EX_VAR(opline->result.var);
13111 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
13112 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
13113 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
13114 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
13115 ZVAL_LONG(result, 0);
13116 } else {
13117 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
13118 }
13119 ZEND_VM_NEXT_OPCODE();
13120 }
13121 }
13122
13123 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13124}
13125
13126static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13127{
13128 USE_OPLINE
13129 zval *op1, *op2;
13130
13131 op1 = EX_VAR(opline->op1.var);
13132 op2 = RT_CONSTANT(opline, opline->op2);
13133 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13134 /* pass */
13135 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13136 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13137 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13138 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
13139 ZVAL_LONG(EX_VAR(opline->result.var),
13140 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
13141 ZEND_VM_NEXT_OPCODE();
13142 }
13143
13144 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13145}
13146
13147static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13148{
13149 USE_OPLINE
13150 zval *op1, *op2;
13151
13152 op1 = EX_VAR(opline->op1.var);
13153 op2 = RT_CONSTANT(opline, opline->op2);
13154 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13155 /* pass */
13156 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13157 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13158 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13159 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
13160 ZEND_VM_NEXT_OPCODE();
13161 }
13162
13163 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13164}
13165
13166static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13167{
13168 USE_OPLINE
13169 zval *op1, *op2;
13170 double d1, d2;
13171
13172 op1 = EX_VAR(opline->op1.var);
13173 op2 = RT_CONSTANT(opline, opline->op2);
13174 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13175 /* pass */
13176 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13177 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13178 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13179is_smaller_true:
13180 ZEND_VM_SMART_BRANCH_TRUE_NONE();
13181 } else {
13182is_smaller_false:
13183 ZEND_VM_SMART_BRANCH_FALSE_NONE();
13184 }
13185 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13186 d1 = (double)Z_LVAL_P(op1);
13187 d2 = Z_DVAL_P(op2);
13188 goto is_smaller_double;
13189 }
13190 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13191 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13192 d1 = Z_DVAL_P(op1);
13193 d2 = Z_DVAL_P(op2);
13194is_smaller_double:
13195 if (d1 < d2) {
13196 goto is_smaller_true;
13197 } else {
13198 goto is_smaller_false;
13199 }
13200 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13201 d1 = Z_DVAL_P(op1);
13202 d2 = (double)Z_LVAL_P(op2);
13203 goto is_smaller_double;
13204 }
13205 }
13206 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13207}
13208
13209static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13210{
13211 USE_OPLINE
13212 zval *op1, *op2;
13213 double d1, d2;
13214
13215 op1 = EX_VAR(opline->op1.var);
13216 op2 = RT_CONSTANT(opline, opline->op2);
13217 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13218 /* pass */
13219 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13220 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13221 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13222is_smaller_true:
13223 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13224 } else {
13225is_smaller_false:
13226 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13227 }
13228 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13229 d1 = (double)Z_LVAL_P(op1);
13230 d2 = Z_DVAL_P(op2);
13231 goto is_smaller_double;
13232 }
13233 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13234 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13235 d1 = Z_DVAL_P(op1);
13236 d2 = Z_DVAL_P(op2);
13237is_smaller_double:
13238 if (d1 < d2) {
13239 goto is_smaller_true;
13240 } else {
13241 goto is_smaller_false;
13242 }
13243 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13244 d1 = Z_DVAL_P(op1);
13245 d2 = (double)Z_LVAL_P(op2);
13246 goto is_smaller_double;
13247 }
13248 }
13249 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13250}
13251
13252static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13253{
13254 USE_OPLINE
13255 zval *op1, *op2;
13256 double d1, d2;
13257
13258 op1 = EX_VAR(opline->op1.var);
13259 op2 = RT_CONSTANT(opline, opline->op2);
13260 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13261 /* pass */
13262 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13263 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13264 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13265is_smaller_true:
13266 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13267 } else {
13268is_smaller_false:
13269 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13270 }
13271 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13272 d1 = (double)Z_LVAL_P(op1);
13273 d2 = Z_DVAL_P(op2);
13274 goto is_smaller_double;
13275 }
13276 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13277 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13278 d1 = Z_DVAL_P(op1);
13279 d2 = Z_DVAL_P(op2);
13280is_smaller_double:
13281 if (d1 < d2) {
13282 goto is_smaller_true;
13283 } else {
13284 goto is_smaller_false;
13285 }
13286 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13287 d1 = Z_DVAL_P(op1);
13288 d2 = (double)Z_LVAL_P(op2);
13289 goto is_smaller_double;
13290 }
13291 }
13292 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13293}
13294
13295static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13296{
13297 USE_OPLINE
13298 zval *op1, *op2;
13299 double d1, d2;
13300
13301 op1 = EX_VAR(opline->op1.var);
13302 op2 = RT_CONSTANT(opline, opline->op2);
13303 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13304 /* pass */
13305 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13306 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13307 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13308is_smaller_or_equal_true:
13309 ZEND_VM_SMART_BRANCH_TRUE_NONE();
13310 ZVAL_TRUE(EX_VAR(opline->result.var));
13311 ZEND_VM_NEXT_OPCODE();
13312 } else {
13313is_smaller_or_equal_false:
13314 ZEND_VM_SMART_BRANCH_FALSE_NONE();
13315 ZVAL_FALSE(EX_VAR(opline->result.var));
13316 ZEND_VM_NEXT_OPCODE();
13317 }
13318 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13319 d1 = (double)Z_LVAL_P(op1);
13320 d2 = Z_DVAL_P(op2);
13321 goto is_smaller_or_equal_double;
13322 }
13323 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13324 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13325 d1 = Z_DVAL_P(op1);
13326 d2 = Z_DVAL_P(op2);
13327is_smaller_or_equal_double:
13328 if (d1 <= d2) {
13329 goto is_smaller_or_equal_true;
13330 } else {
13331 goto is_smaller_or_equal_false;
13332 }
13333 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13334 d1 = Z_DVAL_P(op1);
13335 d2 = (double)Z_LVAL_P(op2);
13336 goto is_smaller_or_equal_double;
13337 }
13338 }
13339 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13340}
13341
13342static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13343{
13344 USE_OPLINE
13345 zval *op1, *op2;
13346 double d1, d2;
13347
13348 op1 = EX_VAR(opline->op1.var);
13349 op2 = RT_CONSTANT(opline, opline->op2);
13350 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13351 /* pass */
13352 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13353 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13354 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13355is_smaller_or_equal_true:
13356 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13357 ZVAL_TRUE(EX_VAR(opline->result.var));
13358 ZEND_VM_NEXT_OPCODE();
13359 } else {
13360is_smaller_or_equal_false:
13361 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13362 ZVAL_FALSE(EX_VAR(opline->result.var));
13363 ZEND_VM_NEXT_OPCODE();
13364 }
13365 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13366 d1 = (double)Z_LVAL_P(op1);
13367 d2 = Z_DVAL_P(op2);
13368 goto is_smaller_or_equal_double;
13369 }
13370 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13371 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13372 d1 = Z_DVAL_P(op1);
13373 d2 = Z_DVAL_P(op2);
13374is_smaller_or_equal_double:
13375 if (d1 <= d2) {
13376 goto is_smaller_or_equal_true;
13377 } else {
13378 goto is_smaller_or_equal_false;
13379 }
13380 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13381 d1 = Z_DVAL_P(op1);
13382 d2 = (double)Z_LVAL_P(op2);
13383 goto is_smaller_or_equal_double;
13384 }
13385 }
13386 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13387}
13388
13389static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13390{
13391 USE_OPLINE
13392 zval *op1, *op2;
13393 double d1, d2;
13394
13395 op1 = EX_VAR(opline->op1.var);
13396 op2 = RT_CONSTANT(opline, opline->op2);
13397 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13398 /* pass */
13399 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13400 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13401 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13402is_smaller_or_equal_true:
13403 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13404 ZVAL_TRUE(EX_VAR(opline->result.var));
13405 ZEND_VM_NEXT_OPCODE();
13406 } else {
13407is_smaller_or_equal_false:
13408 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13409 ZVAL_FALSE(EX_VAR(opline->result.var));
13410 ZEND_VM_NEXT_OPCODE();
13411 }
13412 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13413 d1 = (double)Z_LVAL_P(op1);
13414 d2 = Z_DVAL_P(op2);
13415 goto is_smaller_or_equal_double;
13416 }
13417 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13418 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13419 d1 = Z_DVAL_P(op1);
13420 d2 = Z_DVAL_P(op2);
13421is_smaller_or_equal_double:
13422 if (d1 <= d2) {
13423 goto is_smaller_or_equal_true;
13424 } else {
13425 goto is_smaller_or_equal_false;
13426 }
13427 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13428 d1 = Z_DVAL_P(op1);
13429 d2 = (double)Z_LVAL_P(op2);
13430 goto is_smaller_or_equal_double;
13431 }
13432 }
13433 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13434}
13435
13436static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13437{
13438 USE_OPLINE
13439 zval *op1, *op2;
13440
13441 op1 = EX_VAR(opline->op1.var);
13442 op2 = RT_CONSTANT(opline, opline->op2);
13443 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13444 /* pass */
13445 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13446 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13447 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
13448 ZEND_VM_NEXT_OPCODE();
13449 }
13450
13451 ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13452}
13453
13454static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13455{
13456 USE_OPLINE
13457 zval *op1, *op2;
13458
13459 op1 = EX_VAR(opline->op1.var);
13460 op2 = RT_CONSTANT(opline, opline->op2);
13461 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13462 /* pass */
13463 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13464 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13465 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
13466 ZEND_VM_NEXT_OPCODE();
13467 }
13468
13469 ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13470}
13471
13472static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13473{
13474 USE_OPLINE
13475 zval *op1, *op2;
13476
13477 op1 = EX_VAR(opline->op1.var);
13478 op2 = RT_CONSTANT(opline, opline->op2);
13479 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13480 /* pass */
13481 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13482 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13483 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
13484 ZEND_VM_NEXT_OPCODE();
13485 }
13486
13487 ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13488}
13489
13490static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13491{
13492 USE_OPLINE
13493 zval *container;
13494
13495 SAVE_OPLINE();
13496 container = EX_VAR(opline->op1.var);
13497 zend_fetch_dimension_address_LIST_r(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
13498
13499 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
13500}
13501
13502static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13503{
13504 USE_OPLINE
13505 zval *op, *jump_zv;
13506 HashTable *jumptable;
13507
13508 op = EX_VAR(opline->op1.var);
13509
13510 if (Z_TYPE_P(op) != IS_LONG) {
13511 ZVAL_DEREF(op);
13512 if (Z_TYPE_P(op) != IS_LONG) {
13513 /* Wrong type, fall back to ZEND_CASE chain */
13514 ZEND_VM_NEXT_OPCODE();
13515 }
13516 }
13517
13518 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13519 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13520 if (jump_zv != NULL) {
13521 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13522 ZEND_VM_CONTINUE();
13523 } else {
13524 /* default */
13525 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13526 ZEND_VM_CONTINUE();
13527 }
13528}
13529
13530static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13531{
13532 USE_OPLINE
13533 zval *op, *jump_zv;
13534 HashTable *jumptable;
13535
13536 op = EX_VAR(opline->op1.var);
13537
13538 if (Z_TYPE_P(op) != IS_STRING) {
13539 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13540 /* Wrong type, fall back to ZEND_CASE chain */
13541 ZEND_VM_NEXT_OPCODE();
13542 } else {
13543 ZVAL_DEREF(op);
13544 if (Z_TYPE_P(op) != IS_STRING) {
13545 /* Wrong type, fall back to ZEND_CASE chain */
13546 ZEND_VM_NEXT_OPCODE();
13547 }
13548 }
13549 }
13550
13551 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13552 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13553 if (jump_zv != NULL) {
13554 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13555 ZEND_VM_CONTINUE();
13556 } else {
13557 /* default */
13558 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13559 ZEND_VM_CONTINUE();
13560 }
13561}
13562
13563static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13564{
13565 USE_OPLINE
13566 zval *op, *jump_zv;
13567 HashTable *jumptable;
13568
13569 op = EX_VAR(opline->op1.var);
13570 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13571
13572match_try_again:
13573 if (Z_TYPE_P(op) == IS_LONG) {
13574 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13575 } else if (Z_TYPE_P(op) == IS_STRING) {
13576 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13577 } else if (Z_TYPE_P(op) == IS_REFERENCE) {
13578 op = Z_REFVAL_P(op);
13579 goto match_try_again;
13580 } else {
13581 if (UNEXPECTED(((IS_TMP_VAR|IS_VAR|IS_CV) & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
13582 SAVE_OPLINE();
13583 op = ZVAL_UNDEFINED_OP1();
13584 if (UNEXPECTED(EG(exception))) {
13585 HANDLE_EXCEPTION();
13586 }
13587 goto match_try_again;
13588 }
13589
13590 goto default_branch;
13591 }
13592
13593 if (jump_zv != NULL) {
13594 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13595 ZEND_VM_CONTINUE();
13596 } else {
13597default_branch:
13598 /* default */
13599 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13600 ZEND_VM_CONTINUE();
13601 }
13602}
13603
13604static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13605{
13606 USE_OPLINE
13607 zval *op1, *op2, *result;
13608
13609 op1 = EX_VAR(opline->op1.var);
13610 op2 = RT_CONSTANT(opline, opline->op2);
13611 result = EX_VAR(opline->result.var);
13612 ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
13613 ZEND_VM_NEXT_OPCODE();
13614}
13615
13616static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13617{
13618 USE_OPLINE
13619 zval *op1, *op2, *result;
13620
13621 op1 = EX_VAR(opline->op1.var);
13622 op2 = RT_CONSTANT(opline, opline->op2);
13623 result = EX_VAR(opline->result.var);
13624 fast_long_add_function(result, op1, op2);
13625 ZEND_VM_NEXT_OPCODE();
13626}
13627
13628static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13629{
13630 USE_OPLINE
13631 zval *op1, *op2, *result;
13632
13633 op1 = EX_VAR(opline->op1.var);
13634 op2 = RT_CONSTANT(opline, opline->op2);
13635 result = EX_VAR(opline->result.var);
13636 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
13637 ZEND_VM_NEXT_OPCODE();
13638}
13639
13640static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13641{
13642 USE_OPLINE
13643 zval *op1, *op2, *result;
13644
13645 op1 = EX_VAR(opline->op1.var);
13646 op2 = RT_CONSTANT(opline, opline->op2);
13647 result = EX_VAR(opline->result.var);
13648 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
13649 ZEND_VM_NEXT_OPCODE();
13650}
13651
13652static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13653{
13654 USE_OPLINE
13655 zval *op1, *op2, *result;
13656
13657 op1 = EX_VAR(opline->op1.var);
13658 op2 = RT_CONSTANT(opline, opline->op2);
13659 result = EX_VAR(opline->result.var);
13660 fast_long_sub_function(result, op1, op2);
13661 ZEND_VM_NEXT_OPCODE();
13662}
13663
13664static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13665{
13666 USE_OPLINE
13667 zval *op1, *op2, *result;
13668
13669 op1 = EX_VAR(opline->op1.var);
13670 op2 = RT_CONSTANT(opline, opline->op2);
13671 result = EX_VAR(opline->result.var);
13672 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
13673 ZEND_VM_NEXT_OPCODE();
13674}
13675
13676static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13677{
13678 USE_OPLINE
13679 zval *op1, *op2, *result;
13680
13681 op1 = EX_VAR(opline->op1.var);
13682 op2 = RT_CONSTANT(opline, opline->op2);
13683 result = EX_VAR(opline->result.var);
13684 ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
13685 ZEND_VM_NEXT_OPCODE();
13686}
13687
13688static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13689{
13690 USE_OPLINE
13691 zval *op1, *op2, *result;
13692 zend_long overflow;
13693
13694 op1 = EX_VAR(opline->op1.var);
13695 op2 = RT_CONSTANT(opline, opline->op2);
13696 result = EX_VAR(opline->result.var);
13697 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13698 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13699 ZEND_VM_NEXT_OPCODE();
13700}
13701
13702static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13703{
13704 USE_OPLINE
13705 zval *op1, *op2, *result;
13706
13707 op1 = EX_VAR(opline->op1.var);
13708 op2 = RT_CONSTANT(opline, opline->op2);
13709 result = EX_VAR(opline->result.var);
13710 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
13711 ZEND_VM_NEXT_OPCODE();
13712}
13713
13714static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13715{
13716 USE_OPLINE
13717 zval *op1, *op2;
13718 bool result;
13719
13720 op1 = EX_VAR(opline->op1.var);
13721 op2 = RT_CONSTANT(opline, opline->op2);
13722 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13723 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13724}
13725
13726static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13727{
13728 USE_OPLINE
13729 zval *op1, *op2;
13730 bool result;
13731
13732 op1 = EX_VAR(opline->op1.var);
13733 op2 = RT_CONSTANT(opline, opline->op2);
13734 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13735 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13736}
13737
13738static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13739{
13740 USE_OPLINE
13741 zval *op1, *op2;
13742 bool result;
13743
13744 op1 = EX_VAR(opline->op1.var);
13745 op2 = RT_CONSTANT(opline, opline->op2);
13746 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13747 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13748}
13749
13750static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13751{
13752 USE_OPLINE
13753 zval *op1, *op2;
13754 bool result;
13755
13756 op1 = EX_VAR(opline->op1.var);
13757 op2 = RT_CONSTANT(opline, opline->op2);
13758 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13759 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13760}
13761
13762static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13763{
13764 USE_OPLINE
13765 zval *op1, *op2;
13766 bool result;
13767
13768 op1 = EX_VAR(opline->op1.var);
13769 op2 = RT_CONSTANT(opline, opline->op2);
13770 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13771 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13772}
13773
13774static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13775{
13776 USE_OPLINE
13777 zval *op1, *op2;
13778 bool result;
13779
13780 op1 = EX_VAR(opline->op1.var);
13781 op2 = RT_CONSTANT(opline, opline->op2);
13782 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13783 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13784}
13785
13786static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13787{
13788 USE_OPLINE
13789 zval *op1, *op2;
13790 bool result;
13791
13792 op1 = EX_VAR(opline->op1.var);
13793 op2 = RT_CONSTANT(opline, opline->op2);
13794 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13795 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13796}
13797
13798static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13799{
13800 USE_OPLINE
13801 zval *op1, *op2;
13802 bool result;
13803
13804 op1 = EX_VAR(opline->op1.var);
13805 op2 = RT_CONSTANT(opline, opline->op2);
13806 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13807 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13808}
13809
13810static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13811{
13812 USE_OPLINE
13813 zval *op1, *op2;
13814 bool result;
13815
13816 op1 = EX_VAR(opline->op1.var);
13817 op2 = RT_CONSTANT(opline, opline->op2);
13818 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13819 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13820}
13821
13822static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13823{
13824 USE_OPLINE
13825 zval *op1, *op2;
13826 bool result;
13827
13828 op1 = EX_VAR(opline->op1.var);
13829 op2 = RT_CONSTANT(opline, opline->op2);
13830 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13831 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13832}
13833
13834static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13835{
13836 USE_OPLINE
13837 zval *op1, *op2;
13838 bool result;
13839
13840 op1 = EX_VAR(opline->op1.var);
13841 op2 = RT_CONSTANT(opline, opline->op2);
13842 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13843 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13844}
13845
13846static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13847{
13848 USE_OPLINE
13849 zval *op1, *op2;
13850 bool result;
13851
13852 op1 = EX_VAR(opline->op1.var);
13853 op2 = RT_CONSTANT(opline, opline->op2);
13854 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13855 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13856}
13857
13858static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13859{
13860 USE_OPLINE
13861 zval *op1, *op2;
13862 bool result;
13863
13864 op1 = EX_VAR(opline->op1.var);
13865 op2 = RT_CONSTANT(opline, opline->op2);
13866 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13867 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13868}
13869
13870static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13871{
13872 USE_OPLINE
13873 zval *op1, *op2;
13874 bool result;
13875
13876 op1 = EX_VAR(opline->op1.var);
13877 op2 = RT_CONSTANT(opline, opline->op2);
13878 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13879 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13880}
13881
13882static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13883{
13884 USE_OPLINE
13885 zval *op1, *op2;
13886 bool result;
13887
13888 op1 = EX_VAR(opline->op1.var);
13889 op2 = RT_CONSTANT(opline, opline->op2);
13890 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13891 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13892}
13893
13894static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13895{
13896 USE_OPLINE
13897 zval *op1, *op2;
13898 bool result;
13899
13900 op1 = EX_VAR(opline->op1.var);
13901 op2 = RT_CONSTANT(opline, opline->op2);
13902 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13903 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13904}
13905
13906static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13907{
13908 USE_OPLINE
13909 zval *op1, *op2;
13910 bool result;
13911
13912 op1 = EX_VAR(opline->op1.var);
13913 op2 = RT_CONSTANT(opline, opline->op2);
13914 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13915 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13916}
13917
13918static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13919{
13920 USE_OPLINE
13921 zval *op1, *op2;
13922 bool result;
13923
13924 op1 = EX_VAR(opline->op1.var);
13925 op2 = RT_CONSTANT(opline, opline->op2);
13926 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13927 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13928}
13929
13930static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13931{
13932 USE_OPLINE
13933 zval *op1, *op2;
13934 bool result;
13935
13936 op1 = EX_VAR(opline->op1.var);
13937 op2 = RT_CONSTANT(opline, opline->op2);
13938 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13939 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13940}
13941
13942static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13943{
13944 USE_OPLINE
13945 zval *op1, *op2;
13946 bool result;
13947
13948 op1 = EX_VAR(opline->op1.var);
13949 op2 = RT_CONSTANT(opline, opline->op2);
13950 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13951 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13952}
13953
13954static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13955{
13956 USE_OPLINE
13957 zval *op1, *op2;
13958 bool result;
13959
13960 op1 = EX_VAR(opline->op1.var);
13961 op2 = RT_CONSTANT(opline, opline->op2);
13962 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13963 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13964}
13965
13966static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13967{
13968 USE_OPLINE
13969 zval *op1, *op2;
13970 bool result;
13971
13972 op1 = EX_VAR(opline->op1.var);
13973 op2 = RT_CONSTANT(opline, opline->op2);
13974 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13975 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13976}
13977
13978static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13979{
13980 USE_OPLINE
13981 zval *op1, *op2;
13982 bool result;
13983
13984 op1 = EX_VAR(opline->op1.var);
13985 op2 = RT_CONSTANT(opline, opline->op2);
13986 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13987 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13988}
13989
13990static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13991{
13992 USE_OPLINE
13993 zval *op1, *op2;
13994 bool result;
13995
13996 op1 = EX_VAR(opline->op1.var);
13997 op2 = RT_CONSTANT(opline, opline->op2);
13998 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13999 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14000}
14001
14002static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14003{
14004 USE_OPLINE
14005 zval *op1, *op2, *result;
14006 double d1, d2;
14007
14008 op1 = EX_VAR(opline->op1.var);
14009 op2 = EX_VAR(opline->op2.var);
14010 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14011 /* pass */
14012 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14013 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14014 result = EX_VAR(opline->result.var);
14015 fast_long_add_function(result, op1, op2);
14016 ZEND_VM_NEXT_OPCODE();
14017 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14018 d1 = (double)Z_LVAL_P(op1);
14019 d2 = Z_DVAL_P(op2);
14020 goto add_double;
14021 }
14022 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14023 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14024 d1 = Z_DVAL_P(op1);
14025 d2 = Z_DVAL_P(op2);
14026add_double:
14027 result = EX_VAR(opline->result.var);
14028 ZVAL_DOUBLE(result, d1 + d2);
14029 ZEND_VM_NEXT_OPCODE();
14030 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14031 d1 = Z_DVAL_P(op1);
14032 d2 = (double)Z_LVAL_P(op2);
14033 goto add_double;
14034 }
14035 }
14036
14037 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14038}
14039
14040static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14041{
14042 USE_OPLINE
14043 zval *op1, *op2, *result;
14044 double d1, d2;
14045
14046 op1 = EX_VAR(opline->op1.var);
14047 op2 = EX_VAR(opline->op2.var);
14048 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14049 /* pass */
14050 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14051 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14052 result = EX_VAR(opline->result.var);
14053 fast_long_sub_function(result, op1, op2);
14054 ZEND_VM_NEXT_OPCODE();
14055 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14056 d1 = (double)Z_LVAL_P(op1);
14057 d2 = Z_DVAL_P(op2);
14058 goto sub_double;
14059 }
14060 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14061 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14062 d1 = Z_DVAL_P(op1);
14063 d2 = Z_DVAL_P(op2);
14064sub_double:
14065 result = EX_VAR(opline->result.var);
14066 ZVAL_DOUBLE(result, d1 - d2);
14067 ZEND_VM_NEXT_OPCODE();
14068 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14069 d1 = Z_DVAL_P(op1);
14070 d2 = (double)Z_LVAL_P(op2);
14071 goto sub_double;
14072 }
14073 }
14074
14075 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14076}
14077
14078static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14079{
14080 USE_OPLINE
14081 zval *op1, *op2, *result;
14082 double d1, d2;
14083
14084 op1 = EX_VAR(opline->op1.var);
14085 op2 = EX_VAR(opline->op2.var);
14086 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14087 /* pass */
14088 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14089 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14090 zend_long overflow;
14091
14092 result = EX_VAR(opline->result.var);
14093 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
14094 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
14095 ZEND_VM_NEXT_OPCODE();
14096 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14097 d1 = (double)Z_LVAL_P(op1);
14098 d2 = Z_DVAL_P(op2);
14099 goto mul_double;
14100 }
14101 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14102 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14103 d1 = Z_DVAL_P(op1);
14104 d2 = Z_DVAL_P(op2);
14105mul_double:
14106 result = EX_VAR(opline->result.var);
14107 ZVAL_DOUBLE(result, d1 * d2);
14108 ZEND_VM_NEXT_OPCODE();
14109 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14110 d1 = Z_DVAL_P(op1);
14111 d2 = (double)Z_LVAL_P(op2);
14112 goto mul_double;
14113 }
14114 }
14115
14116 ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14117}
14118
14119static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14120{
14121 USE_OPLINE
14122 zval *op1, *op2, *result;
14123
14124 op1 = EX_VAR(opline->op1.var);
14125 op2 = EX_VAR(opline->op2.var);
14126 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14127 /* pass */
14128 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14129 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14130 result = EX_VAR(opline->result.var);
14131 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
14132 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
14133 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
14134 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
14135 ZVAL_LONG(result, 0);
14136 } else {
14137 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
14138 }
14139 ZEND_VM_NEXT_OPCODE();
14140 }
14141 }
14142
14143 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14144}
14145
14146static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14147{
14148 USE_OPLINE
14149 zval *op1, *op2;
14150
14151 op1 = EX_VAR(opline->op1.var);
14152 op2 = EX_VAR(opline->op2.var);
14153 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14154 /* pass */
14155 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14156 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
14157 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
14158 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
14159 ZVAL_LONG(EX_VAR(opline->result.var),
14160 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
14161 ZEND_VM_NEXT_OPCODE();
14162 }
14163
14164 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14165}
14166
14167static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14168{
14169 USE_OPLINE
14170 zval *op1, *op2;
14171
14172 op1 = EX_VAR(opline->op1.var);
14173 op2 = EX_VAR(opline->op2.var);
14174 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14175 /* pass */
14176 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14177 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
14178 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
14179 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
14180 ZEND_VM_NEXT_OPCODE();
14181 }
14182
14183 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14184}
14185
14186static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14187{
14188 USE_OPLINE
14189 zval *op1, *op2;
14190 double d1, d2;
14191
14192 op1 = EX_VAR(opline->op1.var);
14193 op2 = EX_VAR(opline->op2.var);
14194 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14195 /* pass */
14196 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14197 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14198 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14199is_smaller_true:
14200 ZEND_VM_SMART_BRANCH_TRUE_NONE();
14201 } else {
14202is_smaller_false:
14203 ZEND_VM_SMART_BRANCH_FALSE_NONE();
14204 }
14205 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14206 d1 = (double)Z_LVAL_P(op1);
14207 d2 = Z_DVAL_P(op2);
14208 goto is_smaller_double;
14209 }
14210 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14211 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14212 d1 = Z_DVAL_P(op1);
14213 d2 = Z_DVAL_P(op2);
14214is_smaller_double:
14215 if (d1 < d2) {
14216 goto is_smaller_true;
14217 } else {
14218 goto is_smaller_false;
14219 }
14220 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14221 d1 = Z_DVAL_P(op1);
14222 d2 = (double)Z_LVAL_P(op2);
14223 goto is_smaller_double;
14224 }
14225 }
14226 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14227}
14228
14229static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14230{
14231 USE_OPLINE
14232 zval *op1, *op2;
14233 double d1, d2;
14234
14235 op1 = EX_VAR(opline->op1.var);
14236 op2 = EX_VAR(opline->op2.var);
14237 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14238 /* pass */
14239 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14240 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14241 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14242is_smaller_true:
14243 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
14244 } else {
14245is_smaller_false:
14246 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
14247 }
14248 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14249 d1 = (double)Z_LVAL_P(op1);
14250 d2 = Z_DVAL_P(op2);
14251 goto is_smaller_double;
14252 }
14253 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14254 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14255 d1 = Z_DVAL_P(op1);
14256 d2 = Z_DVAL_P(op2);
14257is_smaller_double:
14258 if (d1 < d2) {
14259 goto is_smaller_true;
14260 } else {
14261 goto is_smaller_false;
14262 }
14263 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14264 d1 = Z_DVAL_P(op1);
14265 d2 = (double)Z_LVAL_P(op2);
14266 goto is_smaller_double;
14267 }
14268 }
14269 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14270}
14271
14272static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14273{
14274 USE_OPLINE
14275 zval *op1, *op2;
14276 double d1, d2;
14277
14278 op1 = EX_VAR(opline->op1.var);
14279 op2 = EX_VAR(opline->op2.var);
14280 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14281 /* pass */
14282 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14283 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14284 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14285is_smaller_true:
14286 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
14287 } else {
14288is_smaller_false:
14289 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
14290 }
14291 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14292 d1 = (double)Z_LVAL_P(op1);
14293 d2 = Z_DVAL_P(op2);
14294 goto is_smaller_double;
14295 }
14296 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14297 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14298 d1 = Z_DVAL_P(op1);
14299 d2 = Z_DVAL_P(op2);
14300is_smaller_double:
14301 if (d1 < d2) {
14302 goto is_smaller_true;
14303 } else {
14304 goto is_smaller_false;
14305 }
14306 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14307 d1 = Z_DVAL_P(op1);
14308 d2 = (double)Z_LVAL_P(op2);
14309 goto is_smaller_double;
14310 }
14311 }
14312 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14313}
14314
14315static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14316{
14317 USE_OPLINE
14318 zval *op1, *op2;
14319 double d1, d2;
14320
14321 op1 = EX_VAR(opline->op1.var);
14322 op2 = EX_VAR(opline->op2.var);
14323 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14324 /* pass */
14325 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14326 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14327 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14328is_smaller_or_equal_true:
14329 ZEND_VM_SMART_BRANCH_TRUE_NONE();
14330 ZVAL_TRUE(EX_VAR(opline->result.var));
14331 ZEND_VM_NEXT_OPCODE();
14332 } else {
14333is_smaller_or_equal_false:
14334 ZEND_VM_SMART_BRANCH_FALSE_NONE();
14335 ZVAL_FALSE(EX_VAR(opline->result.var));
14336 ZEND_VM_NEXT_OPCODE();
14337 }
14338 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14339 d1 = (double)Z_LVAL_P(op1);
14340 d2 = Z_DVAL_P(op2);
14341 goto is_smaller_or_equal_double;
14342 }
14343 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14344 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14345 d1 = Z_DVAL_P(op1);
14346 d2 = Z_DVAL_P(op2);
14347is_smaller_or_equal_double:
14348 if (d1 <= d2) {
14349 goto is_smaller_or_equal_true;
14350 } else {
14351 goto is_smaller_or_equal_false;
14352 }
14353 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14354 d1 = Z_DVAL_P(op1);
14355 d2 = (double)Z_LVAL_P(op2);
14356 goto is_smaller_or_equal_double;
14357 }
14358 }
14359 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14360}
14361
14362static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14363{
14364 USE_OPLINE
14365 zval *op1, *op2;
14366 double d1, d2;
14367
14368 op1 = EX_VAR(opline->op1.var);
14369 op2 = EX_VAR(opline->op2.var);
14370 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14371 /* pass */
14372 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14373 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14374 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14375is_smaller_or_equal_true:
14376 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
14377 ZVAL_TRUE(EX_VAR(opline->result.var));
14378 ZEND_VM_NEXT_OPCODE();
14379 } else {
14380is_smaller_or_equal_false:
14381 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
14382 ZVAL_FALSE(EX_VAR(opline->result.var));
14383 ZEND_VM_NEXT_OPCODE();
14384 }
14385 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14386 d1 = (double)Z_LVAL_P(op1);
14387 d2 = Z_DVAL_P(op2);
14388 goto is_smaller_or_equal_double;
14389 }
14390 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14391 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14392 d1 = Z_DVAL_P(op1);
14393 d2 = Z_DVAL_P(op2);
14394is_smaller_or_equal_double:
14395 if (d1 <= d2) {
14396 goto is_smaller_or_equal_true;
14397 } else {
14398 goto is_smaller_or_equal_false;
14399 }
14400 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14401 d1 = Z_DVAL_P(op1);
14402 d2 = (double)Z_LVAL_P(op2);
14403 goto is_smaller_or_equal_double;
14404 }
14405 }
14406 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14407}
14408
14409static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14410{
14411 USE_OPLINE
14412 zval *op1, *op2;
14413 double d1, d2;
14414
14415 op1 = EX_VAR(opline->op1.var);
14416 op2 = EX_VAR(opline->op2.var);
14417 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14418 /* pass */
14419 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14420 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14421 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14422is_smaller_or_equal_true:
14423 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
14424 ZVAL_TRUE(EX_VAR(opline->result.var));
14425 ZEND_VM_NEXT_OPCODE();
14426 } else {
14427is_smaller_or_equal_false:
14428 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
14429 ZVAL_FALSE(EX_VAR(opline->result.var));
14430 ZEND_VM_NEXT_OPCODE();
14431 }
14432 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14433 d1 = (double)Z_LVAL_P(op1);
14434 d2 = Z_DVAL_P(op2);
14435 goto is_smaller_or_equal_double;
14436 }
14437 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14438 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14439 d1 = Z_DVAL_P(op1);
14440 d2 = Z_DVAL_P(op2);
14441is_smaller_or_equal_double:
14442 if (d1 <= d2) {
14443 goto is_smaller_or_equal_true;
14444 } else {
14445 goto is_smaller_or_equal_false;
14446 }
14447 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14448 d1 = Z_DVAL_P(op1);
14449 d2 = (double)Z_LVAL_P(op2);
14450 goto is_smaller_or_equal_double;
14451 }
14452 }
14453 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14454}
14455
14456static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14457{
14458 USE_OPLINE
14459 zval *op1, *op2;
14460
14461 op1 = EX_VAR(opline->op1.var);
14462 op2 = EX_VAR(opline->op2.var);
14463 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14464 /* pass */
14465 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14466 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14467 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
14468 ZEND_VM_NEXT_OPCODE();
14469 }
14470
14471 ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14472}
14473
14474static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14475{
14476 USE_OPLINE
14477 zval *op1, *op2;
14478
14479 op1 = EX_VAR(opline->op1.var);
14480 op2 = EX_VAR(opline->op2.var);
14481 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14482 /* pass */
14483 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14484 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14485 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
14486 ZEND_VM_NEXT_OPCODE();
14487 }
14488
14489 ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14490}
14491
14492static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14493{
14494 USE_OPLINE
14495 zval *op1, *op2;
14496
14497 op1 = EX_VAR(opline->op1.var);
14498 op2 = EX_VAR(opline->op2.var);
14499 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14500 /* pass */
14501 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14502 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14503 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
14504 ZEND_VM_NEXT_OPCODE();
14505 }
14506
14507 ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14508}
14509
14510static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14511{
14512 USE_OPLINE
14513 zval *op1, *op2, *result;
14514
14515 op1 = EX_VAR(opline->op1.var);
14516 op2 = EX_VAR(opline->op2.var);
14517 result = EX_VAR(opline->result.var);
14518 ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
14519 ZEND_VM_NEXT_OPCODE();
14520}
14521
14522static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14523{
14524 USE_OPLINE
14525 zval *op1, *op2, *result;
14526
14527 op1 = EX_VAR(opline->op1.var);
14528 op2 = EX_VAR(opline->op2.var);
14529 result = EX_VAR(opline->result.var);
14530 fast_long_add_function(result, op1, op2);
14531 ZEND_VM_NEXT_OPCODE();
14532}
14533
14534static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14535{
14536 USE_OPLINE
14537 zval *op1, *op2, *result;
14538
14539 op1 = EX_VAR(opline->op1.var);
14540 op2 = EX_VAR(opline->op2.var);
14541 result = EX_VAR(opline->result.var);
14542 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
14543 ZEND_VM_NEXT_OPCODE();
14544}
14545
14546static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14547{
14548 USE_OPLINE
14549 zval *op1, *op2, *result;
14550
14551 op1 = EX_VAR(opline->op1.var);
14552 op2 = EX_VAR(opline->op2.var);
14553 result = EX_VAR(opline->result.var);
14554 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
14555 ZEND_VM_NEXT_OPCODE();
14556}
14557
14558static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14559{
14560 USE_OPLINE
14561 zval *op1, *op2, *result;
14562
14563 op1 = EX_VAR(opline->op1.var);
14564 op2 = EX_VAR(opline->op2.var);
14565 result = EX_VAR(opline->result.var);
14566 fast_long_sub_function(result, op1, op2);
14567 ZEND_VM_NEXT_OPCODE();
14568}
14569
14570static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14571{
14572 USE_OPLINE
14573 zval *op1, *op2, *result;
14574
14575 op1 = EX_VAR(opline->op1.var);
14576 op2 = EX_VAR(opline->op2.var);
14577 result = EX_VAR(opline->result.var);
14578 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
14579 ZEND_VM_NEXT_OPCODE();
14580}
14581
14582static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14583{
14584 USE_OPLINE
14585 zval *op1, *op2, *result;
14586
14587 op1 = EX_VAR(opline->op1.var);
14588 op2 = EX_VAR(opline->op2.var);
14589 result = EX_VAR(opline->result.var);
14590 ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
14591 ZEND_VM_NEXT_OPCODE();
14592}
14593
14594static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14595{
14596 USE_OPLINE
14597 zval *op1, *op2, *result;
14598 zend_long overflow;
14599
14600 op1 = EX_VAR(opline->op1.var);
14601 op2 = EX_VAR(opline->op2.var);
14602 result = EX_VAR(opline->result.var);
14603 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
14604 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
14605 ZEND_VM_NEXT_OPCODE();
14606}
14607
14608static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14609{
14610 USE_OPLINE
14611 zval *op1, *op2, *result;
14612
14613 op1 = EX_VAR(opline->op1.var);
14614 op2 = EX_VAR(opline->op2.var);
14615 result = EX_VAR(opline->result.var);
14616 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
14617 ZEND_VM_NEXT_OPCODE();
14618}
14619
14620static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14621{
14622 USE_OPLINE
14623 zval *op1, *op2;
14624 bool result;
14625
14626 op1 = EX_VAR(opline->op1.var);
14627 op2 = EX_VAR(opline->op2.var);
14628 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14629 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14630}
14631
14632static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14633{
14634 USE_OPLINE
14635 zval *op1, *op2;
14636 bool result;
14637
14638 op1 = EX_VAR(opline->op1.var);
14639 op2 = EX_VAR(opline->op2.var);
14640 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14641 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14642}
14643
14644static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14645{
14646 USE_OPLINE
14647 zval *op1, *op2;
14648 bool result;
14649
14650 op1 = EX_VAR(opline->op1.var);
14651 op2 = EX_VAR(opline->op2.var);
14652 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14653 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14654}
14655
14656static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14657{
14658 USE_OPLINE
14659 zval *op1, *op2;
14660 bool result;
14661
14662 op1 = EX_VAR(opline->op1.var);
14663 op2 = EX_VAR(opline->op2.var);
14664 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14665 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14666}
14667
14668static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14669{
14670 USE_OPLINE
14671 zval *op1, *op2;
14672 bool result;
14673
14674 op1 = EX_VAR(opline->op1.var);
14675 op2 = EX_VAR(opline->op2.var);
14676 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14677 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14678}
14679
14680static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14681{
14682 USE_OPLINE
14683 zval *op1, *op2;
14684 bool result;
14685
14686 op1 = EX_VAR(opline->op1.var);
14687 op2 = EX_VAR(opline->op2.var);
14688 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14689 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14690}
14691
14692static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14693{
14694 USE_OPLINE
14695 zval *op1, *op2;
14696 bool result;
14697
14698 op1 = EX_VAR(opline->op1.var);
14699 op2 = EX_VAR(opline->op2.var);
14700 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14701 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14702}
14703
14704static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14705{
14706 USE_OPLINE
14707 zval *op1, *op2;
14708 bool result;
14709
14710 op1 = EX_VAR(opline->op1.var);
14711 op2 = EX_VAR(opline->op2.var);
14712 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14713 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14714}
14715
14716static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14717{
14718 USE_OPLINE
14719 zval *op1, *op2;
14720 bool result;
14721
14722 op1 = EX_VAR(opline->op1.var);
14723 op2 = EX_VAR(opline->op2.var);
14724 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14725 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14726}
14727
14728static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14729{
14730 USE_OPLINE
14731 zval *op1, *op2;
14732 bool result;
14733
14734 op1 = EX_VAR(opline->op1.var);
14735 op2 = EX_VAR(opline->op2.var);
14736 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14737 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14738}
14739
14740static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14741{
14742 USE_OPLINE
14743 zval *op1, *op2;
14744 bool result;
14745
14746 op1 = EX_VAR(opline->op1.var);
14747 op2 = EX_VAR(opline->op2.var);
14748 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14749 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14750}
14751
14752static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14753{
14754 USE_OPLINE
14755 zval *op1, *op2;
14756 bool result;
14757
14758 op1 = EX_VAR(opline->op1.var);
14759 op2 = EX_VAR(opline->op2.var);
14760 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14761 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14762}
14763
14764static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14765{
14766 USE_OPLINE
14767 zval *op1, *op2;
14768 bool result;
14769
14770 op1 = EX_VAR(opline->op1.var);
14771 op2 = EX_VAR(opline->op2.var);
14772 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14773 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14774}
14775
14776static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14777{
14778 USE_OPLINE
14779 zval *op1, *op2;
14780 bool result;
14781
14782 op1 = EX_VAR(opline->op1.var);
14783 op2 = EX_VAR(opline->op2.var);
14784 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14785 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14786}
14787
14788static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14789{
14790 USE_OPLINE
14791 zval *op1, *op2;
14792 bool result;
14793
14794 op1 = EX_VAR(opline->op1.var);
14795 op2 = EX_VAR(opline->op2.var);
14796 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14797 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14798}
14799
14800static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14801{
14802 USE_OPLINE
14803 zval *op1, *op2;
14804 bool result;
14805
14806 op1 = EX_VAR(opline->op1.var);
14807 op2 = EX_VAR(opline->op2.var);
14808 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14809 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14810}
14811
14812static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14813{
14814 USE_OPLINE
14815 zval *op1, *op2;
14816 bool result;
14817
14818 op1 = EX_VAR(opline->op1.var);
14819 op2 = EX_VAR(opline->op2.var);
14820 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14821 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14822}
14823
14824static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14825{
14826 USE_OPLINE
14827 zval *op1, *op2;
14828 bool result;
14829
14830 op1 = EX_VAR(opline->op1.var);
14831 op2 = EX_VAR(opline->op2.var);
14832 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14833 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14834}
14835
14836static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14837{
14838 USE_OPLINE
14839 zval *op1, *op2;
14840 bool result;
14841
14842 op1 = EX_VAR(opline->op1.var);
14843 op2 = EX_VAR(opline->op2.var);
14844 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14845 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14846}
14847
14848static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14849{
14850 USE_OPLINE
14851 zval *op1, *op2;
14852 bool result;
14853
14854 op1 = EX_VAR(opline->op1.var);
14855 op2 = EX_VAR(opline->op2.var);
14856 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14857 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14858}
14859
14860static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14861{
14862 USE_OPLINE
14863 zval *op1, *op2;
14864 bool result;
14865
14866 op1 = EX_VAR(opline->op1.var);
14867 op2 = EX_VAR(opline->op2.var);
14868 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14869 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14870}
14871
14872static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14873{
14874 USE_OPLINE
14875 zval *op1, *op2;
14876 bool result;
14877
14878 op1 = EX_VAR(opline->op1.var);
14879 op2 = EX_VAR(opline->op2.var);
14880 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14881 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14882}
14883
14884static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14885{
14886 USE_OPLINE
14887 zval *op1, *op2;
14888 bool result;
14889
14890 op1 = EX_VAR(opline->op1.var);
14891 op2 = EX_VAR(opline->op2.var);
14892 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14893 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14894}
14895
14896static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14897{
14898 USE_OPLINE
14899 zval *op1, *op2;
14900 bool result;
14901
14902 op1 = EX_VAR(opline->op1.var);
14903 op2 = EX_VAR(opline->op2.var);
14904 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14905 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14906}
14907
14908static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14909{
14910 USE_OPLINE
14911 zval *container;
14912
14913 SAVE_OPLINE();
14914 container = EX_VAR(opline->op1.var);
14915 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);
14916 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
14917 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14918}
14919
14920static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14921{
14922 USE_OPLINE
14923 zval *op;
14924
14925 SAVE_OPLINE();
14926 op = EX_VAR(opline->op1.var);
14927 zend_match_unhandled_error(op);
14928 HANDLE_EXCEPTION();
14929}
14930
14931static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14932{
14933 USE_OPLINE
14934 zval *container;
14935
14936 SAVE_OPLINE();
14937 container = EX_VAR(opline->op1.var);
14938 zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
14939
14940 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14941}
14942
14943static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14944{
14945 USE_OPLINE
14946 zval *val;
14947
14948 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14949 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14950 ZVAL_FALSE(EX_VAR(opline->result.var));
14951 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14952 /* The result and op1 can be the same cv zval */
14953 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
14954 ZVAL_TRUE(EX_VAR(opline->result.var));
14955 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
14956 SAVE_OPLINE();
14957 ZVAL_UNDEFINED_OP1();
14958 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14959 }
14960 } else {
14961 SAVE_OPLINE();
14962 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
14963 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14964 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14965 }
14966 ZEND_VM_NEXT_OPCODE();
14967}
14968
14969static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14970{
14971 USE_OPLINE
14972 zval *z;
14973
14974 SAVE_OPLINE();
14975 z = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14976
14977 if (Z_TYPE_P(z) == IS_STRING) {
14978 zend_string *str = Z_STR_P(z);
14979
14980 if (ZSTR_LEN(str) != 0) {
14981 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
14982 }
14983 } else {
14984 zend_string *str = zval_get_string_func(z);
14985
14986 if (ZSTR_LEN(str) != 0) {
14987 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
14988 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
14989 ZVAL_UNDEFINED_OP1();
14990 }
14991 zend_string_release_ex(str, 0);
14992 }
14993
14994 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14995 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14996}
14997
14998static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14999{
15000 USE_OPLINE
15001 zval *val;
15002 uint8_t op1_type;
15003
15004 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15005
15006 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15007 ZEND_VM_NEXT_OPCODE();
15008 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15009 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15010 SAVE_OPLINE();
15011 ZVAL_UNDEFINED_OP1();
15012 if (UNEXPECTED(EG(exception))) {
15013 HANDLE_EXCEPTION();
15014 }
15015 }
15016 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15017 }
15018
15019 SAVE_OPLINE();
15020 op1_type = (IS_TMP_VAR|IS_VAR);
15021 if (i_zend_is_true(val)) {
15022 opline++;
15023 } else {
15024 opline = OP_JMP_ADDR(opline, opline->op2);
15025 }
15026 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
15027 zval_ptr_dtor_nogc(val);
15028 }
15029 ZEND_VM_JMP(opline);
15030}
15031
15032static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15033{
15034 USE_OPLINE
15035 zval *val;
15036 uint8_t op1_type;
15037
15038 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15039
15040 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15041 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15042 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15043 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15044 SAVE_OPLINE();
15045 ZVAL_UNDEFINED_OP1();
15046 if (UNEXPECTED(EG(exception))) {
15047 HANDLE_EXCEPTION();
15048 }
15049 }
15050 ZEND_VM_NEXT_OPCODE();
15051 }
15052
15053 SAVE_OPLINE();
15054 op1_type = (IS_TMP_VAR|IS_VAR);
15055 if (i_zend_is_true(val)) {
15056 opline = OP_JMP_ADDR(opline, opline->op2);
15057 } else {
15058 opline++;
15059 }
15060 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
15061 zval_ptr_dtor_nogc(val);
15062 }
15063 ZEND_VM_JMP(opline);
15064}
15065
15066static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15067{
15068 USE_OPLINE
15069 zval *val;
15070 bool ret;
15071
15072 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15073
15074 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15075 ZVAL_TRUE(EX_VAR(opline->result.var));
15076 ZEND_VM_NEXT_OPCODE();
15077 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15078 ZVAL_FALSE(EX_VAR(opline->result.var));
15079 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15080 SAVE_OPLINE();
15081 ZVAL_UNDEFINED_OP1();
15082 if (UNEXPECTED(EG(exception))) {
15083 HANDLE_EXCEPTION();
15084 }
15085 }
15086 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15087 }
15088
15089 SAVE_OPLINE();
15090 ret = i_zend_is_true(val);
15091 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15092 if (ret) {
15093 ZVAL_TRUE(EX_VAR(opline->result.var));
15094 opline++;
15095 } else {
15096 ZVAL_FALSE(EX_VAR(opline->result.var));
15097 opline = OP_JMP_ADDR(opline, opline->op2);
15098 }
15099 ZEND_VM_JMP(opline);
15100}
15101
15102static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15103{
15104 USE_OPLINE
15105 zval *val;
15106 bool ret;
15107
15108 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15109
15110 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15111 ZVAL_TRUE(EX_VAR(opline->result.var));
15112 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15113 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15114 ZVAL_FALSE(EX_VAR(opline->result.var));
15115 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15116 SAVE_OPLINE();
15117 ZVAL_UNDEFINED_OP1();
15118 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15119 } else {
15120 ZEND_VM_NEXT_OPCODE();
15121 }
15122 }
15123
15124 SAVE_OPLINE();
15125 ret = i_zend_is_true(val);
15126 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15127 if (ret) {
15128 ZVAL_TRUE(EX_VAR(opline->result.var));
15129 opline = OP_JMP_ADDR(opline, opline->op2);
15130 } else {
15131 ZVAL_FALSE(EX_VAR(opline->result.var));
15132 opline++;
15133 }
15134 ZEND_VM_JMP(opline);
15135}
15136
15137static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15138{
15139 USE_OPLINE
15140
15141 SAVE_OPLINE();
15142 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15143 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15144}
15145
15146static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15147{
15148 zval *var;
15149 USE_OPLINE
15150
15151 var = EX_VAR(opline->op1.var);
15152 if (Z_TYPE_P(var) != IS_ARRAY) {
15153 SAVE_OPLINE();
15154 if (Z_FE_ITER_P(var) != (uint32_t)-1) {
15155 zend_hash_iterator_del(Z_FE_ITER_P(var));
15156 }
15157 zval_ptr_dtor_nogc(var);
15158 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15159 }
15160
15161 /* This is freeing an array. Use an inlined version of zval_ptr_dtor_nogc. */
15162 /* 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) */
15163 if (Z_REFCOUNTED_P(var) && !Z_DELREF_P(var)) {
15164 SAVE_OPLINE();
15165 rc_dtor_func(Z_COUNTED_P(var));
15166 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15167 }
15168 ZEND_VM_NEXT_OPCODE();
15169}
15170
15171static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15172{
15173 USE_OPLINE
15174 zval *value;
15175
15176 SAVE_OPLINE();
15177 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15178
15179 do {
15180 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
15181 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
15182 value = Z_REFVAL_P(value);
15183 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
15184 break;
15185 }
15186 }
15187 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15188 ZVAL_UNDEFINED_OP1();
15189 if (UNEXPECTED(EG(exception) != NULL)) {
15190 HANDLE_EXCEPTION();
15191 }
15192 }
15193 zend_throw_error(NULL, "Can only throw objects");
15194 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15195 HANDLE_EXCEPTION();
15196 }
15197 } while (0);
15198
15199 zend_exception_save();
15200 Z_TRY_ADDREF_P(value);
15201 zend_throw_exception_object(value);
15202 zend_exception_restore();
15203 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15204 HANDLE_EXCEPTION();
15205}
15206
15207static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15208{
15209 USE_OPLINE
15210 zval *val;
15211
15212 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15213 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15214 ZVAL_TRUE(EX_VAR(opline->result.var));
15215 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15216 /* The result and op1 can be the same cv zval */
15217 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
15218 ZVAL_FALSE(EX_VAR(opline->result.var));
15219 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
15220 SAVE_OPLINE();
15221 ZVAL_UNDEFINED_OP1();
15222 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15223 }
15224 } else {
15225 SAVE_OPLINE();
15226 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
15227 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15228 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15229 }
15230 ZEND_VM_NEXT_OPCODE();
15231}
15232
15233static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15234{
15235 USE_OPLINE
15236 zval *obj;
15237 zend_object *zobj;
15238 zend_class_entry *ce, *scope;
15239 zend_function *clone;
15240 zend_object_clone_obj_t clone_call;
15241
15242 SAVE_OPLINE();
15243 obj = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15244
15245 do {
15246 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
15247 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
15248 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
15249 obj = Z_REFVAL_P(obj);
15250 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
15251 break;
15252 }
15253 }
15254 ZVAL_UNDEF(EX_VAR(opline->result.var));
15255 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
15256 ZVAL_UNDEFINED_OP1();
15257 if (UNEXPECTED(EG(exception) != NULL)) {
15258 HANDLE_EXCEPTION();
15259 }
15260 }
15261 zend_throw_error(NULL, "__clone method called on non-object");
15262 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15263 HANDLE_EXCEPTION();
15264 }
15265 } while (0);
15266
15267 zobj = Z_OBJ_P(obj);
15268 ce = zobj->ce;
15269 clone = ce->clone;
15270 clone_call = zobj->handlers->clone_obj;
15271 if (UNEXPECTED(clone_call == NULL)) {
15272 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
15273 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15274 ZVAL_UNDEF(EX_VAR(opline->result.var));
15275 HANDLE_EXCEPTION();
15276 }
15277
15278 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
15279 scope = EX(func)->op_array.scope;
15280 if (clone->common.scope != scope) {
15281 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
15282 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
15283 zend_wrong_clone_call(clone, scope);
15284 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15285 ZVAL_UNDEF(EX_VAR(opline->result.var));
15286 HANDLE_EXCEPTION();
15287 }
15288 }
15289 }
15290
15291 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
15292
15293 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15294 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15295}
15296
15297static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15298{
15299 USE_OPLINE
15300 zend_op_array *new_op_array;
15301 zval *inc_filename;
15302
15303 SAVE_OPLINE();
15304 inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15305 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
15306 if (UNEXPECTED(EG(exception) != NULL)) {
15307 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15308 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
15309 destroy_op_array(new_op_array);
15310 efree_size(new_op_array, sizeof(zend_op_array));
15311 }
15312 UNDEF_RESULT();
15313 HANDLE_EXCEPTION();
15314 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
15315 if (RETURN_VALUE_USED(opline)) {
15316 ZVAL_TRUE(EX_VAR(opline->result.var));
15317 }
15318 } else if (UNEXPECTED(new_op_array == NULL)) {
15319 if (RETURN_VALUE_USED(opline)) {
15320 ZVAL_FALSE(EX_VAR(opline->result.var));
15321 }
15322 } else if (new_op_array->last == 1
15323 && new_op_array->opcodes[0].opcode == ZEND_RETURN
15324 && new_op_array->opcodes[0].op1_type == IS_CONST
15325 && EXPECTED(zend_execute_ex == execute_ex)) {
15326 if (RETURN_VALUE_USED(opline)) {
15327 const zend_op *op = new_op_array->opcodes;
15328
15329 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
15330 }
15331 zend_destroy_static_vars(new_op_array);
15332 destroy_op_array(new_op_array);
15333 efree_size(new_op_array, sizeof(zend_op_array));
15334 } else {
15335 zval *return_value = NULL;
15336 zend_execute_data *call;
15337 if (RETURN_VALUE_USED(opline)) {
15338 return_value = EX_VAR(opline->result.var);
15339 }
15340
15341 new_op_array->scope = EX(func)->op_array.scope;
15342
15343 call = zend_vm_stack_push_call_frame(
15344 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
15345 (zend_function*)new_op_array, 0,
15346 Z_PTR(EX(This)));
15347
15348 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
15349 call->symbol_table = EX(symbol_table);
15350 } else {
15351 call->symbol_table = zend_rebuild_symbol_table();
15352 }
15353
15354 call->prev_execute_data = execute_data;
15355 i_init_code_execute_data(call, new_op_array, return_value);
15356
15357 if (EXPECTED(zend_execute_ex == execute_ex)) {
15358 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15359 ZEND_VM_ENTER();
15360 } else {
15361 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
15362 zend_execute_ex(call);
15363 zend_vm_stack_free_call_frame(call);
15364 }
15365
15366 zend_destroy_static_vars(new_op_array);
15367 destroy_op_array(new_op_array);
15368 efree_size(new_op_array, sizeof(zend_op_array));
15369 if (UNEXPECTED(EG(exception) != NULL)) {
15370 zend_rethrow_exception(execute_data);
15371 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15372 UNDEF_RESULT();
15373 HANDLE_EXCEPTION();
15374 }
15375 }
15376 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15377 ZEND_VM_NEXT_OPCODE();
15378}
15379
15380static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15381{
15382 USE_OPLINE
15383 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
15384 zval *val;
15385
15386 SAVE_OPLINE();
15387 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15388
15389 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
15390 zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
15391 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15392 UNDEF_RESULT();
15393 HANDLE_EXCEPTION();
15394 }
15395
15396yield_from_try_again:
15397 if (Z_TYPE_P(val) == IS_ARRAY) {
15398 ZVAL_COPY_VALUE(&generator->values, val);
15399 if (Z_OPT_REFCOUNTED_P(val)) {
15400 Z_ADDREF_P(val);
15401 }
15402 Z_FE_POS(generator->values) = 0;
15403 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15404 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
15405 zend_class_entry *ce = Z_OBJCE_P(val);
15406 if (ce == zend_ce_generator) {
15407 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
15408
15409 Z_ADDREF_P(val);
15410 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15411
15412 if (UNEXPECTED(new_gen->execute_data == NULL)) {
15413 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
15414 zval_ptr_dtor(val);
15415 UNDEF_RESULT();
15416 HANDLE_EXCEPTION();
15417 } else if (Z_ISUNDEF(new_gen->retval)) {
15418 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
15419 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
15420 zval_ptr_dtor(val);
15421 UNDEF_RESULT();
15422 HANDLE_EXCEPTION();
15423 } else {
15424 zend_generator_yield_from(generator, new_gen);
15425 }
15426 } else {
15427 if (RETURN_VALUE_USED(opline)) {
15428 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
15429 }
15430 ZEND_VM_NEXT_OPCODE();
15431 }
15432 } else {
15433 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
15434 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15435
15436 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
15437 if (!EG(exception)) {
15438 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
15439 }
15440 UNDEF_RESULT();
15441 HANDLE_EXCEPTION();
15442 }
15443
15444 iter->index = 0;
15445 if (iter->funcs->rewind) {
15446 iter->funcs->rewind(iter);
15447 if (UNEXPECTED(EG(exception) != NULL)) {
15448 OBJ_RELEASE(&iter->std);
15449 UNDEF_RESULT();
15450 HANDLE_EXCEPTION();
15451 }
15452 }
15453
15454 ZVAL_OBJ(&generator->values, &iter->std);
15455 }
15456 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
15457 val = Z_REFVAL_P(val);
15458 goto yield_from_try_again;
15459 } else {
15460 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
15461 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15462 UNDEF_RESULT();
15463 HANDLE_EXCEPTION();
15464 }
15465
15466 /* This is the default return value
15467 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
15468 if (RETURN_VALUE_USED(opline)) {
15469 ZVAL_NULL(EX_VAR(opline->result.var));
15470 }
15471
15472 /* This generator has no send target (though the generator we delegate to might have one) */
15473 generator->send_target = NULL;
15474
15475 /* The GOTO VM uses a local opline variable. We need to set the opline
15476 * variable in execute_data so we don't resume at an old position. */
15477 SAVE_OPLINE();
15478
15479 ZEND_VM_RETURN();
15480}
15481
15482static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15483{
15484 USE_OPLINE
15485 zval *value;
15486
15487 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15488 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15489 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15490 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15491 zval_ptr_dtor_str(value);
15492 }
15493 ZEND_VM_NEXT_OPCODE();
15494 } else {
15495 bool strict;
15496
15497 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
15498 value = Z_REFVAL_P(value);
15499 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15500 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15501 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15502 ZEND_VM_NEXT_OPCODE();
15503 }
15504 }
15505
15506 SAVE_OPLINE();
15507 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15508 value = ZVAL_UNDEFINED_OP1();
15509 }
15510 strict = EX_USES_STRICT_TYPES();
15511 do {
15512 if (EXPECTED(!strict)) {
15513 zend_string *str;
15514 zval tmp;
15515
15516 if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
15517 zend_error(E_DEPRECATED,
15518 "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
15519 ZVAL_LONG(EX_VAR(opline->result.var), 0);
15520 if (UNEXPECTED(EG(exception))) {
15521 HANDLE_EXCEPTION();
15522 }
15523 break;
15524 }
15525
15526 ZVAL_COPY(&tmp, value);
15527 if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
15528 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
15529 zval_ptr_dtor(&tmp);
15530 break;
15531 }
15532 zval_ptr_dtor(&tmp);
15533 }
15534 if (!EG(exception)) {
15535 zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
15536 }
15537 ZVAL_UNDEF(EX_VAR(opline->result.var));
15538 } while (0);
15539 }
15540 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15541 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15542}
15543
15544static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15545{
15546 USE_OPLINE
15547 zval *value;
15548 int result = 0;
15549
15550 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15551 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15552type_check_resource:
15553 if (opline->extended_value != MAY_BE_RESOURCE
15554 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
15555 result = 1;
15556 }
15557 } else if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
15558 value = Z_REFVAL_P(value);
15559 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15560 goto type_check_resource;
15561 }
15562 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15563 result = ((1 << IS_NULL) & opline->extended_value) != 0;
15564 SAVE_OPLINE();
15565 ZVAL_UNDEFINED_OP1();
15566 if (UNEXPECTED(EG(exception))) {
15567 ZVAL_UNDEF(EX_VAR(opline->result.var));
15568 HANDLE_EXCEPTION();
15569 }
15570 }
15571 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15572 SAVE_OPLINE();
15573 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15574 ZEND_VM_SMART_BRANCH(result, 1);
15575 } else {
15576 ZEND_VM_SMART_BRANCH(result, 0);
15577 }
15578}
15579
15580static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15581{
15582 uint32_t fetch_type;
15583 zend_class_entry *called_scope, *scope;
15584 USE_OPLINE
15585
15586 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
15587 SAVE_OPLINE();
15588 zval *op = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15589 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
15590 ZVAL_DEREF(op);
15591 if (Z_TYPE_P(op) != IS_OBJECT) {
15592 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
15593 ZVAL_UNDEF(EX_VAR(opline->result.var));
15594 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15595 HANDLE_EXCEPTION();
15596 }
15597 }
15598
15599 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
15600 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15601 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15602 }
15603
15604 fetch_type = opline->op1.num;
15605 scope = EX(func)->op_array.scope;
15606 if (UNEXPECTED(scope == NULL)) {
15607 SAVE_OPLINE();
15608 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
15609 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
15610 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
15611 ZVAL_UNDEF(EX_VAR(opline->result.var));
15612 HANDLE_EXCEPTION();
15613 }
15614
15615 switch (fetch_type) {
15616 case ZEND_FETCH_CLASS_SELF:
15617 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
15618 break;
15619 case ZEND_FETCH_CLASS_PARENT:
15620 if (UNEXPECTED(scope->parent == NULL)) {
15621 SAVE_OPLINE();
15622 zend_throw_error(NULL,
15623 "Cannot use \"parent\" when current class scope has no parent");
15624 ZVAL_UNDEF(EX_VAR(opline->result.var));
15625 HANDLE_EXCEPTION();
15626 }
15627 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
15628 break;
15629 case ZEND_FETCH_CLASS_STATIC:
15630 if (Z_TYPE(EX(This)) == IS_OBJECT) {
15631 called_scope = Z_OBJCE(EX(This));
15632 } else {
15633 called_scope = Z_CE(EX(This));
15634 }
15635 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
15636 break;
15637 EMPTY_SWITCH_DEFAULT_CASE()
15638 }
15639 ZEND_VM_NEXT_OPCODE();
15640}
15641
15642static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15643{
15644 USE_OPLINE
15645 zval *op1, *op2;
15646
15647 SAVE_OPLINE();
15648 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15649 op2 = RT_CONSTANT(opline, opline->op2);
15650 div_function(EX_VAR(opline->result.var), op1, op2);
15651 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15652
15653 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15654}
15655
15656static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15657{
15658 USE_OPLINE
15659 zval *op1, *op2;
15660
15661 SAVE_OPLINE();
15662 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15663 op2 = RT_CONSTANT(opline, opline->op2);
15664 pow_function(EX_VAR(opline->result.var), op1, op2);
15665 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15666
15667 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15668}
15669
15670static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15671{
15672 USE_OPLINE
15673 zval *op1, *op2;
15674
15675 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15676 op2 = RT_CONSTANT(opline, opline->op2);
15677
15678 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
15679 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
15680 zend_string *op1_str = Z_STR_P(op1);
15681 zend_string *op2_str = Z_STR_P(op2);
15682 zend_string *str;
15683 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
15684
15685 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
15686 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
15687 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
15688 } else {
15689 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
15690 }
15691 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15692 zend_string_release_ex(op1_str, 0);
15693 }
15694 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
15695 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
15696 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
15697 } else {
15698 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
15699 }
15700 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15701 zend_string_release_ex(op2_str, 0);
15702 }
15703 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
15704 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
15705 size_t len = ZSTR_LEN(op1_str);
15706
15707 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
15708 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
15709 }
15710 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
15711 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15712 GC_ADD_FLAGS(str, flags);
15713 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15714 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15715 zend_string_release_ex(op2_str, 0);
15716 }
15717 } else {
15718 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
15719 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
15720 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15721 GC_ADD_FLAGS(str, flags);
15722 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15723 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15724 zend_string_release_ex(op1_str, 0);
15725 }
15726 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15727 zend_string_release_ex(op2_str, 0);
15728 }
15729 }
15730 ZEND_VM_NEXT_OPCODE();
15731 } else {
15732 SAVE_OPLINE();
15733
15734 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
15735 op1 = ZVAL_UNDEFINED_OP1();
15736 }
15737 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
15738 op2 = ZVAL_UNDEFINED_OP2();
15739 }
15740 concat_function(EX_VAR(opline->result.var), op1, op2);
15741 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15742
15743 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15744 }
15745}
15746
15747static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15748{
15749 USE_OPLINE
15750 zval *op1, *op2;
15751 double d1, d2;
15752
15753 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15754 op2 = RT_CONSTANT(opline, opline->op2);
15755 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15756 /* pass */
15757 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15758 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15759 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15760is_equal_true:
15761 ZEND_VM_SMART_BRANCH_TRUE_NONE();
15762 } else {
15763is_equal_false:
15764 ZEND_VM_SMART_BRANCH_FALSE_NONE();
15765 }
15766 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15767 d1 = (double)Z_LVAL_P(op1);
15768 d2 = Z_DVAL_P(op2);
15769 goto is_equal_double;
15770 }
15771 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15772 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15773 d1 = Z_DVAL_P(op1);
15774 d2 = Z_DVAL_P(op2);
15775is_equal_double:
15776 if (d1 == d2) {
15777 goto is_equal_true;
15778 } else {
15779 goto is_equal_false;
15780 }
15781 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15782 d1 = Z_DVAL_P(op1);
15783 d2 = (double)Z_LVAL_P(op2);
15784 goto is_equal_double;
15785 }
15786 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15787 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15788 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15789 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15790 zval_ptr_dtor_str(op1);
15791 }
15792 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15793 zval_ptr_dtor_str(op2);
15794 }
15795 if (result) {
15796 goto is_equal_true;
15797 } else {
15798 goto is_equal_false;
15799 }
15800 }
15801 }
15802 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15803}
15804
15805static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15806{
15807 USE_OPLINE
15808 zval *op1, *op2;
15809 double d1, d2;
15810
15811 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15812 op2 = RT_CONSTANT(opline, opline->op2);
15813 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15814 /* pass */
15815 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15816 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15817 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15818is_equal_true:
15819 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
15820 } else {
15821is_equal_false:
15822 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
15823 }
15824 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15825 d1 = (double)Z_LVAL_P(op1);
15826 d2 = Z_DVAL_P(op2);
15827 goto is_equal_double;
15828 }
15829 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15830 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15831 d1 = Z_DVAL_P(op1);
15832 d2 = Z_DVAL_P(op2);
15833is_equal_double:
15834 if (d1 == d2) {
15835 goto is_equal_true;
15836 } else {
15837 goto is_equal_false;
15838 }
15839 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15840 d1 = Z_DVAL_P(op1);
15841 d2 = (double)Z_LVAL_P(op2);
15842 goto is_equal_double;
15843 }
15844 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15845 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15846 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15847 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15848 zval_ptr_dtor_str(op1);
15849 }
15850 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15851 zval_ptr_dtor_str(op2);
15852 }
15853 if (result) {
15854 goto is_equal_true;
15855 } else {
15856 goto is_equal_false;
15857 }
15858 }
15859 }
15860 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15861}
15862
15863static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15864{
15865 USE_OPLINE
15866 zval *op1, *op2;
15867 double d1, d2;
15868
15869 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15870 op2 = RT_CONSTANT(opline, opline->op2);
15871 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15872 /* pass */
15873 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15874 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15875 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15876is_equal_true:
15877 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
15878 } else {
15879is_equal_false:
15880 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
15881 }
15882 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15883 d1 = (double)Z_LVAL_P(op1);
15884 d2 = Z_DVAL_P(op2);
15885 goto is_equal_double;
15886 }
15887 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15888 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15889 d1 = Z_DVAL_P(op1);
15890 d2 = Z_DVAL_P(op2);
15891is_equal_double:
15892 if (d1 == d2) {
15893 goto is_equal_true;
15894 } else {
15895 goto is_equal_false;
15896 }
15897 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15898 d1 = Z_DVAL_P(op1);
15899 d2 = (double)Z_LVAL_P(op2);
15900 goto is_equal_double;
15901 }
15902 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15903 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15904 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15905 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15906 zval_ptr_dtor_str(op1);
15907 }
15908 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15909 zval_ptr_dtor_str(op2);
15910 }
15911 if (result) {
15912 goto is_equal_true;
15913 } else {
15914 goto is_equal_false;
15915 }
15916 }
15917 }
15918 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15919}
15920
15921static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15922{
15923 USE_OPLINE
15924 zval *op1, *op2;
15925 double d1, d2;
15926
15927 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15928 op2 = RT_CONSTANT(opline, opline->op2);
15929 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15930 /* pass */
15931 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15932 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15933 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
15934is_not_equal_true:
15935 ZEND_VM_SMART_BRANCH_TRUE_NONE();
15936 } else {
15937is_not_equal_false:
15938 ZEND_VM_SMART_BRANCH_FALSE_NONE();
15939 }
15940 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15941 d1 = (double)Z_LVAL_P(op1);
15942 d2 = Z_DVAL_P(op2);
15943 goto is_not_equal_double;
15944 }
15945 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15946 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15947 d1 = Z_DVAL_P(op1);
15948 d2 = Z_DVAL_P(op2);
15949is_not_equal_double:
15950 if (d1 != d2) {
15951 goto is_not_equal_true;
15952 } else {
15953 goto is_not_equal_false;
15954 }
15955 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15956 d1 = Z_DVAL_P(op1);
15957 d2 = (double)Z_LVAL_P(op2);
15958 goto is_not_equal_double;
15959 }
15960 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15961 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15962 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15963 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15964 zval_ptr_dtor_str(op1);
15965 }
15966 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15967 zval_ptr_dtor_str(op2);
15968 }
15969 if (!result) {
15970 goto is_not_equal_true;
15971 } else {
15972 goto is_not_equal_false;
15973 }
15974 }
15975 }
15976 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15977}
15978
15979static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15980{
15981 USE_OPLINE
15982 zval *op1, *op2;
15983 double d1, d2;
15984
15985 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15986 op2 = RT_CONSTANT(opline, opline->op2);
15987 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15988 /* pass */
15989 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15990 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15991 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
15992is_not_equal_true:
15993 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
15994 } else {
15995is_not_equal_false:
15996 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
15997 }
15998 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15999 d1 = (double)Z_LVAL_P(op1);
16000 d2 = Z_DVAL_P(op2);
16001 goto is_not_equal_double;
16002 }
16003 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16004 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16005 d1 = Z_DVAL_P(op1);
16006 d2 = Z_DVAL_P(op2);
16007is_not_equal_double:
16008 if (d1 != d2) {
16009 goto is_not_equal_true;
16010 } else {
16011 goto is_not_equal_false;
16012 }
16013 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16014 d1 = Z_DVAL_P(op1);
16015 d2 = (double)Z_LVAL_P(op2);
16016 goto is_not_equal_double;
16017 }
16018 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16019 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16020 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16021 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16022 zval_ptr_dtor_str(op1);
16023 }
16024 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16025 zval_ptr_dtor_str(op2);
16026 }
16027 if (!result) {
16028 goto is_not_equal_true;
16029 } else {
16030 goto is_not_equal_false;
16031 }
16032 }
16033 }
16034 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16035}
16036
16037static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16038{
16039 USE_OPLINE
16040 zval *op1, *op2;
16041 double d1, d2;
16042
16043 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16044 op2 = RT_CONSTANT(opline, opline->op2);
16045 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16046 /* pass */
16047 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16048 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16049 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
16050is_not_equal_true:
16051 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
16052 } else {
16053is_not_equal_false:
16054 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
16055 }
16056 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16057 d1 = (double)Z_LVAL_P(op1);
16058 d2 = Z_DVAL_P(op2);
16059 goto is_not_equal_double;
16060 }
16061 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16062 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16063 d1 = Z_DVAL_P(op1);
16064 d2 = Z_DVAL_P(op2);
16065is_not_equal_double:
16066 if (d1 != d2) {
16067 goto is_not_equal_true;
16068 } else {
16069 goto is_not_equal_false;
16070 }
16071 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16072 d1 = Z_DVAL_P(op1);
16073 d2 = (double)Z_LVAL_P(op2);
16074 goto is_not_equal_double;
16075 }
16076 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16077 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16078 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16079 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16080 zval_ptr_dtor_str(op1);
16081 }
16082 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16083 zval_ptr_dtor_str(op2);
16084 }
16085 if (!result) {
16086 goto is_not_equal_true;
16087 } else {
16088 goto is_not_equal_false;
16089 }
16090 }
16091 }
16092 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16093}
16094
16095static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16096{
16097 USE_OPLINE
16098 zval *op1, *op2;
16099
16100 SAVE_OPLINE();
16101 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16102 op2 = RT_CONSTANT(opline, opline->op2);
16103 compare_function(EX_VAR(opline->result.var), op1, op2);
16104 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16105
16106 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16107}
16108
16109static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16110{
16111 USE_OPLINE
16112 zval *op1, *op2;
16113
16114 SAVE_OPLINE();
16115 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16116 op2 = RT_CONSTANT(opline, opline->op2);
16117 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
16118 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16119
16120 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16121}
16122
16123static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16124{
16125 USE_OPLINE
16126 zval *container, *dim, *value;
16127
16128 SAVE_OPLINE();
16129 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16130 dim = RT_CONSTANT(opline, opline->op2);
16131 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16132 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16133fetch_dim_r_array:
16134 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
16135 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
16136 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
16137 container = Z_REFVAL_P(container);
16138 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16139 goto fetch_dim_r_array;
16140 } else {
16141 goto fetch_dim_r_slow;
16142 }
16143 } else {
16144fetch_dim_r_slow:
16145 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
16146 dim++;
16147 }
16148 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
16149 }
16150 } else {
16151 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
16152 }
16153
16154 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16155 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16156}
16157
16158static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16159{
16160 USE_OPLINE
16161 zval *container;
16162
16163 SAVE_OPLINE();
16164 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16165 zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
16166
16167 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16168 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16169}
16170
16171static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16172{
16173 USE_OPLINE
16174 zval *container;
16175 void **cache_slot = NULL;
16176
16177 SAVE_OPLINE();
16178 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16179
16180 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16181 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16182 do {
16183 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16184 container = Z_REFVAL_P(container);
16185 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
16186 break;
16187 }
16188 }
16189 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
16190 ZVAL_UNDEFINED_OP1();
16191 }
16192 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
16193 ZVAL_NULL(EX_VAR(opline->result.var));
16194 goto fetch_obj_r_finish;
16195 } while (0);
16196 }
16197
16198 /* here we are sure we are dealing with an object */
16199 do {
16200 zend_object *zobj = Z_OBJ_P(container);
16201 zend_string *name, *tmp_name;
16202 zval *retval;
16203
16204 if (IS_CONST == IS_CONST) {
16205 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
16206
16207 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
16208 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
16209
16210 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
16211fetch_obj_r_simple:
16212 retval = OBJ_PROP(zobj, prop_offset);
16213 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
16214 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16215 goto fetch_obj_r_copy;
16216 } else {
16217fetch_obj_r_fast_copy:
16218 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16219 ZEND_VM_NEXT_OPCODE();
16220 }
16221 }
16222 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
16223 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
16224 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
16225 prop_offset = prop_info->offset;
16226 goto fetch_obj_r_simple;
16227 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
16228 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
16229 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
16230 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
16231
16232 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
16233 if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
16234 GC_ADDREF(zobj);
16235 }
16236 if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
16237 call_info |= ZEND_CALL_RELEASE_THIS;
16238 }
16239 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
16240 call->prev_execute_data = execute_data;
16241 call->call = NULL;
16242 call->return_value = EX_VAR(opline->result.var);
16243 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
16244
16245 execute_data = call;
16246 EG(current_execute_data) = execute_data;
16247 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
16248
16249#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
16250 opline = hook->op_array.opcodes;
16251#else
16252 EX(opline) = hook->op_array.opcodes;
16253#endif
16254 LOAD_OPLINE_EX();
16255
16256
16257 ZEND_VM_ENTER_EX();
16258 }
16259 /* Fall through to read_property for hooks. */
16260 } else if (EXPECTED(zobj->properties != NULL)) {
16261 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
16262 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16263 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
16264 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
16265
16266 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
16267 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
16268
16269 if (EXPECTED(p->key == name) ||
16270 (EXPECTED(p->h == ZSTR_H(name)) &&
16271 EXPECTED(p->key != NULL) &&
16272 EXPECTED(zend_string_equal_content(p->key, name)))) {
16273 retval = &p->val;
16274 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16275 goto fetch_obj_r_copy;
16276 } else {
16277 goto fetch_obj_r_fast_copy;
16278 }
16279 }
16280 }
16281 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
16282 }
16283 retval = zend_hash_find_known_hash(zobj->properties, name);
16284 if (EXPECTED(retval)) {
16285 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
16286 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
16287 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16288 goto fetch_obj_r_copy;
16289 } else {
16290 goto fetch_obj_r_fast_copy;
16291 }
16292 }
16293 }
16294 }
16295 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16296 } else {
16297 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
16298 if (UNEXPECTED(!name)) {
16299 ZVAL_UNDEF(EX_VAR(opline->result.var));
16300 break;
16301 }
16302 }
16303
16304#if ZEND_DEBUG
16305 /* For non-standard object handlers, verify a declared property type in debug builds.
16306 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
16307 zend_property_info *prop_info = NULL;
16308 if (zobj->handlers->read_property != zend_std_read_property) {
16309 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
16310 }
16311#endif
16312 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
16313#if ZEND_DEBUG
16314 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
16315 && ZEND_TYPE_IS_SET(prop_info->type)) {
16316 ZVAL_OPT_DEREF(retval);
16317 zend_verify_property_type(prop_info, retval, /* strict */ true);
16318 }
16319#endif
16320
16321 if (IS_CONST != IS_CONST) {
16322 zend_tmp_string_release(tmp_name);
16323 }
16324
16325 if (retval != EX_VAR(opline->result.var)) {
16326fetch_obj_r_copy:
16327 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16328 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
16329 zend_unwrap_reference(retval);
16330 }
16331 } while (0);
16332
16333fetch_obj_r_finish:
16334
16335 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16336 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16337}
16338
16339static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16340{
16341 USE_OPLINE
16342 zval *container;
16343 void **cache_slot = NULL;
16344
16345 SAVE_OPLINE();
16346 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16347
16348 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16349 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16350 do {
16351 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16352 container = Z_REFVAL_P(container);
16353 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
16354 break;
16355 }
16356 }
16357 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
16358 ZVAL_UNDEFINED_OP2();
16359 }
16360 ZVAL_NULL(EX_VAR(opline->result.var));
16361 goto fetch_obj_is_finish;
16362 } while (0);
16363 }
16364
16365 /* here we are sure we are dealing with an object */
16366 do {
16367 zend_object *zobj = Z_OBJ_P(container);
16368 zend_string *name, *tmp_name;
16369 zval *retval;
16370
16371 if (IS_CONST == IS_CONST) {
16372 cache_slot = CACHE_ADDR(opline->extended_value);
16373
16374 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
16375 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
16376
16377 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
16378fetch_obj_is_simple:
16379 retval = OBJ_PROP(zobj, prop_offset);
16380 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
16381 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16382 goto fetch_obj_is_copy;
16383 } else {
16384fetch_obj_is_fast_copy:
16385 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16386 ZEND_VM_NEXT_OPCODE();
16387 }
16388 }
16389 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
16390 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
16391 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
16392 prop_offset = prop_info->offset;
16393 goto fetch_obj_is_simple;
16394 }
16395 /* Fall through to read_property for hooks. */
16396 } else if (EXPECTED(zobj->properties != NULL)) {
16397 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
16398 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16399 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
16400 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
16401
16402 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
16403 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
16404
16405 if (EXPECTED(p->key == name) ||
16406 (EXPECTED(p->h == ZSTR_H(name)) &&
16407 EXPECTED(p->key != NULL) &&
16408 EXPECTED(zend_string_equal_content(p->key, name)))) {
16409 retval = &p->val;
16410 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16411 goto fetch_obj_is_copy;
16412 } else {
16413 goto fetch_obj_is_fast_copy;
16414 }
16415 }
16416 }
16417 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
16418 }
16419 retval = zend_hash_find_known_hash(zobj->properties, name);
16420 if (EXPECTED(retval)) {
16421 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
16422 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
16423 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16424 goto fetch_obj_is_copy;
16425 } else {
16426 goto fetch_obj_is_fast_copy;
16427 }
16428 }
16429 }
16430 }
16431 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16432 } else {
16433 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
16434 if (UNEXPECTED(!name)) {
16435 ZVAL_UNDEF(EX_VAR(opline->result.var));
16436 break;
16437 }
16438 }
16439
16440 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
16441
16442 if (IS_CONST != IS_CONST) {
16443 zend_tmp_string_release(tmp_name);
16444 }
16445
16446 if (retval != EX_VAR(opline->result.var)) {
16447fetch_obj_is_copy:
16448 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16449 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
16450 zend_unwrap_reference(retval);
16451 }
16452 } while (0);
16453
16454fetch_obj_is_finish:
16455
16456 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16457 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16458}
16459
16460static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16461{
16462 USE_OPLINE
16463 zval *op1, *op2;
16464 zend_string *op1_str, *op2_str, *str;
16465
16466
16467 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16468 op2 = RT_CONSTANT(opline, opline->op2);
16469 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
16470 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
16471 zend_string *op1_str = Z_STR_P(op1);
16472 zend_string *op2_str = Z_STR_P(op2);
16473 zend_string *str;
16474 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
16475
16476 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16477 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
16478 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
16479 } else {
16480 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16481 }
16482 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16483 zend_string_release_ex(op1_str, 0);
16484 }
16485 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16486 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
16487 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
16488 } else {
16489 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16490 }
16491 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16492 zend_string_release_ex(op2_str, 0);
16493 }
16494 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
16495 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
16496 size_t len = ZSTR_LEN(op1_str);
16497
16498 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
16499 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16500 GC_ADD_FLAGS(str, flags);
16501 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16502 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16503 zend_string_release_ex(op2_str, 0);
16504 }
16505 } else {
16506 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16507 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16508 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16509 GC_ADD_FLAGS(str, flags);
16510 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16511 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16512 zend_string_release_ex(op1_str, 0);
16513 }
16514 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16515 zend_string_release_ex(op2_str, 0);
16516 }
16517 }
16518 ZEND_VM_NEXT_OPCODE();
16519 }
16520
16521 SAVE_OPLINE();
16522 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16523 op1_str = Z_STR_P(op1);
16524 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16525 op1_str = zend_string_copy(Z_STR_P(op1));
16526 } else {
16527 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
16528 ZVAL_UNDEFINED_OP1();
16529 }
16530 op1_str = zval_get_string_func(op1);
16531 }
16532 if (IS_CONST == IS_CONST) {
16533 op2_str = Z_STR_P(op2);
16534 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16535 op2_str = zend_string_copy(Z_STR_P(op2));
16536 } else {
16537 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
16538 ZVAL_UNDEFINED_OP2();
16539 }
16540 op2_str = zval_get_string_func(op2);
16541 }
16542 do {
16543 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16544 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16545 if (IS_CONST == IS_CONST) {
16546 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
16547 GC_ADDREF(op2_str);
16548 }
16549 }
16550 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16551 zend_string_release_ex(op1_str, 0);
16552 break;
16553 }
16554 }
16555 if (IS_CONST != IS_CONST) {
16556 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16557 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16558 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
16559 GC_ADDREF(op1_str);
16560 }
16561 }
16562 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16563 zend_string_release_ex(op2_str, 0);
16564 break;
16565 }
16566 }
16567 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16568 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16569 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16570
16571 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
16572 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16573 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16574 zend_string_release_ex(op1_str, 0);
16575 }
16576 if (IS_CONST != IS_CONST) {
16577 zend_string_release_ex(op2_str, 0);
16578 }
16579 } while (0);
16580 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16581
16582 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16583}
16584
16585static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16586{
16587 USE_OPLINE
16588 zval *function_name;
16589 zval *object;
16590 zend_function *fbc;
16591 zend_class_entry *called_scope;
16592 zend_object *obj;
16593 zend_execute_data *call;
16594 uint32_t call_info;
16595
16596 SAVE_OPLINE();
16597
16598 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16599
16600 if (IS_CONST != IS_CONST) {
16601 function_name = RT_CONSTANT(opline, opline->op2);
16602 }
16603
16604 if (IS_CONST != IS_CONST &&
16605 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
16606 do {
16607 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
16608 function_name = Z_REFVAL_P(function_name);
16609 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
16610 break;
16611 }
16612 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
16613 ZVAL_UNDEFINED_OP2();
16614 if (UNEXPECTED(EG(exception) != NULL)) {
16615 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16616 HANDLE_EXCEPTION();
16617 }
16618 }
16619 zend_throw_error(NULL, "Method name must be a string");
16620
16621 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16622 HANDLE_EXCEPTION();
16623 } while (0);
16624 }
16625
16626 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
16627 obj = Z_OBJ_P(object);
16628 } else {
16629 do {
16630 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16631 obj = Z_OBJ_P(object);
16632 } else {
16633 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
16634 zend_reference *ref = Z_REF_P(object);
16635
16636 object = &ref->val;
16637 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16638 obj = Z_OBJ_P(object);
16639 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
16640 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
16641 efree_size(ref, sizeof(zend_reference));
16642 } else {
16643 Z_ADDREF_P(object);
16644 }
16645 }
16646 break;
16647 }
16648 }
16649 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
16650 object = ZVAL_UNDEFINED_OP1();
16651 if (UNEXPECTED(EG(exception) != NULL)) {
16652 if (IS_CONST != IS_CONST) {
16653
16654 }
16655 HANDLE_EXCEPTION();
16656 }
16657 }
16658 if (IS_CONST == IS_CONST) {
16659 function_name = RT_CONSTANT(opline, opline->op2);
16660 }
16661 zend_invalid_method_call(object, function_name);
16662
16663 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16664 HANDLE_EXCEPTION();
16665 }
16666 } while (0);
16667 }
16668
16669 called_scope = obj->ce;
16670
16671 if (IS_CONST == IS_CONST &&
16672 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
16673 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
16674 } else {
16675 zend_object *orig_obj = obj;
16676
16677 if (IS_CONST == IS_CONST) {
16678 function_name = RT_CONSTANT(opline, opline->op2);
16679 }
16680
16681 /* First, locate the function. */
16682 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
16683 if (UNEXPECTED(fbc == NULL)) {
16684 if (EXPECTED(!EG(exception))) {
16685 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
16686 }
16687
16688 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
16689 zend_objects_store_del(orig_obj);
16690 }
16691 HANDLE_EXCEPTION();
16692 }
16693 if (IS_CONST == IS_CONST &&
16694 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
16695 EXPECTED(obj == orig_obj)) {
16696 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
16697 }
16698 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
16699 GC_ADDREF(obj); /* For $this pointer */
16700 if (GC_DELREF(orig_obj) == 0) {
16701 zend_objects_store_del(orig_obj);
16702 }
16703 }
16704 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
16705 init_func_run_time_cache(&fbc->op_array);
16706 }
16707 }
16708
16709 if (IS_CONST != IS_CONST) {
16710
16711 }
16712
16713 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
16714 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
16715 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
16716 zend_objects_store_del(obj);
16717 if (UNEXPECTED(EG(exception))) {
16718 HANDLE_EXCEPTION();
16719 }
16720 }
16721 /* call static method */
16722 obj = (zend_object*)called_scope;
16723 call_info = ZEND_CALL_NESTED_FUNCTION;
16724 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
16725 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
16726 GC_ADDREF(obj); /* For $this pointer */
16727 }
16728 /* CV may be changed indirectly (e.g. when it's a reference) */
16729 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
16730 }
16731
16732 call = zend_vm_stack_push_call_frame(call_info,
16733 fbc, opline->extended_value, obj);
16734 call->prev_execute_data = EX(call);
16735 EX(call) = call;
16736
16737 ZEND_VM_NEXT_OPCODE();
16738}
16739
16740static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16741{
16742 USE_OPLINE
16743 zval *value, *arg;
16744
16745 if (IS_CONST == IS_CONST) {
16746 SAVE_OPLINE();
16747 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16748 uint32_t arg_num;
16749 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
16750 if (UNEXPECTED(!arg)) {
16751 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16752 HANDLE_EXCEPTION();
16753 }
16754 } else {
16755 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
16756 }
16757
16758 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16759 ZVAL_COPY_VALUE(arg, value);
16760 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16761 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
16762 Z_ADDREF_P(arg);
16763 }
16764 }
16765 ZEND_VM_NEXT_OPCODE();
16766}
16767
16768static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16769{
16770 USE_OPLINE
16771 zval *op1, *op2;
16772 double d1, d2;
16773
16774 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16775 op2 = RT_CONSTANT(opline, opline->op2);
16776 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16777 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16778 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16779case_true:
16780 ZEND_VM_SMART_BRANCH_TRUE();
16781 } else {
16782case_false:
16783 ZEND_VM_SMART_BRANCH_FALSE();
16784 }
16785 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16786 d1 = (double)Z_LVAL_P(op1);
16787 d2 = Z_DVAL_P(op2);
16788 goto case_double;
16789 }
16790 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16791 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16792 d1 = Z_DVAL_P(op1);
16793 d2 = Z_DVAL_P(op2);
16794case_double:
16795 if (d1 == d2) {
16796 goto case_true;
16797 } else {
16798 goto case_false;
16799 }
16800 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16801 d1 = Z_DVAL_P(op1);
16802 d2 = (double)Z_LVAL_P(op2);
16803 goto case_double;
16804 }
16805 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16806 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16807 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16808
16809 if (result) {
16810 goto case_true;
16811 } else {
16812 goto case_false;
16813 }
16814 }
16815 }
16816 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16817}
16818
16819static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16820{
16821 USE_OPLINE
16822 zval *container;
16823 bool result;
16824 zend_ulong hval;
16825 zval *offset;
16826
16827 SAVE_OPLINE();
16828 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16829 offset = RT_CONSTANT(opline, opline->op2);
16830
16831 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16832 HashTable *ht;
16833 zval *value;
16834 zend_string *str;
16835
16836isset_dim_obj_array:
16837 ht = Z_ARRVAL_P(container);
16838isset_again:
16839 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
16840 str = Z_STR_P(offset);
16841 if (IS_CONST != IS_CONST) {
16842 if (ZEND_HANDLE_NUMERIC(str, hval)) {
16843 goto num_index_prop;
16844 }
16845 }
16846 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
16847 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
16848 hval = Z_LVAL_P(offset);
16849num_index_prop:
16850 value = zend_hash_index_find(ht, hval);
16851 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
16852 offset = Z_REFVAL_P(offset);
16853 goto isset_again;
16854 } else {
16855 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
16856 if (UNEXPECTED(EG(exception))) {
16857 result = 0;
16858 goto isset_dim_obj_exit;
16859 }
16860 }
16861
16862 if (!(opline->extended_value & ZEND_ISEMPTY)) {
16863 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
16864 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
16865 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
16866
16867 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
16868 /* avoid exception check */
16869
16870 ZEND_VM_SMART_BRANCH(result, 0);
16871 }
16872 } else {
16873 result = (value == NULL || !i_zend_is_true(value));
16874 }
16875 goto isset_dim_obj_exit;
16876 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
16877 container = Z_REFVAL_P(container);
16878 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16879 goto isset_dim_obj_array;
16880 }
16881 }
16882
16883 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
16884 offset++;
16885 }
16886 if (!(opline->extended_value & ZEND_ISEMPTY)) {
16887 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
16888 } else {
16889 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
16890 }
16891
16892isset_dim_obj_exit:
16893
16894 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16895 ZEND_VM_SMART_BRANCH(result, 1);
16896}
16897
16898static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16899{
16900 USE_OPLINE
16901 zval *container;
16902 int result;
16903 zval *offset;
16904 zend_string *name, *tmp_name;
16905
16906 SAVE_OPLINE();
16907 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16908 offset = RT_CONSTANT(opline, opline->op2);
16909
16910 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16911 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16912 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16913 container = Z_REFVAL_P(container);
16914 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
16915 result = (opline->extended_value & ZEND_ISEMPTY);
16916 goto isset_object_finish;
16917 }
16918 } else {
16919 result = (opline->extended_value & ZEND_ISEMPTY);
16920 goto isset_object_finish;
16921 }
16922 }
16923
16924 if (IS_CONST == IS_CONST) {
16925 name = Z_STR_P(offset);
16926 } else {
16927 name = zval_try_get_tmp_string(offset, &tmp_name);
16928 if (UNEXPECTED(!name)) {
16929 result = 0;
16930 goto isset_object_finish;
16931 }
16932 }
16933
16934 result =
16935 (opline->extended_value & ZEND_ISEMPTY) ^
16936 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));
16937
16938 if (IS_CONST != IS_CONST) {
16939 zend_tmp_string_release(tmp_name);
16940 }
16941
16942isset_object_finish:
16943
16944 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16945 ZEND_VM_SMART_BRANCH(result, 1);
16946}
16947
16948static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16949{
16950 USE_OPLINE
16951
16952 zval *key, *subject;
16953 HashTable *ht;
16954 bool result;
16955
16956 SAVE_OPLINE();
16957
16958 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16959 subject = RT_CONSTANT(opline, opline->op2);
16960
16961 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
16962array_key_exists_array:
16963 ht = Z_ARRVAL_P(subject);
16964 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
16965 } else {
16966 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
16967 subject = Z_REFVAL_P(subject);
16968 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
16969 goto array_key_exists_array;
16970 }
16971 }
16972 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
16973 result = 0;
16974 }
16975
16976 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16977 ZEND_VM_SMART_BRANCH(result, 1);
16978}
16979
16980static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16981{
16982 USE_OPLINE
16983 zval *expr;
16984 bool result;
16985
16986 SAVE_OPLINE();
16987 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16988
16989try_instanceof:
16990 if (Z_TYPE_P(expr) == IS_OBJECT) {
16991 zend_class_entry *ce;
16992
16993 if (IS_CONST == IS_CONST) {
16994 ce = CACHED_PTR(opline->extended_value);
16995 if (UNEXPECTED(ce == NULL)) {
16996 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);
16997 if (EXPECTED(ce)) {
16998 CACHE_PTR(opline->extended_value, ce);
16999 }
17000 }
17001 } else if (IS_CONST == IS_UNUSED) {
17002 ce = zend_fetch_class(NULL, opline->op2.num);
17003 if (UNEXPECTED(ce == NULL)) {
17004 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17005 ZVAL_UNDEF(EX_VAR(opline->result.var));
17006 HANDLE_EXCEPTION();
17007 }
17008 } else {
17009 ce = Z_CE_P(EX_VAR(opline->op2.var));
17010 }
17011 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
17012 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
17013 expr = Z_REFVAL_P(expr);
17014 goto try_instanceof;
17015 } else {
17016 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
17017 ZVAL_UNDEFINED_OP1();
17018 }
17019 result = 0;
17020 }
17021 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17022 ZEND_VM_SMART_BRANCH(result, 1);
17023}
17024
17025static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17026{
17027 USE_OPLINE
17028 zval *container, *dim, *value;
17029 zend_long offset;
17030 HashTable *ht;
17031
17032 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17033 dim = RT_CONSTANT(opline, opline->op2);
17034 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17035fetch_dim_r_index_array:
17036 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
17037 offset = Z_LVAL_P(dim);
17038 } else {
17039 SAVE_OPLINE();
17040 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
17041 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17042 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17043 }
17044 ht = Z_ARRVAL_P(container);
17045 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
17046 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17047 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17048 SAVE_OPLINE();
17049 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17050 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17051 } else {
17052 ZEND_VM_NEXT_OPCODE();
17053 }
17054 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17055 container = Z_REFVAL_P(container);
17056 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17057 goto fetch_dim_r_index_array;
17058 } else {
17059 goto fetch_dim_r_index_slow;
17060 }
17061 } else {
17062fetch_dim_r_index_slow:
17063 SAVE_OPLINE();
17064 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17065 dim++;
17066 }
17067 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17068 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17069 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17070 }
17071
17072fetch_dim_r_index_undef:
17073 ZVAL_NULL(EX_VAR(opline->result.var));
17074 SAVE_OPLINE();
17075 zend_undefined_offset(offset);
17076 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17077 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17078}
17079
17080static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17081{
17082 USE_OPLINE
17083 zval *container, *dim, *value;
17084 zend_long offset;
17085 HashTable *ht;
17086
17087 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17088 dim = EX_VAR(opline->op2.var);
17089 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17090fetch_dim_r_index_array:
17091 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
17092 offset = Z_LVAL_P(dim);
17093 } else {
17094 SAVE_OPLINE();
17095 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
17096 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17097 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17098 }
17099 ht = Z_ARRVAL_P(container);
17100 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
17101 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17102 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17103 SAVE_OPLINE();
17104 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17105 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17106 } else {
17107 ZEND_VM_NEXT_OPCODE();
17108 }
17109 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17110 container = Z_REFVAL_P(container);
17111 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17112 goto fetch_dim_r_index_array;
17113 } else {
17114 goto fetch_dim_r_index_slow;
17115 }
17116 } else {
17117fetch_dim_r_index_slow:
17118 SAVE_OPLINE();
17119 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17120 dim++;
17121 }
17122 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17123 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17124 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17125 }
17126
17127fetch_dim_r_index_undef:
17128 ZVAL_NULL(EX_VAR(opline->result.var));
17129 SAVE_OPLINE();
17130 zend_undefined_offset(offset);
17131 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17132 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17133}
17134
17135static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17136{
17137 USE_OPLINE
17138 zval *op1, *op2;
17139
17140 SAVE_OPLINE();
17141 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17142 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17143 div_function(EX_VAR(opline->result.var), op1, op2);
17144 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17145 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17146 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17147}
17148
17149static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17150{
17151 USE_OPLINE
17152 zval *op1, *op2;
17153
17154 SAVE_OPLINE();
17155 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17156 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17157 pow_function(EX_VAR(opline->result.var), op1, op2);
17158 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17159 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17160 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17161}
17162
17163static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17164{
17165 USE_OPLINE
17166 zval *op1, *op2;
17167
17168 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17169 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17170
17171 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
17172 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
17173 zend_string *op1_str = Z_STR_P(op1);
17174 zend_string *op2_str = Z_STR_P(op2);
17175 zend_string *str;
17176 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
17177
17178 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
17179 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17180 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
17181 } else {
17182 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
17183 }
17184 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17185 zend_string_release_ex(op1_str, 0);
17186 }
17187 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
17188 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17189 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
17190 } else {
17191 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
17192 }
17193 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17194 zend_string_release_ex(op2_str, 0);
17195 }
17196 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
17197 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
17198 size_t len = ZSTR_LEN(op1_str);
17199
17200 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
17201 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
17202 }
17203 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
17204 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17205 GC_ADD_FLAGS(str, flags);
17206 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17207 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17208 zend_string_release_ex(op2_str, 0);
17209 }
17210 } else {
17211 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
17212 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
17213 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17214 GC_ADD_FLAGS(str, flags);
17215 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17216 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17217 zend_string_release_ex(op1_str, 0);
17218 }
17219 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17220 zend_string_release_ex(op2_str, 0);
17221 }
17222 }
17223 ZEND_VM_NEXT_OPCODE();
17224 } else {
17225 SAVE_OPLINE();
17226
17227 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
17228 op1 = ZVAL_UNDEFINED_OP1();
17229 }
17230 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
17231 op2 = ZVAL_UNDEFINED_OP2();
17232 }
17233 concat_function(EX_VAR(opline->result.var), op1, op2);
17234 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17235 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17236 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17237 }
17238}
17239
17240static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17241{
17242 USE_OPLINE
17243 zval *op1, *op2;
17244 double d1, d2;
17245
17246 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17247 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17248 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17249 /* pass */
17250 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17251 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17252 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17253is_equal_true:
17254 ZEND_VM_SMART_BRANCH_TRUE_NONE();
17255 } else {
17256is_equal_false:
17257 ZEND_VM_SMART_BRANCH_FALSE_NONE();
17258 }
17259 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17260 d1 = (double)Z_LVAL_P(op1);
17261 d2 = Z_DVAL_P(op2);
17262 goto is_equal_double;
17263 }
17264 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17265 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17266 d1 = Z_DVAL_P(op1);
17267 d2 = Z_DVAL_P(op2);
17268is_equal_double:
17269 if (d1 == d2) {
17270 goto is_equal_true;
17271 } else {
17272 goto is_equal_false;
17273 }
17274 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17275 d1 = Z_DVAL_P(op1);
17276 d2 = (double)Z_LVAL_P(op2);
17277 goto is_equal_double;
17278 }
17279 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17280 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17281 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17282 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17283 zval_ptr_dtor_str(op1);
17284 }
17285 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17286 zval_ptr_dtor_str(op2);
17287 }
17288 if (result) {
17289 goto is_equal_true;
17290 } else {
17291 goto is_equal_false;
17292 }
17293 }
17294 }
17295 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17296}
17297
17298static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17299{
17300 USE_OPLINE
17301 zval *op1, *op2;
17302 double d1, d2;
17303
17304 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17305 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17306 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17307 /* pass */
17308 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17309 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17310 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17311is_equal_true:
17312 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
17313 } else {
17314is_equal_false:
17315 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
17316 }
17317 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17318 d1 = (double)Z_LVAL_P(op1);
17319 d2 = Z_DVAL_P(op2);
17320 goto is_equal_double;
17321 }
17322 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17323 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17324 d1 = Z_DVAL_P(op1);
17325 d2 = Z_DVAL_P(op2);
17326is_equal_double:
17327 if (d1 == d2) {
17328 goto is_equal_true;
17329 } else {
17330 goto is_equal_false;
17331 }
17332 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17333 d1 = Z_DVAL_P(op1);
17334 d2 = (double)Z_LVAL_P(op2);
17335 goto is_equal_double;
17336 }
17337 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17338 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17339 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17340 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17341 zval_ptr_dtor_str(op1);
17342 }
17343 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17344 zval_ptr_dtor_str(op2);
17345 }
17346 if (result) {
17347 goto is_equal_true;
17348 } else {
17349 goto is_equal_false;
17350 }
17351 }
17352 }
17353 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17354}
17355
17356static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17357{
17358 USE_OPLINE
17359 zval *op1, *op2;
17360 double d1, d2;
17361
17362 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17363 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17364 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17365 /* pass */
17366 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17367 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17368 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17369is_equal_true:
17370 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
17371 } else {
17372is_equal_false:
17373 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
17374 }
17375 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17376 d1 = (double)Z_LVAL_P(op1);
17377 d2 = Z_DVAL_P(op2);
17378 goto is_equal_double;
17379 }
17380 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17381 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17382 d1 = Z_DVAL_P(op1);
17383 d2 = Z_DVAL_P(op2);
17384is_equal_double:
17385 if (d1 == d2) {
17386 goto is_equal_true;
17387 } else {
17388 goto is_equal_false;
17389 }
17390 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17391 d1 = Z_DVAL_P(op1);
17392 d2 = (double)Z_LVAL_P(op2);
17393 goto is_equal_double;
17394 }
17395 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17396 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17397 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17398 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17399 zval_ptr_dtor_str(op1);
17400 }
17401 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17402 zval_ptr_dtor_str(op2);
17403 }
17404 if (result) {
17405 goto is_equal_true;
17406 } else {
17407 goto is_equal_false;
17408 }
17409 }
17410 }
17411 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17412}
17413
17414static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17415{
17416 USE_OPLINE
17417 zval *op1, *op2;
17418 double d1, d2;
17419
17420 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17421 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17422 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17423 /* pass */
17424 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17425 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17426 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17427is_not_equal_true:
17428 ZEND_VM_SMART_BRANCH_TRUE_NONE();
17429 } else {
17430is_not_equal_false:
17431 ZEND_VM_SMART_BRANCH_FALSE_NONE();
17432 }
17433 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17434 d1 = (double)Z_LVAL_P(op1);
17435 d2 = Z_DVAL_P(op2);
17436 goto is_not_equal_double;
17437 }
17438 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17439 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17440 d1 = Z_DVAL_P(op1);
17441 d2 = Z_DVAL_P(op2);
17442is_not_equal_double:
17443 if (d1 != d2) {
17444 goto is_not_equal_true;
17445 } else {
17446 goto is_not_equal_false;
17447 }
17448 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17449 d1 = Z_DVAL_P(op1);
17450 d2 = (double)Z_LVAL_P(op2);
17451 goto is_not_equal_double;
17452 }
17453 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17454 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17455 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17456 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17457 zval_ptr_dtor_str(op1);
17458 }
17459 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17460 zval_ptr_dtor_str(op2);
17461 }
17462 if (!result) {
17463 goto is_not_equal_true;
17464 } else {
17465 goto is_not_equal_false;
17466 }
17467 }
17468 }
17469 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17470}
17471
17472static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17473{
17474 USE_OPLINE
17475 zval *op1, *op2;
17476 double d1, d2;
17477
17478 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17479 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17480 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17481 /* pass */
17482 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17483 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17484 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17485is_not_equal_true:
17486 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
17487 } else {
17488is_not_equal_false:
17489 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
17490 }
17491 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17492 d1 = (double)Z_LVAL_P(op1);
17493 d2 = Z_DVAL_P(op2);
17494 goto is_not_equal_double;
17495 }
17496 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17497 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17498 d1 = Z_DVAL_P(op1);
17499 d2 = Z_DVAL_P(op2);
17500is_not_equal_double:
17501 if (d1 != d2) {
17502 goto is_not_equal_true;
17503 } else {
17504 goto is_not_equal_false;
17505 }
17506 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17507 d1 = Z_DVAL_P(op1);
17508 d2 = (double)Z_LVAL_P(op2);
17509 goto is_not_equal_double;
17510 }
17511 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17512 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17513 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17514 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17515 zval_ptr_dtor_str(op1);
17516 }
17517 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17518 zval_ptr_dtor_str(op2);
17519 }
17520 if (!result) {
17521 goto is_not_equal_true;
17522 } else {
17523 goto is_not_equal_false;
17524 }
17525 }
17526 }
17527 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17528}
17529
17530static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17531{
17532 USE_OPLINE
17533 zval *op1, *op2;
17534 double d1, d2;
17535
17536 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17537 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17538 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17539 /* pass */
17540 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17541 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17542 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17543is_not_equal_true:
17544 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
17545 } else {
17546is_not_equal_false:
17547 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
17548 }
17549 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17550 d1 = (double)Z_LVAL_P(op1);
17551 d2 = Z_DVAL_P(op2);
17552 goto is_not_equal_double;
17553 }
17554 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17555 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17556 d1 = Z_DVAL_P(op1);
17557 d2 = Z_DVAL_P(op2);
17558is_not_equal_double:
17559 if (d1 != d2) {
17560 goto is_not_equal_true;
17561 } else {
17562 goto is_not_equal_false;
17563 }
17564 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17565 d1 = Z_DVAL_P(op1);
17566 d2 = (double)Z_LVAL_P(op2);
17567 goto is_not_equal_double;
17568 }
17569 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17570 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17571 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17572 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17573 zval_ptr_dtor_str(op1);
17574 }
17575 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17576 zval_ptr_dtor_str(op2);
17577 }
17578 if (!result) {
17579 goto is_not_equal_true;
17580 } else {
17581 goto is_not_equal_false;
17582 }
17583 }
17584 }
17585 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17586}
17587
17588static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17589{
17590 USE_OPLINE
17591 zval *op1, *op2;
17592
17593 SAVE_OPLINE();
17594 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17595 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17596 compare_function(EX_VAR(opline->result.var), op1, op2);
17597 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17598 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17599 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17600}
17601
17602static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17603{
17604 USE_OPLINE
17605 zval *op1, *op2;
17606
17607 SAVE_OPLINE();
17608 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17609 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17610 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
17611 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17612 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17613 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17614}
17615
17616static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17617{
17618 USE_OPLINE
17619 zval *container, *dim, *value;
17620
17621 SAVE_OPLINE();
17622 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17623 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17624 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17625 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17626fetch_dim_r_array:
17627 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
17628 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17629 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17630 container = Z_REFVAL_P(container);
17631 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17632 goto fetch_dim_r_array;
17633 } else {
17634 goto fetch_dim_r_slow;
17635 }
17636 } else {
17637fetch_dim_r_slow:
17638 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17639 dim++;
17640 }
17641 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17642 }
17643 } else {
17644 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
17645 }
17646 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17647 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17648 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17649}
17650
17651static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17652{
17653 USE_OPLINE
17654 zval *container;
17655
17656 SAVE_OPLINE();
17657 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17658 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);
17659 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17660 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17661 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17662}
17663
17664static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17665{
17666 USE_OPLINE
17667 zval *container;
17668 void **cache_slot = NULL;
17669
17670 SAVE_OPLINE();
17671 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17672
17673 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17674 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17675 do {
17676 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17677 container = Z_REFVAL_P(container);
17678 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
17679 break;
17680 }
17681 }
17682 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
17683 ZVAL_UNDEFINED_OP1();
17684 }
17685 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17686 ZVAL_NULL(EX_VAR(opline->result.var));
17687 goto fetch_obj_r_finish;
17688 } while (0);
17689 }
17690
17691 /* here we are sure we are dealing with an object */
17692 do {
17693 zend_object *zobj = Z_OBJ_P(container);
17694 zend_string *name, *tmp_name;
17695 zval *retval;
17696
17697 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17698 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
17699
17700 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
17701 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
17702
17703 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
17704fetch_obj_r_simple:
17705 retval = OBJ_PROP(zobj, prop_offset);
17706 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
17707 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17708 goto fetch_obj_r_copy;
17709 } else {
17710fetch_obj_r_fast_copy:
17711 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17712 ZEND_VM_NEXT_OPCODE();
17713 }
17714 }
17715 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
17716 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
17717 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
17718 prop_offset = prop_info->offset;
17719 goto fetch_obj_r_simple;
17720 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
17721 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
17722 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
17723 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
17724
17725 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
17726 if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
17727 GC_ADDREF(zobj);
17728 }
17729 if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
17730 call_info |= ZEND_CALL_RELEASE_THIS;
17731 }
17732 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
17733 call->prev_execute_data = execute_data;
17734 call->call = NULL;
17735 call->return_value = EX_VAR(opline->result.var);
17736 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
17737
17738 execute_data = call;
17739 EG(current_execute_data) = execute_data;
17740 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
17741
17742#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
17743 opline = hook->op_array.opcodes;
17744#else
17745 EX(opline) = hook->op_array.opcodes;
17746#endif
17747 LOAD_OPLINE_EX();
17748
17749
17750 ZEND_VM_ENTER_EX();
17751 }
17752 /* Fall through to read_property for hooks. */
17753 } else if (EXPECTED(zobj->properties != NULL)) {
17754 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
17755 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17756 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
17757 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
17758
17759 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
17760 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
17761
17762 if (EXPECTED(p->key == name) ||
17763 (EXPECTED(p->h == ZSTR_H(name)) &&
17764 EXPECTED(p->key != NULL) &&
17765 EXPECTED(zend_string_equal_content(p->key, name)))) {
17766 retval = &p->val;
17767 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17768 goto fetch_obj_r_copy;
17769 } else {
17770 goto fetch_obj_r_fast_copy;
17771 }
17772 }
17773 }
17774 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
17775 }
17776 retval = zend_hash_find_known_hash(zobj->properties, name);
17777 if (EXPECTED(retval)) {
17778 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
17779 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
17780 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17781 goto fetch_obj_r_copy;
17782 } else {
17783 goto fetch_obj_r_fast_copy;
17784 }
17785 }
17786 }
17787 }
17788 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17789 } else {
17790 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
17791 if (UNEXPECTED(!name)) {
17792 ZVAL_UNDEF(EX_VAR(opline->result.var));
17793 break;
17794 }
17795 }
17796
17797#if ZEND_DEBUG
17798 /* For non-standard object handlers, verify a declared property type in debug builds.
17799 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
17800 zend_property_info *prop_info = NULL;
17801 if (zobj->handlers->read_property != zend_std_read_property) {
17802 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
17803 }
17804#endif
17805 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
17806#if ZEND_DEBUG
17807 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
17808 && ZEND_TYPE_IS_SET(prop_info->type)) {
17809 ZVAL_OPT_DEREF(retval);
17810 zend_verify_property_type(prop_info, retval, /* strict */ true);
17811 }
17812#endif
17813
17814 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17815 zend_tmp_string_release(tmp_name);
17816 }
17817
17818 if (retval != EX_VAR(opline->result.var)) {
17819fetch_obj_r_copy:
17820 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17821 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
17822 zend_unwrap_reference(retval);
17823 }
17824 } while (0);
17825
17826fetch_obj_r_finish:
17827 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17828 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17829 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17830}
17831
17832static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17833{
17834 USE_OPLINE
17835 zval *container;
17836 void **cache_slot = NULL;
17837
17838 SAVE_OPLINE();
17839 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17840
17841 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17842 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17843 do {
17844 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17845 container = Z_REFVAL_P(container);
17846 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
17847 break;
17848 }
17849 }
17850 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
17851 ZVAL_UNDEFINED_OP2();
17852 }
17853 ZVAL_NULL(EX_VAR(opline->result.var));
17854 goto fetch_obj_is_finish;
17855 } while (0);
17856 }
17857
17858 /* here we are sure we are dealing with an object */
17859 do {
17860 zend_object *zobj = Z_OBJ_P(container);
17861 zend_string *name, *tmp_name;
17862 zval *retval;
17863
17864 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17865 cache_slot = CACHE_ADDR(opline->extended_value);
17866
17867 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
17868 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
17869
17870 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
17871fetch_obj_is_simple:
17872 retval = OBJ_PROP(zobj, prop_offset);
17873 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
17874 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17875 goto fetch_obj_is_copy;
17876 } else {
17877fetch_obj_is_fast_copy:
17878 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17879 ZEND_VM_NEXT_OPCODE();
17880 }
17881 }
17882 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
17883 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
17884 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
17885 prop_offset = prop_info->offset;
17886 goto fetch_obj_is_simple;
17887 }
17888 /* Fall through to read_property for hooks. */
17889 } else if (EXPECTED(zobj->properties != NULL)) {
17890 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
17891 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17892 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
17893 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
17894
17895 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
17896 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
17897
17898 if (EXPECTED(p->key == name) ||
17899 (EXPECTED(p->h == ZSTR_H(name)) &&
17900 EXPECTED(p->key != NULL) &&
17901 EXPECTED(zend_string_equal_content(p->key, name)))) {
17902 retval = &p->val;
17903 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17904 goto fetch_obj_is_copy;
17905 } else {
17906 goto fetch_obj_is_fast_copy;
17907 }
17908 }
17909 }
17910 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
17911 }
17912 retval = zend_hash_find_known_hash(zobj->properties, name);
17913 if (EXPECTED(retval)) {
17914 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
17915 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
17916 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17917 goto fetch_obj_is_copy;
17918 } else {
17919 goto fetch_obj_is_fast_copy;
17920 }
17921 }
17922 }
17923 }
17924 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17925 } else {
17926 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
17927 if (UNEXPECTED(!name)) {
17928 ZVAL_UNDEF(EX_VAR(opline->result.var));
17929 break;
17930 }
17931 }
17932
17933 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
17934
17935 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17936 zend_tmp_string_release(tmp_name);
17937 }
17938
17939 if (retval != EX_VAR(opline->result.var)) {
17940fetch_obj_is_copy:
17941 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17942 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
17943 zend_unwrap_reference(retval);
17944 }
17945 } while (0);
17946
17947fetch_obj_is_finish:
17948 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17949 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17950 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17951}
17952
17953static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17954{
17955 USE_OPLINE
17956 zval *op1, *op2;
17957 zend_string *op1_str, *op2_str, *str;
17958
17959
17960 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17961 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17962 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
17963 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
17964 zend_string *op1_str = Z_STR_P(op1);
17965 zend_string *op2_str = Z_STR_P(op2);
17966 zend_string *str;
17967 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
17968
17969 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
17970 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17971 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
17972 } else {
17973 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
17974 }
17975 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17976 zend_string_release_ex(op1_str, 0);
17977 }
17978 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
17979 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17980 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
17981 } else {
17982 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
17983 }
17984 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17985 zend_string_release_ex(op2_str, 0);
17986 }
17987 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
17988 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
17989 size_t len = ZSTR_LEN(op1_str);
17990
17991 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
17992 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17993 GC_ADD_FLAGS(str, flags);
17994 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17995 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17996 zend_string_release_ex(op2_str, 0);
17997 }
17998 } else {
17999 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18000 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18001 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18002 GC_ADD_FLAGS(str, flags);
18003 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18004 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18005 zend_string_release_ex(op1_str, 0);
18006 }
18007 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18008 zend_string_release_ex(op2_str, 0);
18009 }
18010 }
18011 ZEND_VM_NEXT_OPCODE();
18012 }
18013
18014 SAVE_OPLINE();
18015 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18016 op1_str = Z_STR_P(op1);
18017 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
18018 op1_str = zend_string_copy(Z_STR_P(op1));
18019 } else {
18020 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18021 ZVAL_UNDEFINED_OP1();
18022 }
18023 op1_str = zval_get_string_func(op1);
18024 }
18025 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18026 op2_str = Z_STR_P(op2);
18027 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
18028 op2_str = zend_string_copy(Z_STR_P(op2));
18029 } else {
18030 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
18031 ZVAL_UNDEFINED_OP2();
18032 }
18033 op2_str = zval_get_string_func(op2);
18034 }
18035 do {
18036 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18037 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18038 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18039 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
18040 GC_ADDREF(op2_str);
18041 }
18042 }
18043 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18044 zend_string_release_ex(op1_str, 0);
18045 break;
18046 }
18047 }
18048 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18049 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18050 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18051 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
18052 GC_ADDREF(op1_str);
18053 }
18054 }
18055 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18056 zend_string_release_ex(op2_str, 0);
18057 break;
18058 }
18059 }
18060 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18061 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18062 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18063
18064 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
18065 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18066 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18067 zend_string_release_ex(op1_str, 0);
18068 }
18069 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18070 zend_string_release_ex(op2_str, 0);
18071 }
18072 } while (0);
18073 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18074 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18075 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18076}
18077
18078static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18079{
18080 USE_OPLINE
18081 zval *function_name;
18082 zval *object;
18083 zend_function *fbc;
18084 zend_class_entry *called_scope;
18085 zend_object *obj;
18086 zend_execute_data *call;
18087 uint32_t call_info;
18088
18089 SAVE_OPLINE();
18090
18091 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18092
18093 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18094 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18095 }
18096
18097 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
18098 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
18099 do {
18100 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
18101 function_name = Z_REFVAL_P(function_name);
18102 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
18103 break;
18104 }
18105 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
18106 ZVAL_UNDEFINED_OP2();
18107 if (UNEXPECTED(EG(exception) != NULL)) {
18108 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18109 HANDLE_EXCEPTION();
18110 }
18111 }
18112 zend_throw_error(NULL, "Method name must be a string");
18113 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18114 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18115 HANDLE_EXCEPTION();
18116 } while (0);
18117 }
18118
18119 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
18120 obj = Z_OBJ_P(object);
18121 } else {
18122 do {
18123 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
18124 obj = Z_OBJ_P(object);
18125 } else {
18126 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
18127 zend_reference *ref = Z_REF_P(object);
18128
18129 object = &ref->val;
18130 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
18131 obj = Z_OBJ_P(object);
18132 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
18133 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
18134 efree_size(ref, sizeof(zend_reference));
18135 } else {
18136 Z_ADDREF_P(object);
18137 }
18138 }
18139 break;
18140 }
18141 }
18142 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
18143 object = ZVAL_UNDEFINED_OP1();
18144 if (UNEXPECTED(EG(exception) != NULL)) {
18145 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18146 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18147 }
18148 HANDLE_EXCEPTION();
18149 }
18150 }
18151 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18152 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18153 }
18154 zend_invalid_method_call(object, function_name);
18155 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18156 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18157 HANDLE_EXCEPTION();
18158 }
18159 } while (0);
18160 }
18161
18162 called_scope = obj->ce;
18163
18164 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
18165 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
18166 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
18167 } else {
18168 zend_object *orig_obj = obj;
18169
18170 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18171 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18172 }
18173
18174 /* First, locate the function. */
18175 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));
18176 if (UNEXPECTED(fbc == NULL)) {
18177 if (EXPECTED(!EG(exception))) {
18178 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
18179 }
18180 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18181 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
18182 zend_objects_store_del(orig_obj);
18183 }
18184 HANDLE_EXCEPTION();
18185 }
18186 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
18187 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
18188 EXPECTED(obj == orig_obj)) {
18189 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
18190 }
18191 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
18192 GC_ADDREF(obj); /* For $this pointer */
18193 if (GC_DELREF(orig_obj) == 0) {
18194 zend_objects_store_del(orig_obj);
18195 }
18196 }
18197 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
18198 init_func_run_time_cache(&fbc->op_array);
18199 }
18200 }
18201
18202 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18203 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18204 }
18205
18206 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
18207 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
18208 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
18209 zend_objects_store_del(obj);
18210 if (UNEXPECTED(EG(exception))) {
18211 HANDLE_EXCEPTION();
18212 }
18213 }
18214 /* call static method */
18215 obj = (zend_object*)called_scope;
18216 call_info = ZEND_CALL_NESTED_FUNCTION;
18217 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
18218 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18219 GC_ADDREF(obj); /* For $this pointer */
18220 }
18221 /* CV may be changed indirectly (e.g. when it's a reference) */
18222 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
18223 }
18224
18225 call = zend_vm_stack_push_call_frame(call_info,
18226 fbc, opline->extended_value, obj);
18227 call->prev_execute_data = EX(call);
18228 EX(call) = call;
18229
18230 ZEND_VM_NEXT_OPCODE();
18231}
18232
18233static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18234{
18235 USE_OPLINE
18236 zval *op1, *op2;
18237 double d1, d2;
18238
18239 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18240 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18241 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
18242 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
18243 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
18244case_true:
18245 ZEND_VM_SMART_BRANCH_TRUE();
18246 } else {
18247case_false:
18248 ZEND_VM_SMART_BRANCH_FALSE();
18249 }
18250 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
18251 d1 = (double)Z_LVAL_P(op1);
18252 d2 = Z_DVAL_P(op2);
18253 goto case_double;
18254 }
18255 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
18256 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
18257 d1 = Z_DVAL_P(op1);
18258 d2 = Z_DVAL_P(op2);
18259case_double:
18260 if (d1 == d2) {
18261 goto case_true;
18262 } else {
18263 goto case_false;
18264 }
18265 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
18266 d1 = Z_DVAL_P(op1);
18267 d2 = (double)Z_LVAL_P(op2);
18268 goto case_double;
18269 }
18270 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
18271 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
18272 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
18273 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18274 if (result) {
18275 goto case_true;
18276 } else {
18277 goto case_false;
18278 }
18279 }
18280 }
18281 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18282}
18283
18284static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18285{
18286 USE_OPLINE
18287 zval *container;
18288 bool result;
18289 zend_ulong hval;
18290 zval *offset;
18291
18292 SAVE_OPLINE();
18293 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18294 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18295
18296 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18297 HashTable *ht;
18298 zval *value;
18299 zend_string *str;
18300
18301isset_dim_obj_array:
18302 ht = Z_ARRVAL_P(container);
18303isset_again:
18304 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
18305 str = Z_STR_P(offset);
18306 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18307 if (ZEND_HANDLE_NUMERIC(str, hval)) {
18308 goto num_index_prop;
18309 }
18310 }
18311 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18312 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
18313 hval = Z_LVAL_P(offset);
18314num_index_prop:
18315 value = zend_hash_index_find(ht, hval);
18316 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
18317 offset = Z_REFVAL_P(offset);
18318 goto isset_again;
18319 } else {
18320 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
18321 if (UNEXPECTED(EG(exception))) {
18322 result = 0;
18323 goto isset_dim_obj_exit;
18324 }
18325 }
18326
18327 if (!(opline->extended_value & ZEND_ISEMPTY)) {
18328 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
18329 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
18330 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
18331
18332 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
18333 /* avoid exception check */
18334 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18335 ZEND_VM_SMART_BRANCH(result, 0);
18336 }
18337 } else {
18338 result = (value == NULL || !i_zend_is_true(value));
18339 }
18340 goto isset_dim_obj_exit;
18341 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
18342 container = Z_REFVAL_P(container);
18343 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18344 goto isset_dim_obj_array;
18345 }
18346 }
18347
18348 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
18349 offset++;
18350 }
18351 if (!(opline->extended_value & ZEND_ISEMPTY)) {
18352 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
18353 } else {
18354 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
18355 }
18356
18357isset_dim_obj_exit:
18358 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18359 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18360 ZEND_VM_SMART_BRANCH(result, 1);
18361}
18362
18363static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18364{
18365 USE_OPLINE
18366 zval *container;
18367 int result;
18368 zval *offset;
18369 zend_string *name, *tmp_name;
18370
18371 SAVE_OPLINE();
18372 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18373 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18374
18375 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
18376 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
18377 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
18378 container = Z_REFVAL_P(container);
18379 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
18380 result = (opline->extended_value & ZEND_ISEMPTY);
18381 goto isset_object_finish;
18382 }
18383 } else {
18384 result = (opline->extended_value & ZEND_ISEMPTY);
18385 goto isset_object_finish;
18386 }
18387 }
18388
18389 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18390 name = Z_STR_P(offset);
18391 } else {
18392 name = zval_try_get_tmp_string(offset, &tmp_name);
18393 if (UNEXPECTED(!name)) {
18394 result = 0;
18395 goto isset_object_finish;
18396 }
18397 }
18398
18399 result =
18400 (opline->extended_value & ZEND_ISEMPTY) ^
18401 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));
18402
18403 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18404 zend_tmp_string_release(tmp_name);
18405 }
18406
18407isset_object_finish:
18408 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18409 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18410 ZEND_VM_SMART_BRANCH(result, 1);
18411}
18412
18413static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18414{
18415 USE_OPLINE
18416
18417 zval *key, *subject;
18418 HashTable *ht;
18419 bool result;
18420
18421 SAVE_OPLINE();
18422
18423 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18424 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18425
18426 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
18427array_key_exists_array:
18428 ht = Z_ARRVAL_P(subject);
18429 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
18430 } else {
18431 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
18432 subject = Z_REFVAL_P(subject);
18433 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
18434 goto array_key_exists_array;
18435 }
18436 }
18437 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
18438 result = 0;
18439 }
18440
18441 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18442 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18443 ZEND_VM_SMART_BRANCH(result, 1);
18444}
18445
18446static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18447{
18448 USE_OPLINE
18449 zval *expr;
18450 bool result;
18451
18452 SAVE_OPLINE();
18453 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18454
18455try_instanceof:
18456 if (Z_TYPE_P(expr) == IS_OBJECT) {
18457 zend_class_entry *ce;
18458
18459 if (IS_VAR == IS_CONST) {
18460 ce = CACHED_PTR(opline->extended_value);
18461 if (UNEXPECTED(ce == NULL)) {
18462 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);
18463 if (EXPECTED(ce)) {
18464 CACHE_PTR(opline->extended_value, ce);
18465 }
18466 }
18467 } else if (IS_VAR == IS_UNUSED) {
18468 ce = zend_fetch_class(NULL, opline->op2.num);
18469 if (UNEXPECTED(ce == NULL)) {
18470 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18471 ZVAL_UNDEF(EX_VAR(opline->result.var));
18472 HANDLE_EXCEPTION();
18473 }
18474 } else {
18475 ce = Z_CE_P(EX_VAR(opline->op2.var));
18476 }
18477 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
18478 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
18479 expr = Z_REFVAL_P(expr);
18480 goto try_instanceof;
18481 } else {
18482 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
18483 ZVAL_UNDEFINED_OP1();
18484 }
18485 result = 0;
18486 }
18487 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18488 ZEND_VM_SMART_BRANCH(result, 1);
18489}
18490
18491static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
18492{
18493 USE_OPLINE
18494 zval *varname;
18495 zval *retval;
18496 zend_string *name, *tmp_name;
18497 HashTable *target_symbol_table;
18498
18499 SAVE_OPLINE();
18500 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18501
18502 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18503 name = Z_STR_P(varname);
18504 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18505 name = Z_STR_P(varname);
18506 tmp_name = NULL;
18507 } else {
18508 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18509 ZVAL_UNDEFINED_OP1();
18510 }
18511 name = zval_try_get_tmp_string(varname, &tmp_name);
18512 if (UNEXPECTED(!name)) {
18513 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18514 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18515 }
18516 ZVAL_UNDEF(EX_VAR(opline->result.var));
18517 HANDLE_EXCEPTION();
18518 }
18519 }
18520
18521 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18522 retval = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18523 if (retval == NULL) {
18524 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18525fetch_this:
18526 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
18527 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18528 zend_tmp_string_release(tmp_name);
18529 }
18530 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18531 }
18532 if (type == BP_VAR_W) {
18533 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
18534 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18535 retval = &EG(uninitialized_zval);
18536 } else {
18537 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18538 /* Keep name alive in case an error handler tries to free it. */
18539 zend_string_addref(name);
18540 }
18541 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18542 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18543 if (type == BP_VAR_RW && !EG(exception)) {
18544 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
18545 } else {
18546 retval = &EG(uninitialized_zval);
18547 }
18548 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18549 zend_string_release(name);
18550 }
18551 }
18552 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
18553 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
18554 retval = Z_INDIRECT_P(retval);
18555 if (Z_TYPE_P(retval) == IS_UNDEF) {
18556 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18557 goto fetch_this;
18558 }
18559 if (type == BP_VAR_W) {
18560 ZVAL_NULL(retval);
18561 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18562 retval = &EG(uninitialized_zval);
18563 } else {
18564 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18565 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18566 if (type == BP_VAR_RW && !EG(exception)) {
18567 ZVAL_NULL(retval);
18568 } else {
18569 retval = &EG(uninitialized_zval);
18570 }
18571 }
18572 }
18573 }
18574
18575 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18576 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18577 }
18578
18579 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18580 zend_tmp_string_release(tmp_name);
18581 }
18582
18583 ZEND_ASSERT(retval != NULL);
18584 if (type == BP_VAR_R || type == BP_VAR_IS) {
18585 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18586 } else {
18587 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
18588 }
18589 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18590}
18591
18592static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18593{
18594 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18595}
18596
18597static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18598{
18599 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18600}
18601
18602static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18603{
18604 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18605}
18606
18607static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18608{
18609 int fetch_type =
18610 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
18611 BP_VAR_W : BP_VAR_R;
18612 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18613}
18614
18615static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18616{
18617 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18618}
18619
18620static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18621{
18622 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18623}
18624
18625/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
18626static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18627{
18628 USE_OPLINE
18629 zval *value, *arg;
18630
18631 if (IS_UNUSED == IS_CONST) {
18632 SAVE_OPLINE();
18633 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
18634 uint32_t arg_num;
18635 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
18636 if (UNEXPECTED(!arg)) {
18637 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18638 HANDLE_EXCEPTION();
18639 }
18640 } else {
18641 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
18642 }
18643
18644 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18645 ZVAL_COPY_VALUE(arg, value);
18646 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18647 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
18648 Z_ADDREF_P(arg);
18649 }
18650 }
18651 ZEND_VM_NEXT_OPCODE();
18652}
18653
18654static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18655{
18656 USE_OPLINE
18657 zval *varname;
18658 zend_string *name, *tmp_name;
18659 HashTable *target_symbol_table;
18660
18661 SAVE_OPLINE();
18662
18663 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18664
18665 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18666 name = Z_STR_P(varname);
18667 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18668 name = Z_STR_P(varname);
18669 tmp_name = NULL;
18670 } else {
18671 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18672 varname = ZVAL_UNDEFINED_OP1();
18673 }
18674 name = zval_try_get_tmp_string(varname, &tmp_name);
18675 if (UNEXPECTED(!name)) {
18676 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18677 HANDLE_EXCEPTION();
18678 }
18679 }
18680
18681 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18682 zend_hash_del_ind(target_symbol_table, name);
18683
18684 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18685 zend_tmp_string_release(tmp_name);
18686 }
18687 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18688 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18689}
18690
18691/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
18692static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18693{
18694 USE_OPLINE
18695 zval *value;
18696 bool result;
18697 zval *varname;
18698 zend_string *name, *tmp_name;
18699 HashTable *target_symbol_table;
18700
18701 SAVE_OPLINE();
18702 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18703 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18704 name = Z_STR_P(varname);
18705 } else {
18706 name = zval_get_tmp_string(varname, &tmp_name);
18707 }
18708
18709 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18710 value = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18711
18712 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18713 zend_tmp_string_release(tmp_name);
18714 }
18715 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18716
18717 if (!value) {
18718 result = (opline->extended_value & ZEND_ISEMPTY);
18719 } else {
18720 if (Z_TYPE_P(value) == IS_INDIRECT) {
18721 value = Z_INDIRECT_P(value);
18722 }
18723 if (!(opline->extended_value & ZEND_ISEMPTY)) {
18724 if (Z_ISREF_P(value)) {
18725 value = Z_REFVAL_P(value);
18726 }
18727 result = Z_TYPE_P(value) > IS_NULL;
18728 } else {
18729 result = !i_zend_is_true(value);
18730 }
18731 }
18732
18733 ZEND_VM_SMART_BRANCH(result, true);
18734}
18735
18736/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
18737static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18738{
18739 USE_OPLINE
18740 zval *expr;
18741 bool result;
18742
18743 SAVE_OPLINE();
18744 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18745
18746try_instanceof:
18747 if (Z_TYPE_P(expr) == IS_OBJECT) {
18748 zend_class_entry *ce;
18749
18750 if (IS_UNUSED == IS_CONST) {
18751 ce = CACHED_PTR(opline->extended_value);
18752 if (UNEXPECTED(ce == NULL)) {
18753 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);
18754 if (EXPECTED(ce)) {
18755 CACHE_PTR(opline->extended_value, ce);
18756 }
18757 }
18758 } else if (IS_UNUSED == IS_UNUSED) {
18759 ce = zend_fetch_class(NULL, opline->op2.num);
18760 if (UNEXPECTED(ce == NULL)) {
18761 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18762 ZVAL_UNDEF(EX_VAR(opline->result.var));
18763 HANDLE_EXCEPTION();
18764 }
18765 } else {
18766 ce = Z_CE_P(EX_VAR(opline->op2.var));
18767 }
18768 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
18769 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
18770 expr = Z_REFVAL_P(expr);
18771 goto try_instanceof;
18772 } else {
18773 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
18774 ZVAL_UNDEFINED_OP1();
18775 }
18776 result = 0;
18777 }
18778 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18779 ZEND_VM_SMART_BRANCH(result, 1);
18780}
18781
18782static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18783{
18784 USE_OPLINE
18785 zval *op1;
18786 zend_long count;
18787
18788 SAVE_OPLINE();
18789 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18790
18791 while (1) {
18792 if (Z_TYPE_P(op1) == IS_ARRAY) {
18793 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
18794 break;
18795 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
18796 zend_object *zobj = Z_OBJ_P(op1);
18797
18798 /* first, we check if the handler is defined */
18799 if (zobj->handlers->count_elements) {
18800 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
18801 break;
18802 }
18803 if (UNEXPECTED(EG(exception))) {
18804 count = 0;
18805 break;
18806 }
18807 }
18808
18809 /* if not and the object implements Countable we call its count() method */
18810 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
18811 zval retval;
18812
18813 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
18814 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
18815 count = zval_get_long(&retval);
18816 zval_ptr_dtor(&retval);
18817 break;
18818 }
18819
18820 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
18821 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
18822 op1 = Z_REFVAL_P(op1);
18823 continue;
18824 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18825 ZVAL_UNDEFINED_OP1();
18826 }
18827 count = 0;
18828 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));
18829 break;
18830 }
18831
18832 ZVAL_LONG(EX_VAR(opline->result.var), count);
18833 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18834 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18835}
18836
18837static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18838{
18839 USE_OPLINE
18840 zend_array *ht = Z_ARRVAL_P(_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC));
18841 ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
18842 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
18843 SAVE_OPLINE();
18844 zend_array_destroy(ht);
18845 if (EG(exception)) {
18846 HANDLE_EXCEPTION();
18847 }
18848 }
18849 ZEND_VM_NEXT_OPCODE();
18850}
18851
18852static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18853{
18854 USE_OPLINE
18855
18856 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
18857 SAVE_OPLINE();
18858 if (UNEXPECTED(!EX(func)->common.scope)) {
18859 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
18860 ZVAL_UNDEF(EX_VAR(opline->result.var));
18861 HANDLE_EXCEPTION();
18862 } else {
18863 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
18864 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
18865 if (UNEXPECTED(EG(exception))) {
18866 HANDLE_EXCEPTION();
18867 }
18868 ZEND_VM_NEXT_OPCODE();
18869 }
18870 } else {
18871 zval *op1;
18872
18873 SAVE_OPLINE();
18874 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18875 while (1) {
18876 if (Z_TYPE_P(op1) == IS_OBJECT) {
18877 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
18878 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
18879 op1 = Z_REFVAL_P(op1);
18880 continue;
18881 } else {
18882 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18883 ZVAL_UNDEFINED_OP1();
18884 }
18885 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
18886 ZVAL_UNDEF(EX_VAR(opline->result.var));
18887 }
18888 break;
18889 }
18890 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18891 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18892 }
18893}
18894
18895static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18896{
18897 USE_OPLINE
18898 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18899 zval *result = EX_VAR(opline->result.var);
18900 ZVAL_COPY(result, value);
18901 ZEND_VM_NEXT_OPCODE();
18902}
18903
18904static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18905{
18906 USE_OPLINE
18907 zval *op1, *op2;
18908
18909 SAVE_OPLINE();
18910 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18911 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
18912 div_function(EX_VAR(opline->result.var), op1, op2);
18913 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18914
18915 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18916}
18917
18918static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18919{
18920 USE_OPLINE
18921 zval *op1, *op2;
18922
18923 SAVE_OPLINE();
18924 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18925 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
18926 pow_function(EX_VAR(opline->result.var), op1, op2);
18927 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18928
18929 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18930}
18931
18932static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18933{
18934 USE_OPLINE
18935 zval *op1, *op2;
18936
18937 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18938 op2 = EX_VAR(opline->op2.var);
18939
18940 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
18941 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
18942 zend_string *op1_str = Z_STR_P(op1);
18943 zend_string *op2_str = Z_STR_P(op2);
18944 zend_string *str;
18945 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
18946
18947 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18948 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
18949 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
18950 } else {
18951 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18952 }
18953 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18954 zend_string_release_ex(op1_str, 0);
18955 }
18956 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18957 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
18958 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
18959 } else {
18960 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18961 }
18962 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18963 zend_string_release_ex(op2_str, 0);
18964 }
18965 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
18966 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
18967 size_t len = ZSTR_LEN(op1_str);
18968
18969 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
18970 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
18971 }
18972 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
18973 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18974 GC_ADD_FLAGS(str, flags);
18975 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18976 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18977 zend_string_release_ex(op2_str, 0);
18978 }
18979 } else {
18980 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18981 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18982 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18983 GC_ADD_FLAGS(str, flags);
18984 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18985 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18986 zend_string_release_ex(op1_str, 0);
18987 }
18988 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18989 zend_string_release_ex(op2_str, 0);
18990 }
18991 }
18992 ZEND_VM_NEXT_OPCODE();
18993 } else {
18994 SAVE_OPLINE();
18995
18996 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18997 op1 = ZVAL_UNDEFINED_OP1();
18998 }
18999 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
19000 op2 = ZVAL_UNDEFINED_OP2();
19001 }
19002 concat_function(EX_VAR(opline->result.var), op1, op2);
19003 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19004
19005 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19006 }
19007}
19008
19009static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19010{
19011 USE_OPLINE
19012 zval *op1, *op2;
19013
19014 SAVE_OPLINE();
19015 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19016 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19017 compare_function(EX_VAR(opline->result.var), op1, op2);
19018 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19019
19020 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19021}
19022
19023static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19024{
19025 USE_OPLINE
19026 zval *container, *dim, *value;
19027
19028 SAVE_OPLINE();
19029 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19030 dim = EX_VAR(opline->op2.var);
19031 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
19032 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19033fetch_dim_r_array:
19034 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
19035 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
19036 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
19037 container = Z_REFVAL_P(container);
19038 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19039 goto fetch_dim_r_array;
19040 } else {
19041 goto fetch_dim_r_slow;
19042 }
19043 } else {
19044fetch_dim_r_slow:
19045 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
19046 dim++;
19047 }
19048 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
19049 }
19050 } else {
19051 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
19052 }
19053
19054 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19055 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19056}
19057
19058static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19059{
19060 USE_OPLINE
19061 zval *container;
19062
19063 SAVE_OPLINE();
19064 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19065 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
19066
19067 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19068 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19069}
19070
19071static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19072{
19073 USE_OPLINE
19074 zval *container;
19075 void **cache_slot = NULL;
19076
19077 SAVE_OPLINE();
19078 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19079
19080 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19081 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19082 do {
19083 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19084 container = Z_REFVAL_P(container);
19085 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
19086 break;
19087 }
19088 }
19089 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
19090 ZVAL_UNDEFINED_OP1();
19091 }
19092 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19093 ZVAL_NULL(EX_VAR(opline->result.var));
19094 goto fetch_obj_r_finish;
19095 } while (0);
19096 }
19097
19098 /* here we are sure we are dealing with an object */
19099 do {
19100 zend_object *zobj = Z_OBJ_P(container);
19101 zend_string *name, *tmp_name;
19102 zval *retval;
19103
19104 if (IS_CV == IS_CONST) {
19105 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
19106
19107 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
19108 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
19109
19110 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
19111fetch_obj_r_simple:
19112 retval = OBJ_PROP(zobj, prop_offset);
19113 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
19114 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19115 goto fetch_obj_r_copy;
19116 } else {
19117fetch_obj_r_fast_copy:
19118 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19119 ZEND_VM_NEXT_OPCODE();
19120 }
19121 }
19122 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
19123 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
19124 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
19125 prop_offset = prop_info->offset;
19126 goto fetch_obj_r_simple;
19127 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
19128 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
19129 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
19130 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
19131
19132 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
19133 if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
19134 GC_ADDREF(zobj);
19135 }
19136 if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
19137 call_info |= ZEND_CALL_RELEASE_THIS;
19138 }
19139 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
19140 call->prev_execute_data = execute_data;
19141 call->call = NULL;
19142 call->return_value = EX_VAR(opline->result.var);
19143 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
19144
19145 execute_data = call;
19146 EG(current_execute_data) = execute_data;
19147 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
19148
19149#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
19150 opline = hook->op_array.opcodes;
19151#else
19152 EX(opline) = hook->op_array.opcodes;
19153#endif
19154 LOAD_OPLINE_EX();
19155
19156
19157 ZEND_VM_ENTER_EX();
19158 }
19159 /* Fall through to read_property for hooks. */
19160 } else if (EXPECTED(zobj->properties != NULL)) {
19161 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
19162 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19163 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
19164 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
19165
19166 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
19167 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
19168
19169 if (EXPECTED(p->key == name) ||
19170 (EXPECTED(p->h == ZSTR_H(name)) &&
19171 EXPECTED(p->key != NULL) &&
19172 EXPECTED(zend_string_equal_content(p->key, name)))) {
19173 retval = &p->val;
19174 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19175 goto fetch_obj_r_copy;
19176 } else {
19177 goto fetch_obj_r_fast_copy;
19178 }
19179 }
19180 }
19181 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
19182 }
19183 retval = zend_hash_find_known_hash(zobj->properties, name);
19184 if (EXPECTED(retval)) {
19185 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
19186 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
19187 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19188 goto fetch_obj_r_copy;
19189 } else {
19190 goto fetch_obj_r_fast_copy;
19191 }
19192 }
19193 }
19194 }
19195 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19196 } else {
19197 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
19198 if (UNEXPECTED(!name)) {
19199 ZVAL_UNDEF(EX_VAR(opline->result.var));
19200 break;
19201 }
19202 }
19203
19204#if ZEND_DEBUG
19205 /* For non-standard object handlers, verify a declared property type in debug builds.
19206 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
19207 zend_property_info *prop_info = NULL;
19208 if (zobj->handlers->read_property != zend_std_read_property) {
19209 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
19210 }
19211#endif
19212 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
19213#if ZEND_DEBUG
19214 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
19215 && ZEND_TYPE_IS_SET(prop_info->type)) {
19216 ZVAL_OPT_DEREF(retval);
19217 zend_verify_property_type(prop_info, retval, /* strict */ true);
19218 }
19219#endif
19220
19221 if (IS_CV != IS_CONST) {
19222 zend_tmp_string_release(tmp_name);
19223 }
19224
19225 if (retval != EX_VAR(opline->result.var)) {
19226fetch_obj_r_copy:
19227 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19228 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
19229 zend_unwrap_reference(retval);
19230 }
19231 } while (0);
19232
19233fetch_obj_r_finish:
19234
19235 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19236 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19237}
19238
19239static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19240{
19241 USE_OPLINE
19242 zval *container;
19243 void **cache_slot = NULL;
19244
19245 SAVE_OPLINE();
19246 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19247
19248 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19249 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19250 do {
19251 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19252 container = Z_REFVAL_P(container);
19253 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
19254 break;
19255 }
19256 }
19257 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
19258 ZVAL_UNDEFINED_OP2();
19259 }
19260 ZVAL_NULL(EX_VAR(opline->result.var));
19261 goto fetch_obj_is_finish;
19262 } while (0);
19263 }
19264
19265 /* here we are sure we are dealing with an object */
19266 do {
19267 zend_object *zobj = Z_OBJ_P(container);
19268 zend_string *name, *tmp_name;
19269 zval *retval;
19270
19271 if (IS_CV == IS_CONST) {
19272 cache_slot = CACHE_ADDR(opline->extended_value);
19273
19274 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
19275 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
19276
19277 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
19278fetch_obj_is_simple:
19279 retval = OBJ_PROP(zobj, prop_offset);
19280 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
19281 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19282 goto fetch_obj_is_copy;
19283 } else {
19284fetch_obj_is_fast_copy:
19285 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19286 ZEND_VM_NEXT_OPCODE();
19287 }
19288 }
19289 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
19290 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
19291 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
19292 prop_offset = prop_info->offset;
19293 goto fetch_obj_is_simple;
19294 }
19295 /* Fall through to read_property for hooks. */
19296 } else if (EXPECTED(zobj->properties != NULL)) {
19297 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
19298 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19299 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
19300 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
19301
19302 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
19303 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
19304
19305 if (EXPECTED(p->key == name) ||
19306 (EXPECTED(p->h == ZSTR_H(name)) &&
19307 EXPECTED(p->key != NULL) &&
19308 EXPECTED(zend_string_equal_content(p->key, name)))) {
19309 retval = &p->val;
19310 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19311 goto fetch_obj_is_copy;
19312 } else {
19313 goto fetch_obj_is_fast_copy;
19314 }
19315 }
19316 }
19317 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
19318 }
19319 retval = zend_hash_find_known_hash(zobj->properties, name);
19320 if (EXPECTED(retval)) {
19321 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
19322 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
19323 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19324 goto fetch_obj_is_copy;
19325 } else {
19326 goto fetch_obj_is_fast_copy;
19327 }
19328 }
19329 }
19330 }
19331 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19332 } else {
19333 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
19334 if (UNEXPECTED(!name)) {
19335 ZVAL_UNDEF(EX_VAR(opline->result.var));
19336 break;
19337 }
19338 }
19339
19340 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
19341
19342 if (IS_CV != IS_CONST) {
19343 zend_tmp_string_release(tmp_name);
19344 }
19345
19346 if (retval != EX_VAR(opline->result.var)) {
19347fetch_obj_is_copy:
19348 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19349 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
19350 zend_unwrap_reference(retval);
19351 }
19352 } while (0);
19353
19354fetch_obj_is_finish:
19355
19356 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19357 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19358}
19359
19360static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19361{
19362 USE_OPLINE
19363 zval *op1, *op2;
19364 zend_string *op1_str, *op2_str, *str;
19365
19366
19367 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19368 op2 = EX_VAR(opline->op2.var);
19369 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
19370 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
19371 zend_string *op1_str = Z_STR_P(op1);
19372 zend_string *op2_str = Z_STR_P(op2);
19373 zend_string *str;
19374 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
19375
19376 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
19377 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
19378 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
19379 } else {
19380 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
19381 }
19382 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19383 zend_string_release_ex(op1_str, 0);
19384 }
19385 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
19386 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
19387 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
19388 } else {
19389 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
19390 }
19391 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19392 zend_string_release_ex(op2_str, 0);
19393 }
19394 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
19395 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
19396 size_t len = ZSTR_LEN(op1_str);
19397
19398 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
19399 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19400 GC_ADD_FLAGS(str, flags);
19401 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19402 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19403 zend_string_release_ex(op2_str, 0);
19404 }
19405 } else {
19406 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
19407 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
19408 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19409 GC_ADD_FLAGS(str, flags);
19410 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19411 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19412 zend_string_release_ex(op1_str, 0);
19413 }
19414 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19415 zend_string_release_ex(op2_str, 0);
19416 }
19417 }
19418 ZEND_VM_NEXT_OPCODE();
19419 }
19420
19421 SAVE_OPLINE();
19422 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
19423 op1_str = Z_STR_P(op1);
19424 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
19425 op1_str = zend_string_copy(Z_STR_P(op1));
19426 } else {
19427 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
19428 ZVAL_UNDEFINED_OP1();
19429 }
19430 op1_str = zval_get_string_func(op1);
19431 }
19432 if (IS_CV == IS_CONST) {
19433 op2_str = Z_STR_P(op2);
19434 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
19435 op2_str = zend_string_copy(Z_STR_P(op2));
19436 } else {
19437 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
19438 ZVAL_UNDEFINED_OP2();
19439 }
19440 op2_str = zval_get_string_func(op2);
19441 }
19442 do {
19443 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
19444 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
19445 if (IS_CV == IS_CONST) {
19446 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
19447 GC_ADDREF(op2_str);
19448 }
19449 }
19450 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
19451 zend_string_release_ex(op1_str, 0);
19452 break;
19453 }
19454 }
19455 if (IS_CV != IS_CONST) {
19456 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
19457 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
19458 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
19459 GC_ADDREF(op1_str);
19460 }
19461 }
19462 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
19463 zend_string_release_ex(op2_str, 0);
19464 break;
19465 }
19466 }
19467 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
19468 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
19469 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19470
19471 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
19472 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19473 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
19474 zend_string_release_ex(op1_str, 0);
19475 }
19476 if (IS_CV != IS_CONST) {
19477 zend_string_release_ex(op2_str, 0);
19478 }
19479 } while (0);
19480 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19481
19482 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19483}
19484
19485static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19486{
19487 USE_OPLINE
19488 zval *function_name;
19489 zval *object;
19490 zend_function *fbc;
19491 zend_class_entry *called_scope;
19492 zend_object *obj;
19493 zend_execute_data *call;
19494 uint32_t call_info;
19495
19496 SAVE_OPLINE();
19497
19498 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19499
19500 if (IS_CV != IS_CONST) {
19501 function_name = EX_VAR(opline->op2.var);
19502 }
19503
19504 if (IS_CV != IS_CONST &&
19505 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
19506 do {
19507 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
19508 function_name = Z_REFVAL_P(function_name);
19509 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
19510 break;
19511 }
19512 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
19513 ZVAL_UNDEFINED_OP2();
19514 if (UNEXPECTED(EG(exception) != NULL)) {
19515 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19516 HANDLE_EXCEPTION();
19517 }
19518 }
19519 zend_throw_error(NULL, "Method name must be a string");
19520
19521 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19522 HANDLE_EXCEPTION();
19523 } while (0);
19524 }
19525
19526 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
19527 obj = Z_OBJ_P(object);
19528 } else {
19529 do {
19530 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
19531 obj = Z_OBJ_P(object);
19532 } else {
19533 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
19534 zend_reference *ref = Z_REF_P(object);
19535
19536 object = &ref->val;
19537 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
19538 obj = Z_OBJ_P(object);
19539 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
19540 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19541 efree_size(ref, sizeof(zend_reference));
19542 } else {
19543 Z_ADDREF_P(object);
19544 }
19545 }
19546 break;
19547 }
19548 }
19549 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
19550 object = ZVAL_UNDEFINED_OP1();
19551 if (UNEXPECTED(EG(exception) != NULL)) {
19552 if (IS_CV != IS_CONST) {
19553
19554 }
19555 HANDLE_EXCEPTION();
19556 }
19557 }
19558 if (IS_CV == IS_CONST) {
19559 function_name = EX_VAR(opline->op2.var);
19560 }
19561 zend_invalid_method_call(object, function_name);
19562
19563 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19564 HANDLE_EXCEPTION();
19565 }
19566 } while (0);
19567 }
19568
19569 called_scope = obj->ce;
19570
19571 if (IS_CV == IS_CONST &&
19572 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
19573 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
19574 } else {
19575 zend_object *orig_obj = obj;
19576
19577 if (IS_CV == IS_CONST) {
19578 function_name = EX_VAR(opline->op2.var);
19579 }
19580
19581 /* First, locate the function. */
19582 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
19583 if (UNEXPECTED(fbc == NULL)) {
19584 if (EXPECTED(!EG(exception))) {
19585 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
19586 }
19587
19588 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
19589 zend_objects_store_del(orig_obj);
19590 }
19591 HANDLE_EXCEPTION();
19592 }
19593 if (IS_CV == IS_CONST &&
19594 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
19595 EXPECTED(obj == orig_obj)) {
19596 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
19597 }
19598 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
19599 GC_ADDREF(obj); /* For $this pointer */
19600 if (GC_DELREF(orig_obj) == 0) {
19601 zend_objects_store_del(orig_obj);
19602 }
19603 }
19604 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
19605 init_func_run_time_cache(&fbc->op_array);
19606 }
19607 }
19608
19609 if (IS_CV != IS_CONST) {
19610
19611 }
19612
19613 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
19614 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
19615 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
19616 zend_objects_store_del(obj);
19617 if (UNEXPECTED(EG(exception))) {
19618 HANDLE_EXCEPTION();
19619 }
19620 }
19621 /* call static method */
19622 obj = (zend_object*)called_scope;
19623 call_info = ZEND_CALL_NESTED_FUNCTION;
19624 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
19625 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
19626 GC_ADDREF(obj); /* For $this pointer */
19627 }
19628 /* CV may be changed indirectly (e.g. when it's a reference) */
19629 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
19630 }
19631
19632 call = zend_vm_stack_push_call_frame(call_info,
19633 fbc, opline->extended_value, obj);
19634 call->prev_execute_data = EX(call);
19635 EX(call) = call;
19636
19637 ZEND_VM_NEXT_OPCODE();
19638}
19639
19640static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19641{
19642 USE_OPLINE
19643 zval *op1, *op2;
19644 double d1, d2;
19645
19646 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19647 op2 = EX_VAR(opline->op2.var);
19648 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
19649 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19650 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
19651case_true:
19652 ZEND_VM_SMART_BRANCH_TRUE();
19653 } else {
19654case_false:
19655 ZEND_VM_SMART_BRANCH_FALSE();
19656 }
19657 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19658 d1 = (double)Z_LVAL_P(op1);
19659 d2 = Z_DVAL_P(op2);
19660 goto case_double;
19661 }
19662 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
19663 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19664 d1 = Z_DVAL_P(op1);
19665 d2 = Z_DVAL_P(op2);
19666case_double:
19667 if (d1 == d2) {
19668 goto case_true;
19669 } else {
19670 goto case_false;
19671 }
19672 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19673 d1 = Z_DVAL_P(op1);
19674 d2 = (double)Z_LVAL_P(op2);
19675 goto case_double;
19676 }
19677 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
19678 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
19679 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
19680
19681 if (result) {
19682 goto case_true;
19683 } else {
19684 goto case_false;
19685 }
19686 }
19687 }
19688 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
19689}
19690
19691static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19692{
19693 USE_OPLINE
19694 zval *container;
19695 bool result;
19696 zend_ulong hval;
19697 zval *offset;
19698
19699 SAVE_OPLINE();
19700 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19701 offset = EX_VAR(opline->op2.var);
19702
19703 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19704 HashTable *ht;
19705 zval *value;
19706 zend_string *str;
19707
19708isset_dim_obj_array:
19709 ht = Z_ARRVAL_P(container);
19710isset_again:
19711 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
19712 str = Z_STR_P(offset);
19713 if (IS_CV != IS_CONST) {
19714 if (ZEND_HANDLE_NUMERIC(str, hval)) {
19715 goto num_index_prop;
19716 }
19717 }
19718 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
19719 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
19720 hval = Z_LVAL_P(offset);
19721num_index_prop:
19722 value = zend_hash_index_find(ht, hval);
19723 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
19724 offset = Z_REFVAL_P(offset);
19725 goto isset_again;
19726 } else {
19727 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
19728 if (UNEXPECTED(EG(exception))) {
19729 result = 0;
19730 goto isset_dim_obj_exit;
19731 }
19732 }
19733
19734 if (!(opline->extended_value & ZEND_ISEMPTY)) {
19735 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
19736 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
19737 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
19738
19739 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
19740 /* avoid exception check */
19741
19742 ZEND_VM_SMART_BRANCH(result, 0);
19743 }
19744 } else {
19745 result = (value == NULL || !i_zend_is_true(value));
19746 }
19747 goto isset_dim_obj_exit;
19748 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
19749 container = Z_REFVAL_P(container);
19750 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19751 goto isset_dim_obj_array;
19752 }
19753 }
19754
19755 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
19756 offset++;
19757 }
19758 if (!(opline->extended_value & ZEND_ISEMPTY)) {
19759 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
19760 } else {
19761 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
19762 }
19763
19764isset_dim_obj_exit:
19765
19766 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19767 ZEND_VM_SMART_BRANCH(result, 1);
19768}
19769
19770static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19771{
19772 USE_OPLINE
19773 zval *container;
19774 int result;
19775 zval *offset;
19776 zend_string *name, *tmp_name;
19777
19778 SAVE_OPLINE();
19779 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19780 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19781
19782 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19783 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19784 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19785 container = Z_REFVAL_P(container);
19786 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
19787 result = (opline->extended_value & ZEND_ISEMPTY);
19788 goto isset_object_finish;
19789 }
19790 } else {
19791 result = (opline->extended_value & ZEND_ISEMPTY);
19792 goto isset_object_finish;
19793 }
19794 }
19795
19796 if (IS_CV == IS_CONST) {
19797 name = Z_STR_P(offset);
19798 } else {
19799 name = zval_try_get_tmp_string(offset, &tmp_name);
19800 if (UNEXPECTED(!name)) {
19801 result = 0;
19802 goto isset_object_finish;
19803 }
19804 }
19805
19806 result =
19807 (opline->extended_value & ZEND_ISEMPTY) ^
19808 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));
19809
19810 if (IS_CV != IS_CONST) {
19811 zend_tmp_string_release(tmp_name);
19812 }
19813
19814isset_object_finish:
19815
19816 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19817 ZEND_VM_SMART_BRANCH(result, 1);
19818}
19819
19820static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19821{
19822 USE_OPLINE
19823
19824 zval *key, *subject;
19825 HashTable *ht;
19826 bool result;
19827
19828 SAVE_OPLINE();
19829
19830 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19831 subject = EX_VAR(opline->op2.var);
19832
19833 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
19834array_key_exists_array:
19835 ht = Z_ARRVAL_P(subject);
19836 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
19837 } else {
19838 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
19839 subject = Z_REFVAL_P(subject);
19840 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
19841 goto array_key_exists_array;
19842 }
19843 }
19844 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
19845 result = 0;
19846 }
19847
19848 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19849 ZEND_VM_SMART_BRANCH(result, 1);
19850}
19851
19852static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19853{
19854 USE_OPLINE
19855 zval *retval_ptr;
19856 zval *return_value;
19857
19858 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19859 return_value = EX(return_value);
19860
19861 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
19862 SAVE_OPLINE();
19863 retval_ptr = ZVAL_UNDEFINED_OP1();
19864 if (return_value) {
19865 ZVAL_NULL(return_value);
19866 }
19867 } else if (!return_value) {
19868 if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
19869 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
19870 SAVE_OPLINE();
19871 rc_dtor_func(Z_COUNTED_P(retval_ptr));
19872 }
19873 }
19874 } else {
19875 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
19876 ZVAL_COPY_VALUE(return_value, retval_ptr);
19877 if (IS_TMP_VAR == IS_CONST) {
19878 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
19879 Z_ADDREF_P(return_value);
19880 }
19881 }
19882 } else if (IS_TMP_VAR == IS_CV) {
19883 do {
19884 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19885 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
19886 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
19887 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
19888 ZVAL_COPY_VALUE(return_value, retval_ptr);
19889 if (GC_MAY_LEAK(ref)) {
19890 SAVE_OPLINE();
19891 gc_possible_root(ref);
19892 }
19893 ZVAL_NULL(retval_ptr);
19894 break;
19895 } else {
19896 Z_ADDREF_P(retval_ptr);
19897 }
19898 } else {
19899 retval_ptr = Z_REFVAL_P(retval_ptr);
19900 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19901 Z_ADDREF_P(retval_ptr);
19902 }
19903 }
19904 }
19905 ZVAL_COPY_VALUE(return_value, retval_ptr);
19906 } while (0);
19907 } else /* if (IS_TMP_VAR == IS_VAR) */ {
19908 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
19909 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
19910
19911 retval_ptr = Z_REFVAL_P(retval_ptr);
19912 ZVAL_COPY_VALUE(return_value, retval_ptr);
19913 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19914 efree_size(ref, sizeof(zend_reference));
19915 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19916 Z_ADDREF_P(retval_ptr);
19917 }
19918 } else {
19919 ZVAL_COPY_VALUE(return_value, retval_ptr);
19920 }
19921 }
19922 }
19923
19924
19925
19926 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
19927}
19928
19929static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19930{
19931 USE_OPLINE
19932 zval *retval_ptr;
19933 zval *return_value;
19934
19935 SAVE_OPLINE();
19936
19937 return_value = EX(return_value);
19938
19939 do {
19940 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) ||
19941 (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
19942 /* Not supposed to happen, but we'll allow it */
19943 zend_error(E_NOTICE, "Only variable references should be returned by reference");
19944
19945 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19946 if (!return_value) {
19947 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19948 } else {
19949 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
19950 ZVAL_COPY_VALUE(return_value, retval_ptr);
19951 break;
19952 }
19953
19954 ZVAL_NEW_REF(return_value, retval_ptr);
19955 if (IS_TMP_VAR == IS_CONST) {
19956 Z_TRY_ADDREF_P(retval_ptr);
19957 }
19958 }
19959 break;
19960 }
19961
19962 retval_ptr = zend_get_bad_ptr();
19963
19964 if (IS_TMP_VAR == IS_VAR) {
19965 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
19966 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
19967 zend_error(E_NOTICE, "Only variable references should be returned by reference");
19968 if (return_value) {
19969 ZVAL_NEW_REF(return_value, retval_ptr);
19970 } else {
19971 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19972 }
19973 break;
19974 }
19975 }
19976
19977 if (return_value) {
19978 if (Z_ISREF_P(retval_ptr)) {
19979 Z_ADDREF_P(retval_ptr);
19980 } else {
19981 ZVAL_MAKE_REF_EX(retval_ptr, 2);
19982 }
19983 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
19984 }
19985
19986 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19987 } while (0);
19988
19989
19990 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
19991}
19992
19993static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19994{
19995 USE_OPLINE
19996 zval *retval;
19997
19998 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
19999
20000 SAVE_OPLINE();
20001 retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20002
20003 /* Copy return value into generator->retval */
20004 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20005 ZVAL_COPY_VALUE(&generator->retval, retval);
20006 if (IS_TMP_VAR == IS_CONST) {
20007 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
20008 Z_ADDREF(generator->retval);
20009 }
20010 }
20011 } else if (IS_TMP_VAR == IS_CV) {
20012 ZVAL_COPY_DEREF(&generator->retval, retval);
20013 } else /* if (IS_TMP_VAR == IS_VAR) */ {
20014 if (UNEXPECTED(Z_ISREF_P(retval))) {
20015 zend_refcounted *ref = Z_COUNTED_P(retval);
20016
20017 retval = Z_REFVAL_P(retval);
20018 ZVAL_COPY_VALUE(&generator->retval, retval);
20019 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20020 efree_size(ref, sizeof(zend_reference));
20021 } else if (Z_OPT_REFCOUNTED_P(retval)) {
20022 Z_ADDREF_P(retval);
20023 }
20024 } else {
20025 ZVAL_COPY_VALUE(&generator->retval, retval);
20026 }
20027 }
20028
20029 EG(current_execute_data) = EX(prev_execute_data);
20030
20031 /* Close the generator to free up resources */
20032 zend_generator_close(generator, 1);
20033
20034 /* Pass execution back to handling code */
20035 ZEND_VM_RETURN();
20036}
20037
20038static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20039{
20040 USE_OPLINE
20041 zval *arg, *param;
20042
20043 SAVE_OPLINE();
20044
20045 arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20046 param = ZEND_CALL_VAR(EX(call), opline->result.var);
20047 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
20048 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
20049 Z_TRY_ADDREF_P(arg);
20050 ZVAL_NEW_REF(param, arg);
20051 } else {
20052 ZVAL_COPY(param, arg);
20053 }
20054
20055 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20056 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20057}
20058
20059static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20060{
20061 USE_OPLINE
20062 zval *expr;
20063 zval *result = EX_VAR(opline->result.var);
20064 HashTable *ht;
20065
20066 SAVE_OPLINE();
20067 expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20068
20069 switch (opline->extended_value) {
20070 case IS_LONG:
20071 ZVAL_LONG(result, zval_get_long(expr));
20072 break;
20073 case IS_DOUBLE:
20074 ZVAL_DOUBLE(result, zval_get_double(expr));
20075 break;
20076 case IS_STRING:
20077 ZVAL_STR(result, zval_get_string(expr));
20078 break;
20079 default:
20080 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
20081 if (IS_TMP_VAR & (IS_VAR|IS_CV)) {
20082 ZVAL_DEREF(expr);
20083 }
20084 /* If value is already of correct type, return it directly */
20085 if (Z_TYPE_P(expr) == opline->extended_value) {
20086 ZVAL_COPY_VALUE(result, expr);
20087 if (IS_TMP_VAR == IS_CONST) {
20088 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20089 } else if (IS_TMP_VAR != IS_TMP_VAR) {
20090 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20091 }
20092
20093 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20094 }
20095
20096 if (opline->extended_value == IS_ARRAY) {
20097 if (IS_TMP_VAR == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
20098 if (Z_TYPE_P(expr) != IS_NULL) {
20099 ZVAL_ARR(result, zend_new_array(1));
20100 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
20101 if (IS_TMP_VAR == IS_CONST) {
20102 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
20103 } else {
20104 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
20105 }
20106 } else {
20107 ZVAL_EMPTY_ARRAY(result);
20108 }
20109 } else if (ZEND_STD_BUILD_OBJECT_PROPERTIES_ARRAY_COMPATIBLE(expr)) {
20110 /* Optimized version without rebuilding properties HashTable */
20111 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
20112 } else {
20113 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
20114 if (obj_ht) {
20115 /* fast copy */
20116 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
20117 (Z_OBJCE_P(expr)->default_properties_count ||
20118 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
20119 GC_IS_RECURSIVE(obj_ht))));
20120 zend_release_properties(obj_ht);
20121 } else {
20122 ZVAL_EMPTY_ARRAY(result);
20123 }
20124 }
20125 } else {
20126 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
20127 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
20128 if (Z_TYPE_P(expr) == IS_ARRAY) {
20129 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
20130 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
20131 /* TODO: try not to duplicate immutable arrays as well ??? */
20132 ht = zend_array_dup(ht);
20133 }
20134 Z_OBJ_P(result)->properties = ht;
20135 } else if (Z_TYPE_P(expr) != IS_NULL) {
20136 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
20137 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
20138 if (IS_TMP_VAR == IS_CONST) {
20139 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
20140 } else {
20141 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
20142 }
20143 }
20144 }
20145 }
20146
20147 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20148 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20149}
20150
20151static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20152{
20153 USE_OPLINE
20154 zval *array_ptr, *result;
20155
20156 SAVE_OPLINE();
20157
20158 array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20159 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
20160 result = EX_VAR(opline->result.var);
20161 ZVAL_COPY_VALUE(result, array_ptr);
20162 if (IS_TMP_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
20163 Z_ADDREF_P(array_ptr);
20164 }
20165 Z_FE_POS_P(result) = 0;
20166
20167 ZEND_VM_NEXT_OPCODE();
20168 } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
20169 zend_object *zobj = Z_OBJ_P(array_ptr);
20170 if (!zobj->ce->get_iterator) {
20171 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
20172 zobj = zend_lazy_object_init(zobj);
20173 if (UNEXPECTED(EG(exception))) {
20174 UNDEF_RESULT();
20175
20176 HANDLE_EXCEPTION();
20177 }
20178 }
20179 HashTable *properties = zobj->properties;
20180 if (properties) {
20181 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
20182 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
20183 GC_DELREF(properties);
20184 }
20185 properties = zobj->properties = zend_array_dup(properties);
20186 }
20187 } else {
20188 properties = zobj->handlers->get_properties(zobj);
20189 }
20190
20191 result = EX_VAR(opline->result.var);
20192 ZVAL_COPY_VALUE(result, array_ptr);
20193 if (IS_TMP_VAR != IS_TMP_VAR) {
20194 Z_ADDREF_P(array_ptr);
20195 }
20196
20197 if (zend_hash_num_elements(properties) == 0) {
20198 Z_FE_ITER_P(result) = (uint32_t) -1;
20199
20200 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20201 }
20202
20203 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
20204
20205 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20206 } else {
20207 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
20208
20209 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20210 if (UNEXPECTED(EG(exception))) {
20211 HANDLE_EXCEPTION();
20212 } else if (is_empty) {
20213 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20214 } else {
20215 ZEND_VM_NEXT_OPCODE();
20216 }
20217 }
20218 } else {
20219 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
20220 ZVAL_UNDEF(EX_VAR(opline->result.var));
20221 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
20222 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20223 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20224 }
20225}
20226
20227static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20228{
20229 USE_OPLINE
20230 zval *array_ptr, *array_ref;
20231
20232 SAVE_OPLINE();
20233
20234 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20235 array_ref = array_ptr = zend_get_bad_ptr();
20236 if (Z_ISREF_P(array_ref)) {
20237 array_ptr = Z_REFVAL_P(array_ref);
20238 }
20239 } else {
20240 array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20241 }
20242
20243 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
20244 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20245 if (array_ptr == array_ref) {
20246 ZVAL_NEW_REF(array_ref, array_ref);
20247 array_ptr = Z_REFVAL_P(array_ref);
20248 }
20249 Z_ADDREF_P(array_ref);
20250 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
20251 } else {
20252 array_ref = EX_VAR(opline->result.var);
20253 ZVAL_NEW_REF(array_ref, array_ptr);
20254 array_ptr = Z_REFVAL_P(array_ref);
20255 }
20256 if (IS_TMP_VAR == IS_CONST) {
20257 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
20258 } else {
20259 SEPARATE_ARRAY(array_ptr);
20260 }
20261 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
20262
20263 ZEND_VM_NEXT_OPCODE();
20264 } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
20265 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
20266 zend_object *zobj = Z_OBJ_P(array_ptr);
20267 HashTable *properties;
20268 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
20269 zobj = zend_lazy_object_init(zobj);
20270 if (UNEXPECTED(EG(exception))) {
20271 UNDEF_RESULT();
20272
20273 HANDLE_EXCEPTION();
20274 }
20275 }
20276 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20277 if (array_ptr == array_ref) {
20278 ZVAL_NEW_REF(array_ref, array_ref);
20279 array_ptr = Z_REFVAL_P(array_ref);
20280 }
20281 Z_ADDREF_P(array_ref);
20282 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
20283 } else {
20284 array_ptr = EX_VAR(opline->result.var);
20285 ZVAL_COPY_VALUE(array_ptr, array_ref);
20286 }
20287 if (Z_OBJ_P(array_ptr)->properties
20288 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
20289 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
20290 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
20291 }
20292 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
20293 }
20294
20295 properties = Z_OBJPROP_P(array_ptr);
20296 if (zend_hash_num_elements(properties) == 0) {
20297 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
20298
20299 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20300 }
20301
20302 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
20303
20304 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20305 } else {
20306 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
20307 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20308 if (UNEXPECTED(EG(exception))) {
20309 HANDLE_EXCEPTION();
20310 } else if (is_empty) {
20311 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20312 } else {
20313 ZEND_VM_NEXT_OPCODE();
20314 }
20315 }
20316 } else {
20317 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
20318 ZVAL_UNDEF(EX_VAR(opline->result.var));
20319 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
20320 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20321 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20322 }
20323}
20324
20325static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20326{
20327 USE_OPLINE
20328
20329 if (E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))
20330 && !E_HAS_ONLY_FATAL_ERRORS(Z_LVAL_P(EX_VAR(opline->op1.var)))) {
20331 EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var));
20332 }
20333 ZEND_VM_NEXT_OPCODE();
20334}
20335
20336static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20337{
20338 USE_OPLINE
20339 zval *value;
20340 zend_reference *ref = NULL;
20341 bool ret;
20342
20343 SAVE_OPLINE();
20344 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20345
20346 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) {
20347 if (IS_TMP_VAR == IS_VAR) {
20348 ref = Z_REF_P(value);
20349 }
20350 value = Z_REFVAL_P(value);
20351 }
20352
20353 ret = i_zend_is_true(value);
20354
20355 if (UNEXPECTED(EG(exception))) {
20356 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20357 ZVAL_UNDEF(EX_VAR(opline->result.var));
20358 HANDLE_EXCEPTION();
20359 }
20360
20361 if (ret) {
20362 zval *result = EX_VAR(opline->result.var);
20363
20364 ZVAL_COPY_VALUE(result, value);
20365 if (IS_TMP_VAR == IS_CONST) {
20366 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20367 } else if (IS_TMP_VAR == IS_CV) {
20368 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20369 } else if (IS_TMP_VAR == IS_VAR && ref) {
20370 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20371 efree_size(ref, sizeof(zend_reference));
20372 } else if (Z_OPT_REFCOUNTED_P(result)) {
20373 Z_ADDREF_P(result);
20374 }
20375 }
20376 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20377 }
20378
20379 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20380 ZEND_VM_NEXT_OPCODE();
20381}
20382
20383static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20384{
20385 USE_OPLINE
20386 zval *value;
20387 zend_reference *ref = NULL;
20388
20389 SAVE_OPLINE();
20390 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20391
20392 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
20393 if (IS_TMP_VAR & IS_VAR) {
20394 ref = Z_REF_P(value);
20395 }
20396 value = Z_REFVAL_P(value);
20397 }
20398
20399 if (Z_TYPE_P(value) > IS_NULL) {
20400 zval *result = EX_VAR(opline->result.var);
20401 ZVAL_COPY_VALUE(result, value);
20402 if (IS_TMP_VAR == IS_CONST) {
20403 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20404 } else if (IS_TMP_VAR == IS_CV) {
20405 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20406 } else if ((IS_TMP_VAR & IS_VAR) && ref) {
20407 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20408 efree_size(ref, sizeof(zend_reference));
20409 } else if (Z_OPT_REFCOUNTED_P(result)) {
20410 Z_ADDREF_P(result);
20411 }
20412 }
20413 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20414 }
20415
20416 if ((IS_TMP_VAR & IS_VAR) && ref) {
20417 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20418 efree_size(ref, sizeof(zend_reference));
20419 }
20420 }
20421 ZEND_VM_NEXT_OPCODE();
20422}
20423
20424static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20425{
20426 USE_OPLINE
20427 zval *val, *result;
20428
20429 val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20430
20431 if (Z_TYPE_P(val) > IS_NULL) {
20432 do {
20433 if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
20434 val = Z_REFVAL_P(val);
20435 if (Z_TYPE_P(val) <= IS_NULL) {
20436 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20437 break;
20438 }
20439 }
20440 ZEND_VM_NEXT_OPCODE();
20441 } while (0);
20442 }
20443
20444 result = EX_VAR(opline->result.var);
20445 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
20446 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
20447 ZVAL_NULL(result);
20448 if (IS_TMP_VAR == IS_CV
20449 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
20450 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
20451 ) {
20452 SAVE_OPLINE();
20453 ZVAL_UNDEFINED_OP1();
20454 if (UNEXPECTED(EG(exception) != NULL)) {
20455 HANDLE_EXCEPTION();
20456 }
20457 }
20458 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
20459 ZVAL_FALSE(result);
20460 } else {
20461 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
20462 ZVAL_TRUE(result);
20463 }
20464
20465 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20466}
20467
20468static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20469{
20470 USE_OPLINE
20471 zval *value;
20472 zval *result = EX_VAR(opline->result.var);
20473
20474 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20475 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
20476 SAVE_OPLINE();
20477 ZVAL_UNDEFINED_OP1();
20478 ZVAL_NULL(result);
20479 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20480 }
20481
20482 if (IS_TMP_VAR == IS_CV) {
20483 ZVAL_COPY_DEREF(result, value);
20484 } else if (IS_TMP_VAR == IS_VAR) {
20485 if (UNEXPECTED(Z_ISREF_P(value))) {
20486 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
20487 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
20488 efree_size(Z_REF_P(value), sizeof(zend_reference));
20489 } else if (Z_OPT_REFCOUNTED_P(result)) {
20490 Z_ADDREF_P(result);
20491 }
20492 } else {
20493 ZVAL_COPY_VALUE(result, value);
20494 }
20495 } else {
20496 ZVAL_COPY_VALUE(result, value);
20497 if (IS_TMP_VAR == IS_CONST) {
20498 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
20499 Z_ADDREF_P(result);
20500 }
20501 }
20502 }
20503 ZEND_VM_NEXT_OPCODE();
20504}
20505
20506static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20507{
20508 USE_OPLINE
20509 zval *op1, *op2;
20510 bool result;
20511
20512 SAVE_OPLINE();
20513 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20514 op2 = RT_CONSTANT(opline, opline->op2);
20515 result = fast_is_identical_function(op1, op2);
20516 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20517
20518 ZEND_VM_SMART_BRANCH(result, 1);
20519}
20520
20521static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20522{
20523 USE_OPLINE
20524 zval *op1, *op2;
20525 bool result;
20526
20527 SAVE_OPLINE();
20528 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20529 op2 = RT_CONSTANT(opline, opline->op2);
20530 result = fast_is_identical_function(op1, op2);
20531
20532 ZEND_VM_SMART_BRANCH(result, 1);
20533}
20534
20535static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20536{
20537 USE_OPLINE
20538 zval *op1, *op2;
20539 bool result;
20540
20541 SAVE_OPLINE();
20542 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20543 op2 = RT_CONSTANT(opline, opline->op2);
20544 result = fast_is_not_identical_function(op1, op2);
20545 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20546
20547 ZEND_VM_SMART_BRANCH(result, 1);
20548}
20549
20550static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20551{
20552#if 0
20553 USE_OPLINE
20554#endif
20555
20556 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20557 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20558 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20559 }
20560 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20561 } else {
20562 if (IS_CONST == IS_UNUSED) {
20563 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20564 }
20565 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20566 }
20567}
20568
20569static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20570{
20571#if 0
20572 USE_OPLINE
20573#endif
20574
20575 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20576 /* Behave like FETCH_OBJ_W */
20577 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20578 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20579 }
20580 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20581 } else {
20582 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20583 }
20584}
20585
20586static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20587{
20588 USE_OPLINE
20589 zend_string **rope;
20590 zval *var;
20591
20592 /* op1 and result are the same */
20593 rope = (zend_string**)EX_VAR(opline->op1.var);
20594 if (IS_CONST == IS_CONST) {
20595 var = RT_CONSTANT(opline, opline->op2);
20596 rope[opline->extended_value] = Z_STR_P(var);
20597 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20598 Z_ADDREF_P(var);
20599 }
20600 } else {
20601 var = RT_CONSTANT(opline, opline->op2);
20602 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20603 if (IS_CONST == IS_CV) {
20604 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20605 } else {
20606 rope[opline->extended_value] = Z_STR_P(var);
20607 }
20608 } else {
20609 SAVE_OPLINE();
20610 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20611 ZVAL_UNDEFINED_OP2();
20612 }
20613 rope[opline->extended_value] = zval_get_string_func(var);
20614
20615 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20616 }
20617 }
20618 ZEND_VM_NEXT_OPCODE();
20619}
20620
20621static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20622{
20623 USE_OPLINE
20624 zend_string **rope;
20625 zval *var, *ret;
20626 uint32_t i;
20627
20628 rope = (zend_string**)EX_VAR(opline->op1.var);
20629 if (IS_CONST == IS_CONST) {
20630 var = RT_CONSTANT(opline, opline->op2);
20631 rope[opline->extended_value] = Z_STR_P(var);
20632 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20633 Z_ADDREF_P(var);
20634 }
20635 } else {
20636 var = RT_CONSTANT(opline, opline->op2);
20637 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20638 if (IS_CONST == IS_CV) {
20639 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20640 } else {
20641 rope[opline->extended_value] = Z_STR_P(var);
20642 }
20643 } else {
20644 SAVE_OPLINE();
20645 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20646 ZVAL_UNDEFINED_OP2();
20647 }
20648 rope[opline->extended_value] = zval_get_string_func(var);
20649
20650 if (UNEXPECTED(EG(exception))) {
20651 for (i = 0; i <= opline->extended_value; i++) {
20652 zend_string_release_ex(rope[i], 0);
20653 }
20654 ZVAL_UNDEF(EX_VAR(opline->result.var));
20655 HANDLE_EXCEPTION();
20656 }
20657 }
20658 }
20659
20660 size_t len = 0;
20661 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
20662 for (i = 0; i <= opline->extended_value; i++) {
20663 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
20664 len += ZSTR_LEN(rope[i]);
20665 }
20666 ret = EX_VAR(opline->result.var);
20667 ZVAL_STR(ret, zend_string_alloc(len, 0));
20668 GC_ADD_FLAGS(Z_STR_P(ret), flags);
20669
20670 char *target = Z_STRVAL_P(ret);
20671 for (i = 0; i <= opline->extended_value; i++) {
20672 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
20673 target += ZSTR_LEN(rope[i]);
20674 zend_string_release_ex(rope[i], 0);
20675 }
20676 *target = '\0';
20677
20678 ZEND_VM_NEXT_OPCODE();
20679}
20680
20681static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20682{
20683 USE_OPLINE
20684 zval *value, *arg;
20685 uint32_t arg_num;
20686
20687 if (IS_CONST == IS_CONST) {
20688 SAVE_OPLINE();
20689 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
20690 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
20691 if (UNEXPECTED(!arg)) {
20692 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20693 HANDLE_EXCEPTION();
20694 }
20695 } else {
20696 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
20697 arg_num = opline->op2.num;
20698 }
20699
20700 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
20701 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20702 goto send_val_by_ref;
20703 }
20704 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20705send_val_by_ref:
20706 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
20707 }
20708 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20709 ZVAL_COPY_VALUE(arg, value);
20710 if (IS_TMP_VAR == IS_CONST) {
20711 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
20712 Z_ADDREF_P(arg);
20713 }
20714 }
20715 ZEND_VM_NEXT_OPCODE();
20716}
20717
20718static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20719{
20720 USE_OPLINE
20721 zval *expr_ptr, new_expr;
20722
20723 SAVE_OPLINE();
20724 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
20725 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
20726 expr_ptr = zend_get_bad_ptr();
20727 if (Z_ISREF_P(expr_ptr)) {
20728 Z_ADDREF_P(expr_ptr);
20729 } else {
20730 ZVAL_MAKE_REF_EX(expr_ptr, 2);
20731 }
20732 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20733 } else {
20734 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20735 if (IS_TMP_VAR == IS_TMP_VAR) {
20736 /* pass */
20737 } else if (IS_TMP_VAR == IS_CONST) {
20738 Z_TRY_ADDREF_P(expr_ptr);
20739 } else if (IS_TMP_VAR == IS_CV) {
20740 ZVAL_DEREF(expr_ptr);
20741 Z_TRY_ADDREF_P(expr_ptr);
20742 } else /* if (IS_TMP_VAR == IS_VAR) */ {
20743 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
20744 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
20745
20746 expr_ptr = Z_REFVAL_P(expr_ptr);
20747 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20748 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
20749 expr_ptr = &new_expr;
20750 efree_size(ref, sizeof(zend_reference));
20751 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
20752 Z_ADDREF_P(expr_ptr);
20753 }
20754 }
20755 }
20756 }
20757
20758 if (IS_CONST != IS_UNUSED) {
20759 zval *offset = RT_CONSTANT(opline, opline->op2);
20760 zend_string *str;
20761 zend_ulong hval;
20762
20763add_again:
20764 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
20765 str = Z_STR_P(offset);
20766 if (IS_CONST != IS_CONST) {
20767 if (ZEND_HANDLE_NUMERIC(str, hval)) {
20768 goto num_index;
20769 }
20770 }
20771str_index:
20772 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
20773 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
20774 hval = Z_LVAL_P(offset);
20775num_index:
20776 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
20777 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
20778 offset = Z_REFVAL_P(offset);
20779 goto add_again;
20780 } else if (Z_TYPE_P(offset) == IS_NULL) {
20781 str = ZSTR_EMPTY_ALLOC();
20782 goto str_index;
20783 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
20784 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
20785 goto num_index;
20786 } else if (Z_TYPE_P(offset) == IS_FALSE) {
20787 hval = 0;
20788 goto num_index;
20789 } else if (Z_TYPE_P(offset) == IS_TRUE) {
20790 hval = 1;
20791 goto num_index;
20792 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
20793 zend_use_resource_as_offset(offset);
20794 hval = Z_RES_HANDLE_P(offset);
20795 goto num_index;
20796 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
20797 ZVAL_UNDEFINED_OP2();
20798 str = ZSTR_EMPTY_ALLOC();
20799 goto str_index;
20800 } else {
20801 zend_illegal_array_offset_access(offset);
20802 zval_ptr_dtor_nogc(expr_ptr);
20803 }
20804
20805 } else {
20806 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
20807 zend_cannot_add_element();
20808 zval_ptr_dtor_nogc(expr_ptr);
20809 }
20810 }
20811 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20812}
20813
20814static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20815{
20816 zval *array;
20817 uint32_t size;
20818 USE_OPLINE
20819
20820 SAVE_OPLINE();
20821 array = EX_VAR(opline->result.var);
20822 if (IS_TMP_VAR != IS_UNUSED) {
20823 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
20824 ZVAL_ARR(array, zend_new_array(size));
20825 /* Explicitly initialize array as not-packed if flag is set */
20826 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
20827 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
20828 }
20829 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20830 } else {
20831 ZVAL_ARR(array, zend_new_array(0));
20832 ZEND_VM_NEXT_OPCODE();
20833 }
20834}
20835
20836static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20837{
20838 USE_OPLINE
20839
20840 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
20841
20842 SAVE_OPLINE();
20843 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
20844 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20845 }
20846
20847 /* Destroy the previously yielded value */
20848 zval_ptr_dtor(&generator->value);
20849
20850 /* Destroy the previously yielded key */
20851 zval_ptr_dtor(&generator->key);
20852
20853 /* Set the new yielded value */
20854 if (IS_TMP_VAR != IS_UNUSED) {
20855 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
20856 /* Constants and temporary variables aren't yieldable by reference,
20857 * but we still allow them with a notice. */
20858 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
20859 zval *value;
20860
20861 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20862
20863 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20864 ZVAL_COPY_VALUE(&generator->value, value);
20865 if (IS_TMP_VAR == IS_CONST) {
20866 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20867 Z_ADDREF(generator->value);
20868 }
20869 }
20870 } else {
20871 zval *value_ptr = zend_get_bad_ptr();
20872
20873 /* If a function call result is yielded and the function did
20874 * not return by reference we throw a notice. */
20875 do {
20876 if (IS_TMP_VAR == IS_VAR) {
20877 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
20878 if (opline->extended_value == ZEND_RETURNS_FUNCTION
20879 && !Z_ISREF_P(value_ptr)) {
20880 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20881 ZVAL_COPY(&generator->value, value_ptr);
20882 break;
20883 }
20884 }
20885 if (Z_ISREF_P(value_ptr)) {
20886 Z_ADDREF_P(value_ptr);
20887 } else {
20888 ZVAL_MAKE_REF_EX(value_ptr, 2);
20889 }
20890 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
20891 } while (0);
20892
20893 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20894 }
20895 } else {
20896 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20897
20898 /* Consts, temporary variables and references need copying */
20899 if (IS_TMP_VAR == IS_CONST) {
20900 ZVAL_COPY_VALUE(&generator->value, value);
20901 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20902 Z_ADDREF(generator->value);
20903 }
20904 } else if (IS_TMP_VAR == IS_TMP_VAR) {
20905 ZVAL_COPY_VALUE(&generator->value, value);
20906 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
20907 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
20908
20909 } else {
20910 ZVAL_COPY_VALUE(&generator->value, value);
20911 if (IS_TMP_VAR == IS_CV) {
20912 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
20913 }
20914 }
20915 }
20916 } else {
20917 /* If no value was specified yield null */
20918 ZVAL_NULL(&generator->value);
20919 }
20920
20921 /* Set the new yielded key */
20922 if (IS_CONST != IS_UNUSED) {
20923 zval *key = RT_CONSTANT(opline, opline->op2);
20924 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
20925 key = Z_REFVAL_P(key);
20926 }
20927 ZVAL_COPY(&generator->key, key);
20928
20929 if (Z_TYPE(generator->key) == IS_LONG
20930 && Z_LVAL(generator->key) > generator->largest_used_integer_key
20931 ) {
20932 generator->largest_used_integer_key = Z_LVAL(generator->key);
20933 }
20934 } else {
20935 /* If no key was specified we use auto-increment keys */
20936 generator->largest_used_integer_key++;
20937 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
20938 }
20939
20940 if (RETURN_VALUE_USED(opline)) {
20941 /* If the return value of yield is used set the send
20942 * target and initialize it to NULL */
20943 generator->send_target = EX_VAR(opline->result.var);
20944 ZVAL_NULL(generator->send_target);
20945 } else {
20946 generator->send_target = NULL;
20947 }
20948
20949 /* The GOTO VM uses a local opline variable. We need to set the opline
20950 * variable in execute_data so we don't resume at an old position. */
20951 SAVE_OPLINE();
20952
20953 ZEND_VM_RETURN();
20954}
20955
20956static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20957{
20958 USE_OPLINE
20959 zval *op1;
20960 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
20961 zval *result;
20962
20963 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20964 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
20965 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_TMP_VAR == IS_CONST);
20966 if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) {
20967 zval_ptr_dtor_str(op1);
20968 }
20969 ZEND_VM_SMART_BRANCH(result, 0);
20970 }
20971
20972 if (opline->extended_value) {
20973 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
20974 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
20975 ZEND_VM_SMART_BRANCH(result, 0);
20976 }
20977 SAVE_OPLINE();
20978 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
20979 op1 = Z_REFVAL_P(op1);
20980 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
20981 result = zend_hash_find(ht, Z_STR_P(op1));
20982 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20983 ZEND_VM_SMART_BRANCH(result, 0);
20984 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
20985 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
20986 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20987 ZEND_VM_SMART_BRANCH(result, 0);
20988 }
20989 } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
20990 ZVAL_UNDEFINED_OP1();
20991 }
20992 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
20993 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
20994 SAVE_OPLINE();
20995 ZVAL_UNDEFINED_OP1();
20996 if (UNEXPECTED(EG(exception) != NULL)) {
20997 HANDLE_EXCEPTION();
20998 }
20999 }
21000 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
21001 ZEND_VM_SMART_BRANCH(result, 0);
21002 } else {
21003 zend_string *key;
21004 zval key_tmp;
21005
21006 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
21007 op1 = Z_REFVAL_P(op1);
21008 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
21009 result = zend_hash_find(ht, Z_STR_P(op1));
21010 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21011 ZEND_VM_SMART_BRANCH(result, 0);
21012 }
21013 }
21014
21015 SAVE_OPLINE();
21016 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
21017 ZVAL_STR(&key_tmp, key);
21018 if (zend_compare(op1, &key_tmp) == 0) {
21019 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21020 ZEND_VM_SMART_BRANCH(1, 1);
21021 }
21022 } ZEND_HASH_FOREACH_END();
21023 }
21024 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21025 ZEND_VM_SMART_BRANCH(0, 1);
21026}
21027
21028static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21029{
21030#if 0
21031 USE_OPLINE
21032#endif
21033
21034 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21035 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21036 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21037 }
21038 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21039 } else {
21040 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
21041 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21042 }
21043 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21044 }
21045}
21046
21047static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21048{
21049#if 0
21050 USE_OPLINE
21051#endif
21052
21053 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21054 /* Behave like FETCH_OBJ_W */
21055 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21056 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21057 }
21058 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21059 } else {
21060 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21061 }
21062}
21063
21064static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21065{
21066 USE_OPLINE
21067 zend_string **rope;
21068 zval *var;
21069
21070 /* op1 and result are the same */
21071 rope = (zend_string**)EX_VAR(opline->op1.var);
21072 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
21073 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21074 rope[opline->extended_value] = Z_STR_P(var);
21075 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21076 Z_ADDREF_P(var);
21077 }
21078 } else {
21079 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21080 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21081 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
21082 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21083 } else {
21084 rope[opline->extended_value] = Z_STR_P(var);
21085 }
21086 } else {
21087 SAVE_OPLINE();
21088 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21089 ZVAL_UNDEFINED_OP2();
21090 }
21091 rope[opline->extended_value] = zval_get_string_func(var);
21092 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21093 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21094 }
21095 }
21096 ZEND_VM_NEXT_OPCODE();
21097}
21098
21099static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21100{
21101 USE_OPLINE
21102 zend_string **rope;
21103 zval *var, *ret;
21104 uint32_t i;
21105
21106 rope = (zend_string**)EX_VAR(opline->op1.var);
21107 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
21108 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21109 rope[opline->extended_value] = Z_STR_P(var);
21110 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21111 Z_ADDREF_P(var);
21112 }
21113 } else {
21114 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21115 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21116 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
21117 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21118 } else {
21119 rope[opline->extended_value] = Z_STR_P(var);
21120 }
21121 } else {
21122 SAVE_OPLINE();
21123 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21124 ZVAL_UNDEFINED_OP2();
21125 }
21126 rope[opline->extended_value] = zval_get_string_func(var);
21127 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21128 if (UNEXPECTED(EG(exception))) {
21129 for (i = 0; i <= opline->extended_value; i++) {
21130 zend_string_release_ex(rope[i], 0);
21131 }
21132 ZVAL_UNDEF(EX_VAR(opline->result.var));
21133 HANDLE_EXCEPTION();
21134 }
21135 }
21136 }
21137
21138 size_t len = 0;
21139 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
21140 for (i = 0; i <= opline->extended_value; i++) {
21141 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
21142 len += ZSTR_LEN(rope[i]);
21143 }
21144 ret = EX_VAR(opline->result.var);
21145 ZVAL_STR(ret, zend_string_alloc(len, 0));
21146 GC_ADD_FLAGS(Z_STR_P(ret), flags);
21147
21148 char *target = Z_STRVAL_P(ret);
21149 for (i = 0; i <= opline->extended_value; i++) {
21150 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
21151 target += ZSTR_LEN(rope[i]);
21152 zend_string_release_ex(rope[i], 0);
21153 }
21154 *target = '\0';
21155
21156 ZEND_VM_NEXT_OPCODE();
21157}
21158
21159static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21160{
21161 USE_OPLINE
21162 zval *expr_ptr, new_expr;
21163
21164 SAVE_OPLINE();
21165 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21166 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21167 expr_ptr = zend_get_bad_ptr();
21168 if (Z_ISREF_P(expr_ptr)) {
21169 Z_ADDREF_P(expr_ptr);
21170 } else {
21171 ZVAL_MAKE_REF_EX(expr_ptr, 2);
21172 }
21173 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21174 } else {
21175 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21176 if (IS_TMP_VAR == IS_TMP_VAR) {
21177 /* pass */
21178 } else if (IS_TMP_VAR == IS_CONST) {
21179 Z_TRY_ADDREF_P(expr_ptr);
21180 } else if (IS_TMP_VAR == IS_CV) {
21181 ZVAL_DEREF(expr_ptr);
21182 Z_TRY_ADDREF_P(expr_ptr);
21183 } else /* if (IS_TMP_VAR == IS_VAR) */ {
21184 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21185 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21186
21187 expr_ptr = Z_REFVAL_P(expr_ptr);
21188 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21189 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21190 expr_ptr = &new_expr;
21191 efree_size(ref, sizeof(zend_reference));
21192 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21193 Z_ADDREF_P(expr_ptr);
21194 }
21195 }
21196 }
21197 }
21198
21199 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
21200 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21201 zend_string *str;
21202 zend_ulong hval;
21203
21204add_again:
21205 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21206 str = Z_STR_P(offset);
21207 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
21208 if (ZEND_HANDLE_NUMERIC(str, hval)) {
21209 goto num_index;
21210 }
21211 }
21212str_index:
21213 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21214 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21215 hval = Z_LVAL_P(offset);
21216num_index:
21217 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21218 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21219 offset = Z_REFVAL_P(offset);
21220 goto add_again;
21221 } else if (Z_TYPE_P(offset) == IS_NULL) {
21222 str = ZSTR_EMPTY_ALLOC();
21223 goto str_index;
21224 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21225 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21226 goto num_index;
21227 } else if (Z_TYPE_P(offset) == IS_FALSE) {
21228 hval = 0;
21229 goto num_index;
21230 } else if (Z_TYPE_P(offset) == IS_TRUE) {
21231 hval = 1;
21232 goto num_index;
21233 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21234 zend_use_resource_as_offset(offset);
21235 hval = Z_RES_HANDLE_P(offset);
21236 goto num_index;
21237 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21238 ZVAL_UNDEFINED_OP2();
21239 str = ZSTR_EMPTY_ALLOC();
21240 goto str_index;
21241 } else {
21242 zend_illegal_array_offset_access(offset);
21243 zval_ptr_dtor_nogc(expr_ptr);
21244 }
21245 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21246 } else {
21247 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21248 zend_cannot_add_element();
21249 zval_ptr_dtor_nogc(expr_ptr);
21250 }
21251 }
21252 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21253}
21254
21255static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21256{
21257 zval *array;
21258 uint32_t size;
21259 USE_OPLINE
21260
21261 SAVE_OPLINE();
21262 array = EX_VAR(opline->result.var);
21263 if (IS_TMP_VAR != IS_UNUSED) {
21264 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21265 ZVAL_ARR(array, zend_new_array(size));
21266 /* Explicitly initialize array as not-packed if flag is set */
21267 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21268 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21269 }
21270 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21271 } else {
21272 ZVAL_ARR(array, zend_new_array(0));
21273 ZEND_VM_NEXT_OPCODE();
21274 }
21275}
21276
21277static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21278{
21279 USE_OPLINE
21280
21281 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21282
21283 SAVE_OPLINE();
21284 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21285 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21286 }
21287
21288 /* Destroy the previously yielded value */
21289 zval_ptr_dtor(&generator->value);
21290
21291 /* Destroy the previously yielded key */
21292 zval_ptr_dtor(&generator->key);
21293
21294 /* Set the new yielded value */
21295 if (IS_TMP_VAR != IS_UNUSED) {
21296 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21297 /* Constants and temporary variables aren't yieldable by reference,
21298 * but we still allow them with a notice. */
21299 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21300 zval *value;
21301
21302 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21303
21304 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21305 ZVAL_COPY_VALUE(&generator->value, value);
21306 if (IS_TMP_VAR == IS_CONST) {
21307 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21308 Z_ADDREF(generator->value);
21309 }
21310 }
21311 } else {
21312 zval *value_ptr = zend_get_bad_ptr();
21313
21314 /* If a function call result is yielded and the function did
21315 * not return by reference we throw a notice. */
21316 do {
21317 if (IS_TMP_VAR == IS_VAR) {
21318 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21319 if (opline->extended_value == ZEND_RETURNS_FUNCTION
21320 && !Z_ISREF_P(value_ptr)) {
21321 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21322 ZVAL_COPY(&generator->value, value_ptr);
21323 break;
21324 }
21325 }
21326 if (Z_ISREF_P(value_ptr)) {
21327 Z_ADDREF_P(value_ptr);
21328 } else {
21329 ZVAL_MAKE_REF_EX(value_ptr, 2);
21330 }
21331 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21332 } while (0);
21333
21334 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21335 }
21336 } else {
21337 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21338
21339 /* Consts, temporary variables and references need copying */
21340 if (IS_TMP_VAR == IS_CONST) {
21341 ZVAL_COPY_VALUE(&generator->value, value);
21342 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21343 Z_ADDREF(generator->value);
21344 }
21345 } else if (IS_TMP_VAR == IS_TMP_VAR) {
21346 ZVAL_COPY_VALUE(&generator->value, value);
21347 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21348 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21349
21350 } else {
21351 ZVAL_COPY_VALUE(&generator->value, value);
21352 if (IS_TMP_VAR == IS_CV) {
21353 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21354 }
21355 }
21356 }
21357 } else {
21358 /* If no value was specified yield null */
21359 ZVAL_NULL(&generator->value);
21360 }
21361
21362 /* Set the new yielded key */
21363 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
21364 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21365 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21366 key = Z_REFVAL_P(key);
21367 }
21368 ZVAL_COPY(&generator->key, key);
21369 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21370
21371 if (Z_TYPE(generator->key) == IS_LONG
21372 && Z_LVAL(generator->key) > generator->largest_used_integer_key
21373 ) {
21374 generator->largest_used_integer_key = Z_LVAL(generator->key);
21375 }
21376 } else {
21377 /* If no key was specified we use auto-increment keys */
21378 generator->largest_used_integer_key++;
21379 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21380 }
21381
21382 if (RETURN_VALUE_USED(opline)) {
21383 /* If the return value of yield is used set the send
21384 * target and initialize it to NULL */
21385 generator->send_target = EX_VAR(opline->result.var);
21386 ZVAL_NULL(generator->send_target);
21387 } else {
21388 generator->send_target = NULL;
21389 }
21390
21391 /* The GOTO VM uses a local opline variable. We need to set the opline
21392 * variable in execute_data so we don't resume at an old position. */
21393 SAVE_OPLINE();
21394
21395 ZEND_VM_RETURN();
21396}
21397
21398static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21399{
21400 USE_OPLINE
21401 zval *op1, *op2;
21402 bool result;
21403
21404 SAVE_OPLINE();
21405 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21406 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21407 result = fast_is_identical_function(op1, op2);
21408 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21409 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21410 ZEND_VM_SMART_BRANCH(result, 1);
21411}
21412
21413static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21414{
21415 USE_OPLINE
21416 zval *op1, *op2;
21417 bool result;
21418
21419 SAVE_OPLINE();
21420 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21421 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21422 result = fast_is_identical_function(op1, op2);
21423 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21424 ZEND_VM_SMART_BRANCH(result, 1);
21425}
21426
21427static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21428{
21429 USE_OPLINE
21430 zval *op1, *op2;
21431 bool result;
21432
21433 SAVE_OPLINE();
21434 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21435 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21436 result = fast_is_not_identical_function(op1, op2);
21437 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21438 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21439 ZEND_VM_SMART_BRANCH(result, 1);
21440}
21441
21442static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21443{
21444 USE_OPLINE
21445 zval *op1, *op2;
21446 bool result;
21447
21448 SAVE_OPLINE();
21449 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21450 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
21451 result = fast_is_identical_function(op1, op2);
21452 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21453 ZEND_VM_SMART_BRANCH(result, 1);
21454}
21455
21456static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21457{
21458#if 0
21459 USE_OPLINE
21460#endif
21461
21462 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21463 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21464 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21465 }
21466 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21467 } else {
21468 if (IS_UNUSED == IS_UNUSED) {
21469 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21470 }
21471 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21472 }
21473}
21474
21475static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21476{
21477 if (IS_TMP_VAR == IS_UNUSED) {
21478 SAVE_OPLINE();
21479 zend_verify_missing_return_type(EX(func));
21480 HANDLE_EXCEPTION();
21481 } else {
21482/* prevents "undefined variable opline" errors */
21483#if 0 || (IS_TMP_VAR != IS_UNUSED)
21484 USE_OPLINE
21485 zval *retval_ref, *retval_ptr;
21486 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
21487 retval_ref = retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21488
21489 if (IS_TMP_VAR == IS_CONST) {
21490 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
21491 retval_ref = retval_ptr = EX_VAR(opline->result.var);
21492 } else if (IS_TMP_VAR == IS_VAR) {
21493 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
21494 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
21495 }
21496 ZVAL_DEREF(retval_ptr);
21497 } else if (IS_TMP_VAR == IS_CV) {
21498 ZVAL_DEREF(retval_ptr);
21499 }
21500
21501 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
21502 ZEND_VM_NEXT_OPCODE();
21503 }
21504
21505 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
21506 SAVE_OPLINE();
21507 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
21508 if (UNEXPECTED(EG(exception))) {
21509 HANDLE_EXCEPTION();
21510 }
21511 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
21512 ZEND_VM_NEXT_OPCODE();
21513 }
21514 }
21515
21516 zend_reference *ref = NULL;
21517 void *cache_slot = CACHE_ADDR(opline->op2.num);
21518 if (UNEXPECTED(retval_ref != retval_ptr)) {
21519 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21520 ref = Z_REF_P(retval_ref);
21521 } else {
21522 /* A cast might happen - unwrap the reference if this is a by-value return */
21523 if (Z_REFCOUNT_P(retval_ref) == 1) {
21524 ZVAL_UNREF(retval_ref);
21525 } else {
21526 Z_DELREF_P(retval_ref);
21527 ZVAL_COPY(retval_ref, retval_ptr);
21528 }
21529 retval_ptr = retval_ref;
21530 }
21531 }
21532
21533 SAVE_OPLINE();
21534 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
21535 zend_verify_return_error(EX(func), retval_ptr);
21536 HANDLE_EXCEPTION();
21537 }
21538 ZEND_VM_NEXT_OPCODE();
21539#endif
21540 }
21541}
21542
21543static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21544{
21545 USE_OPLINE
21546 zval *value, *arg;
21547 uint32_t arg_num;
21548
21549 if (IS_UNUSED == IS_CONST) {
21550 SAVE_OPLINE();
21551 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21552 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21553 if (UNEXPECTED(!arg)) {
21554 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21555 HANDLE_EXCEPTION();
21556 }
21557 } else {
21558 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21559 arg_num = opline->op2.num;
21560 }
21561
21562 if (EXPECTED(0)) {
21563 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21564 goto send_val_by_ref;
21565 }
21566 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21567send_val_by_ref:
21568 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
21569 }
21570 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21571 ZVAL_COPY_VALUE(arg, value);
21572 if (IS_TMP_VAR == IS_CONST) {
21573 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21574 Z_ADDREF_P(arg);
21575 }
21576 }
21577 ZEND_VM_NEXT_OPCODE();
21578}
21579
21580static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21581{
21582 USE_OPLINE
21583 zval *value, *arg;
21584 uint32_t arg_num;
21585
21586 if (IS_UNUSED == IS_CONST) {
21587 SAVE_OPLINE();
21588 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21589 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21590 if (UNEXPECTED(!arg)) {
21591 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21592 HANDLE_EXCEPTION();
21593 }
21594 } else {
21595 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21596 arg_num = opline->op2.num;
21597 }
21598
21599 if (EXPECTED(1)) {
21600 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21601 goto send_val_by_ref;
21602 }
21603 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21604send_val_by_ref:
21605 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
21606 }
21607 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21608 ZVAL_COPY_VALUE(arg, value);
21609 if (IS_TMP_VAR == IS_CONST) {
21610 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21611 Z_ADDREF_P(arg);
21612 }
21613 }
21614 ZEND_VM_NEXT_OPCODE();
21615}
21616
21617static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21618{
21619 USE_OPLINE
21620 zval *expr_ptr, new_expr;
21621
21622 SAVE_OPLINE();
21623 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21624 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21625 expr_ptr = zend_get_bad_ptr();
21626 if (Z_ISREF_P(expr_ptr)) {
21627 Z_ADDREF_P(expr_ptr);
21628 } else {
21629 ZVAL_MAKE_REF_EX(expr_ptr, 2);
21630 }
21631 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21632 } else {
21633 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21634 if (IS_TMP_VAR == IS_TMP_VAR) {
21635 /* pass */
21636 } else if (IS_TMP_VAR == IS_CONST) {
21637 Z_TRY_ADDREF_P(expr_ptr);
21638 } else if (IS_TMP_VAR == IS_CV) {
21639 ZVAL_DEREF(expr_ptr);
21640 Z_TRY_ADDREF_P(expr_ptr);
21641 } else /* if (IS_TMP_VAR == IS_VAR) */ {
21642 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21643 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21644
21645 expr_ptr = Z_REFVAL_P(expr_ptr);
21646 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21647 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21648 expr_ptr = &new_expr;
21649 efree_size(ref, sizeof(zend_reference));
21650 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21651 Z_ADDREF_P(expr_ptr);
21652 }
21653 }
21654 }
21655 }
21656
21657 if (IS_UNUSED != IS_UNUSED) {
21658 zval *offset = NULL;
21659 zend_string *str;
21660 zend_ulong hval;
21661
21662add_again:
21663 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21664 str = Z_STR_P(offset);
21665 if (IS_UNUSED != IS_CONST) {
21666 if (ZEND_HANDLE_NUMERIC(str, hval)) {
21667 goto num_index;
21668 }
21669 }
21670str_index:
21671 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21672 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21673 hval = Z_LVAL_P(offset);
21674num_index:
21675 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21676 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21677 offset = Z_REFVAL_P(offset);
21678 goto add_again;
21679 } else if (Z_TYPE_P(offset) == IS_NULL) {
21680 str = ZSTR_EMPTY_ALLOC();
21681 goto str_index;
21682 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21683 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21684 goto num_index;
21685 } else if (Z_TYPE_P(offset) == IS_FALSE) {
21686 hval = 0;
21687 goto num_index;
21688 } else if (Z_TYPE_P(offset) == IS_TRUE) {
21689 hval = 1;
21690 goto num_index;
21691 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21692 zend_use_resource_as_offset(offset);
21693 hval = Z_RES_HANDLE_P(offset);
21694 goto num_index;
21695 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21696 ZVAL_UNDEFINED_OP2();
21697 str = ZSTR_EMPTY_ALLOC();
21698 goto str_index;
21699 } else {
21700 zend_illegal_array_offset_access(offset);
21701 zval_ptr_dtor_nogc(expr_ptr);
21702 }
21703
21704 } else {
21705 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21706 zend_cannot_add_element();
21707 zval_ptr_dtor_nogc(expr_ptr);
21708 }
21709 }
21710 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21711}
21712
21713static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21714{
21715 zval *array;
21716 uint32_t size;
21717 USE_OPLINE
21718
21719 SAVE_OPLINE();
21720 array = EX_VAR(opline->result.var);
21721 if (IS_TMP_VAR != IS_UNUSED) {
21722 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21723 ZVAL_ARR(array, zend_new_array(size));
21724 /* Explicitly initialize array as not-packed if flag is set */
21725 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21726 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21727 }
21728 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21729 } else {
21730 ZVAL_ARR(array, zend_new_array(0));
21731 ZEND_VM_NEXT_OPCODE();
21732 }
21733}
21734
21735static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21736{
21737 USE_OPLINE
21738
21739 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21740
21741 SAVE_OPLINE();
21742 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21743 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21744 }
21745
21746 /* Destroy the previously yielded value */
21747 zval_ptr_dtor(&generator->value);
21748
21749 /* Destroy the previously yielded key */
21750 zval_ptr_dtor(&generator->key);
21751
21752 /* Set the new yielded value */
21753 if (IS_TMP_VAR != IS_UNUSED) {
21754 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21755 /* Constants and temporary variables aren't yieldable by reference,
21756 * but we still allow them with a notice. */
21757 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21758 zval *value;
21759
21760 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21761
21762 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21763 ZVAL_COPY_VALUE(&generator->value, value);
21764 if (IS_TMP_VAR == IS_CONST) {
21765 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21766 Z_ADDREF(generator->value);
21767 }
21768 }
21769 } else {
21770 zval *value_ptr = zend_get_bad_ptr();
21771
21772 /* If a function call result is yielded and the function did
21773 * not return by reference we throw a notice. */
21774 do {
21775 if (IS_TMP_VAR == IS_VAR) {
21776 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21777 if (opline->extended_value == ZEND_RETURNS_FUNCTION
21778 && !Z_ISREF_P(value_ptr)) {
21779 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21780 ZVAL_COPY(&generator->value, value_ptr);
21781 break;
21782 }
21783 }
21784 if (Z_ISREF_P(value_ptr)) {
21785 Z_ADDREF_P(value_ptr);
21786 } else {
21787 ZVAL_MAKE_REF_EX(value_ptr, 2);
21788 }
21789 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21790 } while (0);
21791
21792 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21793 }
21794 } else {
21795 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21796
21797 /* Consts, temporary variables and references need copying */
21798 if (IS_TMP_VAR == IS_CONST) {
21799 ZVAL_COPY_VALUE(&generator->value, value);
21800 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21801 Z_ADDREF(generator->value);
21802 }
21803 } else if (IS_TMP_VAR == IS_TMP_VAR) {
21804 ZVAL_COPY_VALUE(&generator->value, value);
21805 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21806 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21807
21808 } else {
21809 ZVAL_COPY_VALUE(&generator->value, value);
21810 if (IS_TMP_VAR == IS_CV) {
21811 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21812 }
21813 }
21814 }
21815 } else {
21816 /* If no value was specified yield null */
21817 ZVAL_NULL(&generator->value);
21818 }
21819
21820 /* Set the new yielded key */
21821 if (IS_UNUSED != IS_UNUSED) {
21822 zval *key = NULL;
21823 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21824 key = Z_REFVAL_P(key);
21825 }
21826 ZVAL_COPY(&generator->key, key);
21827
21828 if (Z_TYPE(generator->key) == IS_LONG
21829 && Z_LVAL(generator->key) > generator->largest_used_integer_key
21830 ) {
21831 generator->largest_used_integer_key = Z_LVAL(generator->key);
21832 }
21833 } else {
21834 /* If no key was specified we use auto-increment keys */
21835 generator->largest_used_integer_key++;
21836 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21837 }
21838
21839 if (RETURN_VALUE_USED(opline)) {
21840 /* If the return value of yield is used set the send
21841 * target and initialize it to NULL */
21842 generator->send_target = EX_VAR(opline->result.var);
21843 ZVAL_NULL(generator->send_target);
21844 } else {
21845 generator->send_target = NULL;
21846 }
21847
21848 /* The GOTO VM uses a local opline variable. We need to set the opline
21849 * variable in execute_data so we don't resume at an old position. */
21850 SAVE_OPLINE();
21851
21852 ZEND_VM_RETURN();
21853}
21854
21855static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21856{
21857 USE_OPLINE
21858 zval *op1;
21859 zend_string *type;
21860
21861 SAVE_OPLINE();
21862 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21863 type = zend_zval_get_legacy_type(op1);
21864 if (EXPECTED(type)) {
21865 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
21866 } else {
21867 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
21868 }
21869 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21870 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21871}
21872
21873static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21874{
21875 USE_OPLINE
21876 zval *op1, *op2;
21877 bool result;
21878
21879 SAVE_OPLINE();
21880 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21881 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21882 result = fast_is_identical_function(op1, op2);
21883
21884 ZEND_VM_SMART_BRANCH(result, 1);
21885}
21886
21887static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21888{
21889#if 0
21890 USE_OPLINE
21891#endif
21892
21893 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21894 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21895 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21896 }
21897 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21898 } else {
21899 if (IS_CV == IS_UNUSED) {
21900 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21901 }
21902 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21903 }
21904}
21905
21906static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21907{
21908#if 0
21909 USE_OPLINE
21910#endif
21911
21912 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21913 /* Behave like FETCH_OBJ_W */
21914 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21915 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21916 }
21917 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21918 } else {
21919 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21920 }
21921}
21922
21923static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21924{
21925 USE_OPLINE
21926 zend_string **rope;
21927 zval *var;
21928
21929 /* op1 and result are the same */
21930 rope = (zend_string**)EX_VAR(opline->op1.var);
21931 if (IS_CV == IS_CONST) {
21932 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21933 rope[opline->extended_value] = Z_STR_P(var);
21934 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21935 Z_ADDREF_P(var);
21936 }
21937 } else {
21938 var = EX_VAR(opline->op2.var);
21939 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21940 if (IS_CV == IS_CV) {
21941 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21942 } else {
21943 rope[opline->extended_value] = Z_STR_P(var);
21944 }
21945 } else {
21946 SAVE_OPLINE();
21947 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21948 ZVAL_UNDEFINED_OP2();
21949 }
21950 rope[opline->extended_value] = zval_get_string_func(var);
21951
21952 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21953 }
21954 }
21955 ZEND_VM_NEXT_OPCODE();
21956}
21957
21958static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21959{
21960 USE_OPLINE
21961 zend_string **rope;
21962 zval *var, *ret;
21963 uint32_t i;
21964
21965 rope = (zend_string**)EX_VAR(opline->op1.var);
21966 if (IS_CV == IS_CONST) {
21967 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21968 rope[opline->extended_value] = Z_STR_P(var);
21969 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21970 Z_ADDREF_P(var);
21971 }
21972 } else {
21973 var = EX_VAR(opline->op2.var);
21974 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21975 if (IS_CV == IS_CV) {
21976 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21977 } else {
21978 rope[opline->extended_value] = Z_STR_P(var);
21979 }
21980 } else {
21981 SAVE_OPLINE();
21982 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21983 ZVAL_UNDEFINED_OP2();
21984 }
21985 rope[opline->extended_value] = zval_get_string_func(var);
21986
21987 if (UNEXPECTED(EG(exception))) {
21988 for (i = 0; i <= opline->extended_value; i++) {
21989 zend_string_release_ex(rope[i], 0);
21990 }
21991 ZVAL_UNDEF(EX_VAR(opline->result.var));
21992 HANDLE_EXCEPTION();
21993 }
21994 }
21995 }
21996
21997 size_t len = 0;
21998 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
21999 for (i = 0; i <= opline->extended_value; i++) {
22000 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
22001 len += ZSTR_LEN(rope[i]);
22002 }
22003 ret = EX_VAR(opline->result.var);
22004 ZVAL_STR(ret, zend_string_alloc(len, 0));
22005 GC_ADD_FLAGS(Z_STR_P(ret), flags);
22006
22007 char *target = Z_STRVAL_P(ret);
22008 for (i = 0; i <= opline->extended_value; i++) {
22009 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
22010 target += ZSTR_LEN(rope[i]);
22011 zend_string_release_ex(rope[i], 0);
22012 }
22013 *target = '\0';
22014
22015 ZEND_VM_NEXT_OPCODE();
22016}
22017
22018static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22019{
22020 USE_OPLINE
22021 zval *expr_ptr, new_expr;
22022
22023 SAVE_OPLINE();
22024 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
22025 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
22026 expr_ptr = zend_get_bad_ptr();
22027 if (Z_ISREF_P(expr_ptr)) {
22028 Z_ADDREF_P(expr_ptr);
22029 } else {
22030 ZVAL_MAKE_REF_EX(expr_ptr, 2);
22031 }
22032 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22033 } else {
22034 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22035 if (IS_TMP_VAR == IS_TMP_VAR) {
22036 /* pass */
22037 } else if (IS_TMP_VAR == IS_CONST) {
22038 Z_TRY_ADDREF_P(expr_ptr);
22039 } else if (IS_TMP_VAR == IS_CV) {
22040 ZVAL_DEREF(expr_ptr);
22041 Z_TRY_ADDREF_P(expr_ptr);
22042 } else /* if (IS_TMP_VAR == IS_VAR) */ {
22043 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
22044 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
22045
22046 expr_ptr = Z_REFVAL_P(expr_ptr);
22047 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22048 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
22049 expr_ptr = &new_expr;
22050 efree_size(ref, sizeof(zend_reference));
22051 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
22052 Z_ADDREF_P(expr_ptr);
22053 }
22054 }
22055 }
22056 }
22057
22058 if (IS_CV != IS_UNUSED) {
22059 zval *offset = EX_VAR(opline->op2.var);
22060 zend_string *str;
22061 zend_ulong hval;
22062
22063add_again:
22064 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
22065 str = Z_STR_P(offset);
22066 if (IS_CV != IS_CONST) {
22067 if (ZEND_HANDLE_NUMERIC(str, hval)) {
22068 goto num_index;
22069 }
22070 }
22071str_index:
22072 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
22073 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
22074 hval = Z_LVAL_P(offset);
22075num_index:
22076 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
22077 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
22078 offset = Z_REFVAL_P(offset);
22079 goto add_again;
22080 } else if (Z_TYPE_P(offset) == IS_NULL) {
22081 str = ZSTR_EMPTY_ALLOC();
22082 goto str_index;
22083 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
22084 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
22085 goto num_index;
22086 } else if (Z_TYPE_P(offset) == IS_FALSE) {
22087 hval = 0;
22088 goto num_index;
22089 } else if (Z_TYPE_P(offset) == IS_TRUE) {
22090 hval = 1;
22091 goto num_index;
22092 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
22093 zend_use_resource_as_offset(offset);
22094 hval = Z_RES_HANDLE_P(offset);
22095 goto num_index;
22096 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
22097 ZVAL_UNDEFINED_OP2();
22098 str = ZSTR_EMPTY_ALLOC();
22099 goto str_index;
22100 } else {
22101 zend_illegal_array_offset_access(offset);
22102 zval_ptr_dtor_nogc(expr_ptr);
22103 }
22104
22105 } else {
22106 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
22107 zend_cannot_add_element();
22108 zval_ptr_dtor_nogc(expr_ptr);
22109 }
22110 }
22111 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22112}
22113
22114static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22115{
22116 zval *array;
22117 uint32_t size;
22118 USE_OPLINE
22119
22120 SAVE_OPLINE();
22121 array = EX_VAR(opline->result.var);
22122 if (IS_TMP_VAR != IS_UNUSED) {
22123 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
22124 ZVAL_ARR(array, zend_new_array(size));
22125 /* Explicitly initialize array as not-packed if flag is set */
22126 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
22127 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
22128 }
22129 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22130 } else {
22131 ZVAL_ARR(array, zend_new_array(0));
22132 ZEND_VM_NEXT_OPCODE();
22133 }
22134}
22135
22136static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22137{
22138 USE_OPLINE
22139
22140 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
22141
22142 SAVE_OPLINE();
22143 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
22144 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22145 }
22146
22147 /* Destroy the previously yielded value */
22148 zval_ptr_dtor(&generator->value);
22149
22150 /* Destroy the previously yielded key */
22151 zval_ptr_dtor(&generator->key);
22152
22153 /* Set the new yielded value */
22154 if (IS_TMP_VAR != IS_UNUSED) {
22155 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
22156 /* Constants and temporary variables aren't yieldable by reference,
22157 * but we still allow them with a notice. */
22158 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
22159 zval *value;
22160
22161 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22162
22163 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22164 ZVAL_COPY_VALUE(&generator->value, value);
22165 if (IS_TMP_VAR == IS_CONST) {
22166 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
22167 Z_ADDREF(generator->value);
22168 }
22169 }
22170 } else {
22171 zval *value_ptr = zend_get_bad_ptr();
22172
22173 /* If a function call result is yielded and the function did
22174 * not return by reference we throw a notice. */
22175 do {
22176 if (IS_TMP_VAR == IS_VAR) {
22177 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
22178 if (opline->extended_value == ZEND_RETURNS_FUNCTION
22179 && !Z_ISREF_P(value_ptr)) {
22180 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22181 ZVAL_COPY(&generator->value, value_ptr);
22182 break;
22183 }
22184 }
22185 if (Z_ISREF_P(value_ptr)) {
22186 Z_ADDREF_P(value_ptr);
22187 } else {
22188 ZVAL_MAKE_REF_EX(value_ptr, 2);
22189 }
22190 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
22191 } while (0);
22192
22193 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22194 }
22195 } else {
22196 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22197
22198 /* Consts, temporary variables and references need copying */
22199 if (IS_TMP_VAR == IS_CONST) {
22200 ZVAL_COPY_VALUE(&generator->value, value);
22201 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
22202 Z_ADDREF(generator->value);
22203 }
22204 } else if (IS_TMP_VAR == IS_TMP_VAR) {
22205 ZVAL_COPY_VALUE(&generator->value, value);
22206 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
22207 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
22208
22209 } else {
22210 ZVAL_COPY_VALUE(&generator->value, value);
22211 if (IS_TMP_VAR == IS_CV) {
22212 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
22213 }
22214 }
22215 }
22216 } else {
22217 /* If no value was specified yield null */
22218 ZVAL_NULL(&generator->value);
22219 }
22220
22221 /* Set the new yielded key */
22222 if (IS_CV != IS_UNUSED) {
22223 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
22224 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
22225 key = Z_REFVAL_P(key);
22226 }
22227 ZVAL_COPY(&generator->key, key);
22228
22229 if (Z_TYPE(generator->key) == IS_LONG
22230 && Z_LVAL(generator->key) > generator->largest_used_integer_key
22231 ) {
22232 generator->largest_used_integer_key = Z_LVAL(generator->key);
22233 }
22234 } else {
22235 /* If no key was specified we use auto-increment keys */
22236 generator->largest_used_integer_key++;
22237 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
22238 }
22239
22240 if (RETURN_VALUE_USED(opline)) {
22241 /* If the return value of yield is used set the send
22242 * target and initialize it to NULL */
22243 generator->send_target = EX_VAR(opline->result.var);
22244 ZVAL_NULL(generator->send_target);
22245 } else {
22246 generator->send_target = NULL;
22247 }
22248
22249 /* The GOTO VM uses a local opline variable. We need to set the opline
22250 * variable in execute_data so we don't resume at an old position. */
22251 SAVE_OPLINE();
22252
22253 ZEND_VM_RETURN();
22254}
22255
22256static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22257{
22258 USE_OPLINE
22259 zval *closure, *var;
22260
22261 closure = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22262 if (opline->extended_value & ZEND_BIND_REF) {
22263 /* By-ref binding */
22264 var = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
22265 if (Z_ISREF_P(var)) {
22266 Z_ADDREF_P(var);
22267 } else {
22268 ZVAL_MAKE_REF_EX(var, 2);
22269 }
22270 } else {
22271 var = EX_VAR(opline->op2.var);
22272 if (UNEXPECTED(Z_ISUNDEF_P(var)) && !(opline->extended_value & ZEND_BIND_IMPLICIT)) {
22273 SAVE_OPLINE();
22274 var = ZVAL_UNDEFINED_OP2();
22275 if (UNEXPECTED(EG(exception))) {
22276 HANDLE_EXCEPTION();
22277 }
22278 }
22279 ZVAL_DEREF(var);
22280 Z_TRY_ADDREF_P(var);
22281 }
22282
22283 zend_closure_bind_var_ex(closure,
22284 (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT)), var);
22285 ZEND_VM_NEXT_OPCODE();
22286}
22287
22288static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22289{
22290 USE_OPLINE
22291 zval *var_ptr;
22292
22293 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22294
22295 SAVE_OPLINE();
22296 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22297 ZVAL_UNDEFINED_OP1();
22298 ZVAL_NULL(var_ptr);
22299 }
22300
22301 do {
22302 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22303 zend_reference *ref = Z_REF_P(var_ptr);
22304 var_ptr = Z_REFVAL_P(var_ptr);
22305 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22306 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
22307 break;
22308 }
22309 }
22310 increment_function(var_ptr);
22311 } while (0);
22312
22313 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
22314 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22315 }
22316
22317 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22318 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22319}
22320
22321static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22322{
22323 USE_OPLINE
22324 zval *var_ptr;
22325
22326 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22327
22328 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22329 fast_long_increment_function(var_ptr);
22330 if (UNEXPECTED(0)) {
22331 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22332 }
22333 ZEND_VM_NEXT_OPCODE();
22334 }
22335
22336 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22337}
22338
22339static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22340{
22341 USE_OPLINE
22342 zval *var_ptr;
22343
22344 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22345
22346 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22347 fast_long_increment_function(var_ptr);
22348 if (UNEXPECTED(1)) {
22349 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22350 }
22351 ZEND_VM_NEXT_OPCODE();
22352 }
22353
22354 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22355}
22356
22357static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22358{
22359 USE_OPLINE
22360 zval *var_ptr;
22361
22362 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22363
22364 SAVE_OPLINE();
22365 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22366 ZVAL_UNDEFINED_OP1();
22367 ZVAL_NULL(var_ptr);
22368 }
22369
22370 do {
22371 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22372 zend_reference *ref = Z_REF_P(var_ptr);
22373 var_ptr = Z_REFVAL_P(var_ptr);
22374
22375 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22376 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
22377 break;
22378 }
22379 }
22380 decrement_function(var_ptr);
22381 } while (0);
22382
22383 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
22384 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22385 }
22386
22387 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22388 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22389}
22390
22391static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22392{
22393 USE_OPLINE
22394 zval *var_ptr;
22395
22396 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22397
22398 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22399 fast_long_decrement_function(var_ptr);
22400 if (UNEXPECTED(0)) {
22401 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22402 }
22403 ZEND_VM_NEXT_OPCODE();
22404 }
22405
22406 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22407}
22408
22409static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22410{
22411 USE_OPLINE
22412 zval *var_ptr;
22413
22414 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22415
22416 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22417 fast_long_decrement_function(var_ptr);
22418 if (UNEXPECTED(1)) {
22419 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22420 }
22421 ZEND_VM_NEXT_OPCODE();
22422 }
22423
22424 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22425}
22426
22427static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22428{
22429 USE_OPLINE
22430 zval *var_ptr;
22431
22432 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22433
22434 SAVE_OPLINE();
22435 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22436 ZVAL_UNDEFINED_OP1();
22437 ZVAL_NULL(var_ptr);
22438 }
22439
22440 do {
22441 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22442 zend_reference *ref = Z_REF_P(var_ptr);
22443 var_ptr = Z_REFVAL_P(var_ptr);
22444
22445 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22446 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
22447 break;
22448 }
22449 }
22450 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22451
22452 increment_function(var_ptr);
22453 } while (0);
22454
22455 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22456 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22457}
22458
22459static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22460{
22461 USE_OPLINE
22462 zval *var_ptr;
22463
22464 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22465
22466 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22467 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
22468 fast_long_increment_function(var_ptr);
22469 ZEND_VM_NEXT_OPCODE();
22470 }
22471
22472 ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22473}
22474
22475static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22476{
22477 USE_OPLINE
22478 zval *var_ptr;
22479
22480 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22481
22482 SAVE_OPLINE();
22483 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22484 ZVAL_UNDEFINED_OP1();
22485 ZVAL_NULL(var_ptr);
22486 }
22487
22488 do {
22489 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22490 zend_reference *ref = Z_REF_P(var_ptr);
22491 var_ptr = Z_REFVAL_P(var_ptr);
22492
22493 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22494 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
22495 break;
22496 }
22497 }
22498 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22499
22500 decrement_function(var_ptr);
22501 } while (0);
22502
22503 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22504 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22505}
22506
22507static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22508{
22509 USE_OPLINE
22510 zval *var_ptr;
22511
22512 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22513
22514 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22515 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
22516 fast_long_decrement_function(var_ptr);
22517 ZEND_VM_NEXT_OPCODE();
22518 }
22519
22520 ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22521}
22522
22523static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22524{
22525 USE_OPLINE
22526 zval *retval_ptr;
22527 zval *return_value;
22528
22529 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22530 return_value = EX(return_value);
22531
22532 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
22533 SAVE_OPLINE();
22534 retval_ptr = ZVAL_UNDEFINED_OP1();
22535 if (return_value) {
22536 ZVAL_NULL(return_value);
22537 }
22538 } else if (!return_value) {
22539 if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
22540 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
22541 SAVE_OPLINE();
22542 rc_dtor_func(Z_COUNTED_P(retval_ptr));
22543 }
22544 }
22545 } else {
22546 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22547 ZVAL_COPY_VALUE(return_value, retval_ptr);
22548 if (IS_VAR == IS_CONST) {
22549 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
22550 Z_ADDREF_P(return_value);
22551 }
22552 }
22553 } else if (IS_VAR == IS_CV) {
22554 do {
22555 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22556 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
22557 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
22558 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22559 ZVAL_COPY_VALUE(return_value, retval_ptr);
22560 if (GC_MAY_LEAK(ref)) {
22561 SAVE_OPLINE();
22562 gc_possible_root(ref);
22563 }
22564 ZVAL_NULL(retval_ptr);
22565 break;
22566 } else {
22567 Z_ADDREF_P(retval_ptr);
22568 }
22569 } else {
22570 retval_ptr = Z_REFVAL_P(retval_ptr);
22571 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22572 Z_ADDREF_P(retval_ptr);
22573 }
22574 }
22575 }
22576 ZVAL_COPY_VALUE(return_value, retval_ptr);
22577 } while (0);
22578 } else /* if (IS_VAR == IS_VAR) */ {
22579 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22580 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22581
22582 retval_ptr = Z_REFVAL_P(retval_ptr);
22583 ZVAL_COPY_VALUE(return_value, retval_ptr);
22584 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22585 efree_size(ref, sizeof(zend_reference));
22586 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22587 Z_ADDREF_P(retval_ptr);
22588 }
22589 } else {
22590 ZVAL_COPY_VALUE(return_value, retval_ptr);
22591 }
22592 }
22593 }
22594
22595
22596
22597 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22598}
22599
22600static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22601{
22602 USE_OPLINE
22603 zval *retval_ptr;
22604 zval *return_value;
22605
22606 SAVE_OPLINE();
22607
22608 return_value = EX(return_value);
22609
22610 do {
22611 if ((IS_VAR & (IS_CONST|IS_TMP_VAR)) ||
22612 (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
22613 /* Not supposed to happen, but we'll allow it */
22614 zend_error(E_NOTICE, "Only variable references should be returned by reference");
22615
22616 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22617 if (!return_value) {
22618 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22619 } else {
22620 if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22621 ZVAL_COPY_VALUE(return_value, retval_ptr);
22622 break;
22623 }
22624
22625 ZVAL_NEW_REF(return_value, retval_ptr);
22626 if (IS_VAR == IS_CONST) {
22627 Z_TRY_ADDREF_P(retval_ptr);
22628 }
22629 }
22630 break;
22631 }
22632
22633 retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22634
22635 if (IS_VAR == IS_VAR) {
22636 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
22637 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
22638 zend_error(E_NOTICE, "Only variable references should be returned by reference");
22639 if (return_value) {
22640 ZVAL_NEW_REF(return_value, retval_ptr);
22641 } else {
22642 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22643 }
22644 break;
22645 }
22646 }
22647
22648 if (return_value) {
22649 if (Z_ISREF_P(retval_ptr)) {
22650 Z_ADDREF_P(retval_ptr);
22651 } else {
22652 ZVAL_MAKE_REF_EX(retval_ptr, 2);
22653 }
22654 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
22655 }
22656
22657 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22658 } while (0);
22659
22660
22661 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22662}
22663
22664static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22665{
22666 USE_OPLINE
22667 zval *retval;
22668
22669 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
22670
22671 SAVE_OPLINE();
22672 retval = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22673
22674 /* Copy return value into generator->retval */
22675 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22676 ZVAL_COPY_VALUE(&generator->retval, retval);
22677 if (IS_VAR == IS_CONST) {
22678 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
22679 Z_ADDREF(generator->retval);
22680 }
22681 }
22682 } else if (IS_VAR == IS_CV) {
22683 ZVAL_COPY_DEREF(&generator->retval, retval);
22684 } else /* if (IS_VAR == IS_VAR) */ {
22685 if (UNEXPECTED(Z_ISREF_P(retval))) {
22686 zend_refcounted *ref = Z_COUNTED_P(retval);
22687
22688 retval = Z_REFVAL_P(retval);
22689 ZVAL_COPY_VALUE(&generator->retval, retval);
22690 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22691 efree_size(ref, sizeof(zend_reference));
22692 } else if (Z_OPT_REFCOUNTED_P(retval)) {
22693 Z_ADDREF_P(retval);
22694 }
22695 } else {
22696 ZVAL_COPY_VALUE(&generator->retval, retval);
22697 }
22698 }
22699
22700 EG(current_execute_data) = EX(prev_execute_data);
22701
22702 /* Close the generator to free up resources */
22703 zend_generator_close(generator, 1);
22704
22705 /* Pass execution back to handling code */
22706 ZEND_VM_RETURN();
22707}
22708
22709static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22710{
22711 USE_OPLINE
22712 zval *arg, *param;
22713
22714 SAVE_OPLINE();
22715
22716 arg = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22717 param = ZEND_CALL_VAR(EX(call), opline->result.var);
22718 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
22719 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
22720 Z_TRY_ADDREF_P(arg);
22721 ZVAL_NEW_REF(param, arg);
22722 } else {
22723 ZVAL_COPY(param, arg);
22724 }
22725
22726 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22727 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22728}
22729
22730static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22731{
22732 USE_OPLINE
22733 zval *expr;
22734 zval *result = EX_VAR(opline->result.var);
22735 HashTable *ht;
22736
22737 SAVE_OPLINE();
22738 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22739
22740 switch (opline->extended_value) {
22741 case IS_LONG:
22742 ZVAL_LONG(result, zval_get_long(expr));
22743 break;
22744 case IS_DOUBLE:
22745 ZVAL_DOUBLE(result, zval_get_double(expr));
22746 break;
22747 case IS_STRING:
22748 ZVAL_STR(result, zval_get_string(expr));
22749 break;
22750 default:
22751 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
22752 if (IS_VAR & (IS_VAR|IS_CV)) {
22753 ZVAL_DEREF(expr);
22754 }
22755 /* If value is already of correct type, return it directly */
22756 if (Z_TYPE_P(expr) == opline->extended_value) {
22757 ZVAL_COPY_VALUE(result, expr);
22758 if (IS_VAR == IS_CONST) {
22759 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
22760 } else if (IS_VAR != IS_TMP_VAR) {
22761 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
22762 }
22763
22764 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22765 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22766 }
22767
22768 if (opline->extended_value == IS_ARRAY) {
22769 if (IS_VAR == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
22770 if (Z_TYPE_P(expr) != IS_NULL) {
22771 ZVAL_ARR(result, zend_new_array(1));
22772 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
22773 if (IS_VAR == IS_CONST) {
22774 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
22775 } else {
22776 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
22777 }
22778 } else {
22779 ZVAL_EMPTY_ARRAY(result);
22780 }
22781 } else if (ZEND_STD_BUILD_OBJECT_PROPERTIES_ARRAY_COMPATIBLE(expr)) {
22782 /* Optimized version without rebuilding properties HashTable */
22783 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
22784 } else {
22785 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
22786 if (obj_ht) {
22787 /* fast copy */
22788 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
22789 (Z_OBJCE_P(expr)->default_properties_count ||
22790 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
22791 GC_IS_RECURSIVE(obj_ht))));
22792 zend_release_properties(obj_ht);
22793 } else {
22794 ZVAL_EMPTY_ARRAY(result);
22795 }
22796 }
22797 } else {
22798 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
22799 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
22800 if (Z_TYPE_P(expr) == IS_ARRAY) {
22801 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
22802 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
22803 /* TODO: try not to duplicate immutable arrays as well ??? */
22804 ht = zend_array_dup(ht);
22805 }
22806 Z_OBJ_P(result)->properties = ht;
22807 } else if (Z_TYPE_P(expr) != IS_NULL) {
22808 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
22809 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
22810 if (IS_VAR == IS_CONST) {
22811 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
22812 } else {
22813 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
22814 }
22815 }
22816 }
22817 }
22818
22819 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22820 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22821}
22822
22823static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22824{
22825 USE_OPLINE
22826 zval *array_ptr, *result;
22827
22828 SAVE_OPLINE();
22829
22830 array_ptr = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22831 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
22832 result = EX_VAR(opline->result.var);
22833 ZVAL_COPY_VALUE(result, array_ptr);
22834 if (IS_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
22835 Z_ADDREF_P(array_ptr);
22836 }
22837 Z_FE_POS_P(result) = 0;
22838
22839 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22840 ZEND_VM_NEXT_OPCODE();
22841 } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
22842 zend_object *zobj = Z_OBJ_P(array_ptr);
22843 if (!zobj->ce->get_iterator) {
22844 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
22845 zobj = zend_lazy_object_init(zobj);
22846 if (UNEXPECTED(EG(exception))) {
22847 UNDEF_RESULT();
22848 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22849 HANDLE_EXCEPTION();
22850 }
22851 }
22852 HashTable *properties = zobj->properties;
22853 if (properties) {
22854 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
22855 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
22856 GC_DELREF(properties);
22857 }
22858 properties = zobj->properties = zend_array_dup(properties);
22859 }
22860 } else {
22861 properties = zobj->handlers->get_properties(zobj);
22862 }
22863
22864 result = EX_VAR(opline->result.var);
22865 ZVAL_COPY_VALUE(result, array_ptr);
22866 if (IS_VAR != IS_TMP_VAR) {
22867 Z_ADDREF_P(array_ptr);
22868 }
22869
22870 if (zend_hash_num_elements(properties) == 0) {
22871 Z_FE_ITER_P(result) = (uint32_t) -1;
22872 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22873 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22874 }
22875
22876 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
22877 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22878 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22879 } else {
22880 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
22881
22882 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22883 if (UNEXPECTED(EG(exception))) {
22884 HANDLE_EXCEPTION();
22885 } else if (is_empty) {
22886 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22887 } else {
22888 ZEND_VM_NEXT_OPCODE();
22889 }
22890 }
22891 } else {
22892 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
22893 ZVAL_UNDEF(EX_VAR(opline->result.var));
22894 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
22895 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22896 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22897 }
22898}
22899
22900static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22901{
22902 USE_OPLINE
22903 zval *array_ptr, *array_ref;
22904
22905 SAVE_OPLINE();
22906
22907 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22908 array_ref = array_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22909 if (Z_ISREF_P(array_ref)) {
22910 array_ptr = Z_REFVAL_P(array_ref);
22911 }
22912 } else {
22913 array_ref = array_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22914 }
22915
22916 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
22917 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22918 if (array_ptr == array_ref) {
22919 ZVAL_NEW_REF(array_ref, array_ref);
22920 array_ptr = Z_REFVAL_P(array_ref);
22921 }
22922 Z_ADDREF_P(array_ref);
22923 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
22924 } else {
22925 array_ref = EX_VAR(opline->result.var);
22926 ZVAL_NEW_REF(array_ref, array_ptr);
22927 array_ptr = Z_REFVAL_P(array_ref);
22928 }
22929 if (IS_VAR == IS_CONST) {
22930 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
22931 } else {
22932 SEPARATE_ARRAY(array_ptr);
22933 }
22934 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
22935
22936 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22937 ZEND_VM_NEXT_OPCODE();
22938 } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
22939 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
22940 zend_object *zobj = Z_OBJ_P(array_ptr);
22941 HashTable *properties;
22942 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
22943 zobj = zend_lazy_object_init(zobj);
22944 if (UNEXPECTED(EG(exception))) {
22945 UNDEF_RESULT();
22946 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22947 HANDLE_EXCEPTION();
22948 }
22949 }
22950 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22951 if (array_ptr == array_ref) {
22952 ZVAL_NEW_REF(array_ref, array_ref);
22953 array_ptr = Z_REFVAL_P(array_ref);
22954 }
22955 Z_ADDREF_P(array_ref);
22956 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
22957 } else {
22958 array_ptr = EX_VAR(opline->result.var);
22959 ZVAL_COPY_VALUE(array_ptr, array_ref);
22960 }
22961 if (Z_OBJ_P(array_ptr)->properties
22962 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
22963 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
22964 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
22965 }
22966 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
22967 }
22968
22969 properties = Z_OBJPROP_P(array_ptr);
22970 if (zend_hash_num_elements(properties) == 0) {
22971 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
22972 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22973 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22974 }
22975
22976 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
22977 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22978 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22979 } else {
22980 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
22981 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22982 if (UNEXPECTED(EG(exception))) {
22983 HANDLE_EXCEPTION();
22984 } else if (is_empty) {
22985 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22986 } else {
22987 ZEND_VM_NEXT_OPCODE();
22988 }
22989 }
22990 } else {
22991 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
22992 ZVAL_UNDEF(EX_VAR(opline->result.var));
22993 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
22994 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22995 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22996 }
22997}
22998
22999static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23000{
23001 USE_OPLINE
23002 zval *array;
23003 zval *value;
23004 uint32_t value_type;
23005 HashTable *fe_ht;
23006 HashPosition pos;
23007
23008 array = EX_VAR(opline->op1.var);
23009 if (UNEXPECTED(Z_TYPE_P(array) != IS_ARRAY)) {
23010 ZEND_VM_TAIL_CALL(zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23011 }
23012 fe_ht = Z_ARRVAL_P(array);
23013 pos = Z_FE_POS_P(array);
23014 if (HT_IS_PACKED(fe_ht)) {
23015 value = fe_ht->arPacked + pos;
23016 while (1) {
23017 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23018 /* reached end of iteration */
23019 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
23020 ZEND_VM_CONTINUE();
23021 }
23022 value_type = Z_TYPE_INFO_P(value);
23023 ZEND_ASSERT(value_type != IS_INDIRECT);
23024 if (EXPECTED(value_type != IS_UNDEF)) {
23025 break;
23026 }
23027 pos++;
23028 value++;
23029 }
23030 Z_FE_POS_P(array) = pos + 1;
23031 if (RETURN_VALUE_USED(opline)) {
23032 ZVAL_LONG(EX_VAR(opline->result.var), pos);
23033 }
23034 } else {
23035 Bucket *p;
23036
23037 p = fe_ht->arData + pos;
23038 while (1) {
23039 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23040 /* reached end of iteration */
23041 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
23042 ZEND_VM_CONTINUE();
23043 }
23044 pos++;
23045 value = &p->val;
23046 value_type = Z_TYPE_INFO_P(value);
23047 ZEND_ASSERT(value_type != IS_INDIRECT);
23048 if (EXPECTED(value_type != IS_UNDEF)) {
23049 break;
23050 }
23051 p++;
23052 }
23053 Z_FE_POS_P(array) = pos;
23054 if (RETURN_VALUE_USED(opline)) {
23055 if (!p->key) {
23056 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23057 } else {
23058 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23059 }
23060 }
23061 }
23062 if (EXPECTED(opline->op2_type == IS_CV)) {
23063 zval *variable_ptr = EX_VAR(opline->op2.var);
23064 SAVE_OPLINE();
23065 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
23066 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23067 } else {
23068 zval *res = EX_VAR(opline->op2.var);
23069 zend_refcounted *gc = Z_COUNTED_P(value);
23070
23071 ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
23072 if (Z_TYPE_INFO_REFCOUNTED(value_type)) {
23073 GC_ADDREF(gc);
23074 }
23075 ZEND_VM_NEXT_OPCODE();
23076 }
23077}
23078
23079static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23080{
23081 USE_OPLINE
23082 zval *array;
23083 zval *value;
23084 uint32_t value_type;
23085 HashTable *fe_ht;
23086 HashPosition pos;
23087 Bucket *p;
23088
23089 array = EX_VAR(opline->op1.var);
23090 SAVE_OPLINE();
23091
23092 ZVAL_DEREF(array);
23093 if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
23094 pos = zend_hash_iterator_pos_ex(Z_FE_ITER_P(EX_VAR(opline->op1.var)), array);
23095 fe_ht = Z_ARRVAL_P(array);
23096 if (HT_IS_PACKED(fe_ht)) {
23097 value = fe_ht->arPacked + pos;
23098 while (1) {
23099 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23100 /* reached end of iteration */
23101 goto fe_fetch_w_exit;
23102 }
23103 value_type = Z_TYPE_INFO_P(value);
23104 ZEND_ASSERT(value_type != IS_INDIRECT);
23105 if (EXPECTED(value_type != IS_UNDEF)) {
23106 break;
23107 }
23108 pos++;
23109 value++;
23110 }
23111 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos + 1;
23112 if (RETURN_VALUE_USED(opline)) {
23113 ZVAL_LONG(EX_VAR(opline->result.var), pos);
23114 }
23115 } else {
23116 p = fe_ht->arData + pos;
23117 while (1) {
23118 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23119 /* reached end of iteration */
23120 goto fe_fetch_w_exit;
23121 }
23122 pos++;
23123 value = &p->val;
23124 value_type = Z_TYPE_INFO_P(value);
23125 ZEND_ASSERT(value_type != IS_INDIRECT);
23126 if (EXPECTED(value_type != IS_UNDEF)) {
23127 break;
23128 }
23129 p++;
23130 }
23131 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
23132 if (RETURN_VALUE_USED(opline)) {
23133 if (!p->key) {
23134 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23135 } else {
23136 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23137 }
23138 }
23139 }
23140 } else if (EXPECTED(Z_TYPE_P(array) == IS_OBJECT)) {
23141 zend_object_iterator *iter;
23142
23143 if ((iter = zend_iterator_unwrap(array)) == NULL) {
23144 /* plain object */
23145
23146 fe_ht = Z_OBJPROP_P(array);
23147 pos = zend_hash_iterator_pos(Z_FE_ITER_P(EX_VAR(opline->op1.var)), fe_ht);
23148 p = fe_ht->arData + pos;
23149 while (1) {
23150 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23151 /* reached end of iteration */
23152 goto fe_fetch_w_exit;
23153 }
23154 pos++;
23155 value = &p->val;
23156 value_type = Z_TYPE_INFO_P(value);
23157 if (EXPECTED(value_type != IS_UNDEF)) {
23158 if (UNEXPECTED(value_type == IS_INDIRECT)) {
23159 value = Z_INDIRECT_P(value);
23160 value_type = Z_TYPE_INFO_P(value);
23161 if (EXPECTED(value_type != IS_UNDEF)
23162 && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
23163 if ((value_type & Z_TYPE_MASK) != IS_REFERENCE) {
23164 zend_property_info *prop_info =
23165 zend_get_property_info_for_slot(Z_OBJ_P(array), value);
23166 if (prop_info) {
23167 if (UNEXPECTED(prop_info->flags & ZEND_ACC_READONLY)) {
23168 zend_throw_error(NULL,
23169 "Cannot acquire reference to readonly property %s::$%s",
23170 ZSTR_VAL(prop_info->ce->name), ZSTR_VAL(p->key));
23171 UNDEF_RESULT();
23172 HANDLE_EXCEPTION();
23173 }
23174 if (ZEND_TYPE_IS_SET(prop_info->type)) {
23175 ZVAL_NEW_REF(value, value);
23176 ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(value), prop_info);
23177 value_type = IS_REFERENCE_EX;
23178 }
23179 }
23180 }
23181 break;
23182 }
23183 } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
23184 || !p->key
23185 || zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
23186 break;
23187 }
23188 }
23189 p++;
23190 }
23191 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
23192 if (RETURN_VALUE_USED(opline)) {
23193 if (UNEXPECTED(!p->key)) {
23194 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23195 } else if (ZSTR_VAL(p->key)[0]) {
23196 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23197 } else {
23198 const char *class_name, *prop_name;
23199 size_t prop_name_len;
23200 zend_unmangle_property_name_ex(
23201 p->key, &class_name, &prop_name, &prop_name_len);
23202 ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
23203 }
23204 }
23205 } else {
23206 const zend_object_iterator_funcs *funcs = iter->funcs;
23207 if (++iter->index > 0) {
23208 /* This could cause an endless loop if index becomes zero again.
23209 * In case that ever happens we need an additional flag. */
23210 funcs->move_forward(iter);
23211 if (UNEXPECTED(EG(exception) != NULL)) {
23212 UNDEF_RESULT();
23213 HANDLE_EXCEPTION();
23214 }
23215 if (UNEXPECTED(funcs->valid(iter) == FAILURE)) {
23216 /* reached end of iteration */
23217 if (UNEXPECTED(EG(exception) != NULL)) {
23218 UNDEF_RESULT();
23219 HANDLE_EXCEPTION();
23220 }
23221 goto fe_fetch_w_exit;
23222 }
23223 }
23224 value = funcs->get_current_data(iter);
23225 if (UNEXPECTED(EG(exception) != NULL)) {
23226 UNDEF_RESULT();
23227 HANDLE_EXCEPTION();
23228 }
23229 if (!value) {
23230 /* failure in get_current_data */
23231 goto fe_fetch_w_exit;
23232 }
23233 if (RETURN_VALUE_USED(opline)) {
23234 if (funcs->get_current_key) {
23235 funcs->get_current_key(iter, EX_VAR(opline->result.var));
23236 if (UNEXPECTED(EG(exception) != NULL)) {
23237 UNDEF_RESULT();
23238 HANDLE_EXCEPTION();
23239 }
23240 } else {
23241 ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
23242 }
23243 }
23244 value_type = Z_TYPE_INFO_P(value);
23245 }
23246 } else {
23247 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array));
23248 if (UNEXPECTED(EG(exception))) {
23249 UNDEF_RESULT();
23250 HANDLE_EXCEPTION();
23251 }
23252fe_fetch_w_exit:
23253 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
23254 ZEND_VM_CONTINUE();
23255 }
23256
23257 if (EXPECTED((value_type & Z_TYPE_MASK) != IS_REFERENCE)) {
23258 zend_refcounted *gc = Z_COUNTED_P(value);
23259 zval *ref;
23260 ZVAL_NEW_EMPTY_REF(value);
23261 ref = Z_REFVAL_P(value);
23262 ZVAL_COPY_VALUE_EX(ref, value, gc, value_type);
23263 }
23264 if (EXPECTED(opline->op2_type == IS_CV)) {
23265 zval *variable_ptr = EX_VAR(opline->op2.var);
23266 if (EXPECTED(variable_ptr != value)) {
23267 zend_reference *ref;
23268
23269 ref = Z_REF_P(value);
23270 GC_ADDREF(ref);
23271 i_zval_ptr_dtor(variable_ptr);
23272 ZVAL_REF(variable_ptr, ref);
23273 }
23274 } else {
23275 Z_ADDREF_P(value);
23276 ZVAL_REF(EX_VAR(opline->op2.var), Z_REF_P(value));
23277 }
23278 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23279}
23280
23281static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23282{
23283 USE_OPLINE
23284 zval *value;
23285 zend_reference *ref = NULL;
23286 bool ret;
23287
23288 SAVE_OPLINE();
23289 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23290
23291 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && Z_ISREF_P(value)) {
23292 if (IS_VAR == IS_VAR) {
23293 ref = Z_REF_P(value);
23294 }
23295 value = Z_REFVAL_P(value);
23296 }
23297
23298 ret = i_zend_is_true(value);
23299
23300 if (UNEXPECTED(EG(exception))) {
23301 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23302 ZVAL_UNDEF(EX_VAR(opline->result.var));
23303 HANDLE_EXCEPTION();
23304 }
23305
23306 if (ret) {
23307 zval *result = EX_VAR(opline->result.var);
23308
23309 ZVAL_COPY_VALUE(result, value);
23310 if (IS_VAR == IS_CONST) {
23311 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
23312 } else if (IS_VAR == IS_CV) {
23313 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
23314 } else if (IS_VAR == IS_VAR && ref) {
23315 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23316 efree_size(ref, sizeof(zend_reference));
23317 } else if (Z_OPT_REFCOUNTED_P(result)) {
23318 Z_ADDREF_P(result);
23319 }
23320 }
23321 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23322 }
23323
23324 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23325 ZEND_VM_NEXT_OPCODE();
23326}
23327
23328static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23329{
23330 USE_OPLINE
23331 zval *value;
23332 zend_reference *ref = NULL;
23333
23334 SAVE_OPLINE();
23335 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23336
23337 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
23338 if (IS_VAR & IS_VAR) {
23339 ref = Z_REF_P(value);
23340 }
23341 value = Z_REFVAL_P(value);
23342 }
23343
23344 if (Z_TYPE_P(value) > IS_NULL) {
23345 zval *result = EX_VAR(opline->result.var);
23346 ZVAL_COPY_VALUE(result, value);
23347 if (IS_VAR == IS_CONST) {
23348 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
23349 } else if (IS_VAR == IS_CV) {
23350 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
23351 } else if ((IS_VAR & IS_VAR) && ref) {
23352 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23353 efree_size(ref, sizeof(zend_reference));
23354 } else if (Z_OPT_REFCOUNTED_P(result)) {
23355 Z_ADDREF_P(result);
23356 }
23357 }
23358 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23359 }
23360
23361 if ((IS_VAR & IS_VAR) && ref) {
23362 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23363 efree_size(ref, sizeof(zend_reference));
23364 }
23365 }
23366 ZEND_VM_NEXT_OPCODE();
23367}
23368
23369static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23370{
23371 USE_OPLINE
23372 zval *val, *result;
23373
23374 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23375
23376 if (Z_TYPE_P(val) > IS_NULL) {
23377 do {
23378 if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
23379 val = Z_REFVAL_P(val);
23380 if (Z_TYPE_P(val) <= IS_NULL) {
23381 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23382 break;
23383 }
23384 }
23385 ZEND_VM_NEXT_OPCODE();
23386 } while (0);
23387 }
23388
23389 result = EX_VAR(opline->result.var);
23390 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
23391 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
23392 ZVAL_NULL(result);
23393 if (IS_VAR == IS_CV
23394 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
23395 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
23396 ) {
23397 SAVE_OPLINE();
23398 ZVAL_UNDEFINED_OP1();
23399 if (UNEXPECTED(EG(exception) != NULL)) {
23400 HANDLE_EXCEPTION();
23401 }
23402 }
23403 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
23404 ZVAL_FALSE(result);
23405 } else {
23406 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
23407 ZVAL_TRUE(result);
23408 }
23409
23410 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23411}
23412
23413static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23414{
23415 USE_OPLINE
23416 zval *value;
23417 zval *result = EX_VAR(opline->result.var);
23418
23419 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23420 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
23421 SAVE_OPLINE();
23422 ZVAL_UNDEFINED_OP1();
23423 ZVAL_NULL(result);
23424 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23425 }
23426
23427 if (IS_VAR == IS_CV) {
23428 ZVAL_COPY_DEREF(result, value);
23429 } else if (IS_VAR == IS_VAR) {
23430 if (UNEXPECTED(Z_ISREF_P(value))) {
23431 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
23432 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
23433 efree_size(Z_REF_P(value), sizeof(zend_reference));
23434 } else if (Z_OPT_REFCOUNTED_P(result)) {
23435 Z_ADDREF_P(result);
23436 }
23437 } else {
23438 ZVAL_COPY_VALUE(result, value);
23439 }
23440 } else {
23441 ZVAL_COPY_VALUE(result, value);
23442 if (IS_VAR == IS_CONST) {
23443 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
23444 Z_ADDREF_P(result);
23445 }
23446 }
23447 }
23448 ZEND_VM_NEXT_OPCODE();
23449}
23450
23451static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23452{
23453 USE_OPLINE
23454 zval *varptr, *arg;
23455
23456 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23457 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
23458
23459 if (IS_VAR == IS_CV) {
23460 ZVAL_COPY(arg, varptr);
23461 } else /* if (IS_VAR == IS_VAR) */ {
23462 ZVAL_COPY_VALUE(arg, varptr);
23463 }
23464
23465 ZEND_VM_NEXT_OPCODE();
23466}
23467
23468static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23469{
23470 USE_OPLINE
23471 zval *op1, *op2;
23472 bool result;
23473
23474 SAVE_OPLINE();
23475 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23476 op2 = RT_CONSTANT(opline, opline->op2);
23477 result = fast_is_identical_function(op1, op2);
23478 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23479
23480 ZEND_VM_SMART_BRANCH(result, 1);
23481}
23482
23483static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23484{
23485 USE_OPLINE
23486 zval *op1, *op2;
23487 bool result;
23488
23489 SAVE_OPLINE();
23490 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23491 op2 = RT_CONSTANT(opline, opline->op2);
23492 result = fast_is_identical_function(op1, op2);
23493
23494 ZEND_VM_SMART_BRANCH(result, 1);
23495}
23496
23497static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23498{
23499 USE_OPLINE
23500 zval *op1, *op2;
23501 bool result;
23502
23503 SAVE_OPLINE();
23504 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23505 op2 = RT_CONSTANT(opline, opline->op2);
23506 result = fast_is_not_identical_function(op1, op2);
23507 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23508
23509 ZEND_VM_SMART_BRANCH(result, 1);
23510}
23511
23512static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23513{
23514 USE_OPLINE
23515 zval *object;
23516 zval *property;
23517 zval *value;
23518 zval *zptr;
23519 void *_cache_slot[3] = {0};
23520 void **cache_slot;
23521 zend_property_info *prop_info;
23522 zend_object *zobj;
23523 zend_string *name, *tmp_name;
23524
23525 SAVE_OPLINE();
23526 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23527 property = RT_CONSTANT(opline, opline->op2);
23528
23529 do {
23530 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
23531
23532 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23533 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23534 object = Z_REFVAL_P(object);
23535 goto assign_op_object;
23536 }
23537 if (IS_VAR == IS_CV
23538 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23539 ZVAL_UNDEFINED_OP1();
23540 }
23541 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23542 break;
23543 }
23544
23545assign_op_object:
23546 /* here we are sure we are dealing with an object */
23547 zobj = Z_OBJ_P(object);
23548 if (IS_CONST == IS_CONST) {
23549 name = Z_STR_P(property);
23550 } else {
23551 name = zval_try_get_tmp_string(property, &tmp_name);
23552 if (UNEXPECTED(!name)) {
23553 UNDEF_RESULT();
23554 break;
23555 }
23556 }
23557 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
23558 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23559 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23560 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23561 ZVAL_NULL(EX_VAR(opline->result.var));
23562 }
23563 } else {
23564 zend_reference *ref;
23565
23566 do {
23567 if (UNEXPECTED(Z_ISREF_P(zptr))) {
23568 ref = Z_REF_P(zptr);
23569 zptr = Z_REFVAL_P(zptr);
23570 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23571 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23572 break;
23573 }
23574 }
23575
23576 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23577 if (prop_info) {
23578 /* special case for typed properties */
23579 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
23580 } else {
23581 zend_binary_op(zptr, zptr, value OPLINE_CC);
23582 }
23583 } while (0);
23584
23585 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23586 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
23587 }
23588 }
23589 } else {
23590 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
23591 }
23592 if (IS_CONST != IS_CONST) {
23593 zend_tmp_string_release(tmp_name);
23594 }
23595 } while (0);
23596
23597 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23598
23599 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23600 /* assign_obj has two opcodes! */
23601 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23602}
23603
23604/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
23605static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23606{
23607 USE_OPLINE
23608 zval *var_ptr;
23609 zval *value, *container, *dim;
23610 HashTable *ht;
23611
23612 SAVE_OPLINE();
23613 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23614
23615 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23616assign_dim_op_array:
23617 SEPARATE_ARRAY(container);
23618 ht = Z_ARRVAL_P(container);
23619assign_dim_op_new_array:
23620 dim = RT_CONSTANT(opline, opline->op2);
23621 if (IS_CONST == IS_UNUSED) {
23622 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
23623 if (UNEXPECTED(!var_ptr)) {
23624 zend_cannot_add_element();
23625 goto assign_dim_op_ret_null;
23626 }
23627 } else {
23628 if (IS_CONST == IS_CONST) {
23629 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
23630 } else {
23631 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
23632 }
23633 if (UNEXPECTED(!var_ptr)) {
23634 goto assign_dim_op_ret_null;
23635 }
23636 }
23637
23638 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
23639
23640 do {
23641 if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
23642 zend_reference *ref = Z_REF_P(var_ptr);
23643 var_ptr = Z_REFVAL_P(var_ptr);
23644 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23645 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23646 break;
23647 }
23648 }
23649 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23650 } while (0);
23651
23652 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23653 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23654 }
23655 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23656 } else {
23657 if (EXPECTED(Z_ISREF_P(container))) {
23658 container = Z_REFVAL_P(container);
23659 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23660 goto assign_dim_op_array;
23661 }
23662 }
23663
23664 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
23665 zend_object *obj = Z_OBJ_P(container);
23666
23667 dim = RT_CONSTANT(opline, opline->op2);
23668 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
23669 dim++;
23670 }
23671 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
23672 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
23673 uint8_t old_type;
23674
23675 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
23676 ZVAL_UNDEFINED_OP1();
23677 }
23678 ht = zend_new_array(8);
23679 old_type = Z_TYPE_P(container);
23680 ZVAL_ARR(container, ht);
23681 if (UNEXPECTED(old_type == IS_FALSE)) {
23682 GC_ADDREF(ht);
23683 zend_false_to_array_deprecated();
23684 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
23685 zend_array_destroy(ht);
23686 goto assign_dim_op_ret_null;
23687 }
23688 }
23689 goto assign_dim_op_new_array;
23690 } else {
23691 dim = RT_CONSTANT(opline, opline->op2);
23692 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
23693assign_dim_op_ret_null:
23694 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23695 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23696 ZVAL_NULL(EX_VAR(opline->result.var));
23697 }
23698 }
23699 }
23700
23701 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23702 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23703}
23704
23705static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23706{
23707 USE_OPLINE
23708 zval *var_ptr;
23709 zval *value;
23710
23711 SAVE_OPLINE();
23712 value = RT_CONSTANT(opline, opline->op2);
23713 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23714
23715 do {
23716 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
23717 zend_reference *ref = Z_REF_P(var_ptr);
23718 var_ptr = Z_REFVAL_P(var_ptr);
23719 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23720 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23721 break;
23722 }
23723 }
23724 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23725 } while (0);
23726
23727 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23728 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23729 }
23730
23731 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23732 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23733}
23734
23735static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23736{
23737 USE_OPLINE
23738 zval *object;
23739 zval *property;
23740 zval *zptr;
23741 void *_cache_slot[3] = {0};
23742 void **cache_slot;
23743 zend_property_info *prop_info;
23744 zend_object *zobj;
23745 zend_string *name, *tmp_name;
23746
23747 SAVE_OPLINE();
23748 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23749 property = RT_CONSTANT(opline, opline->op2);
23750
23751 do {
23752 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23753 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23754 object = Z_REFVAL_P(object);
23755 goto pre_incdec_object;
23756 }
23757 if (IS_VAR == IS_CV
23758 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23759 ZVAL_UNDEFINED_OP1();
23760 }
23761 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23762 break;
23763 }
23764
23765pre_incdec_object:
23766 /* here we are sure we are dealing with an object */
23767 zobj = Z_OBJ_P(object);
23768 if (IS_CONST == IS_CONST) {
23769 name = Z_STR_P(property);
23770 } else {
23771 name = zval_try_get_tmp_string(property, &tmp_name);
23772 if (UNEXPECTED(!name)) {
23773 UNDEF_RESULT();
23774 break;
23775 }
23776 }
23777 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
23778 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23779 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23780 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23781 ZVAL_NULL(EX_VAR(opline->result.var));
23782 }
23783 } else {
23784 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
23785 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23786 }
23787 } else {
23788 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23789 }
23790 if (IS_CONST != IS_CONST) {
23791 zend_tmp_string_release(tmp_name);
23792 }
23793 } while (0);
23794
23795 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23796 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23797}
23798
23799static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23800{
23801 USE_OPLINE
23802 zval *object;
23803 zval *property;
23804 zval *zptr;
23805 void *_cache_slot[3] = {0};
23806 void **cache_slot;
23807 zend_property_info *prop_info;
23808 zend_object *zobj;
23809 zend_string *name, *tmp_name;
23810
23811 SAVE_OPLINE();
23812 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23813 property = RT_CONSTANT(opline, opline->op2);
23814
23815 do {
23816 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23817 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23818 object = Z_REFVAL_P(object);
23819 goto post_incdec_object;
23820 }
23821 if (IS_VAR == IS_CV
23822 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23823 ZVAL_UNDEFINED_OP1();
23824 }
23825 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23826 break;
23827 }
23828
23829post_incdec_object:
23830 /* here we are sure we are dealing with an object */
23831 zobj = Z_OBJ_P(object);
23832 if (IS_CONST == IS_CONST) {
23833 name = Z_STR_P(property);
23834 } else {
23835 name = zval_try_get_tmp_string(property, &tmp_name);
23836 if (UNEXPECTED(!name)) {
23837 ZVAL_UNDEF(EX_VAR(opline->result.var));
23838 break;
23839 }
23840 }
23841 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
23842 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23843 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23844 ZVAL_NULL(EX_VAR(opline->result.var));
23845 } else {
23846 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23847 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23848 }
23849 } else {
23850 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23851 }
23852 if (IS_CONST != IS_CONST) {
23853 zend_tmp_string_release(tmp_name);
23854 }
23855 } while (0);
23856
23857 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23858 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23859}
23860
23861static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23862{
23863 USE_OPLINE
23864 zval *container;
23865
23866 SAVE_OPLINE();
23867 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23868 zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23869
23870 if (IS_VAR == IS_VAR) {
23871 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23872 }
23873 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23874}
23875
23876static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23877{
23878 USE_OPLINE
23879 zval *container;
23880
23881 SAVE_OPLINE();
23882 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23883 zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23884
23885 if (IS_VAR == IS_VAR) {
23886 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23887 }
23888 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23889}
23890
23891static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23892{
23893#if 0
23894 USE_OPLINE
23895#endif
23896
23897 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
23898 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
23899 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23900 }
23901 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23902 } else {
23903 if (IS_CONST == IS_UNUSED) {
23904 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23905 }
23906 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23907 }
23908}
23909
23910static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23911{
23912 USE_OPLINE
23913 zval *container;
23914
23915 SAVE_OPLINE();
23916 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23917 zend_fetch_dimension_address_UNSET(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23918
23919 if (IS_VAR == IS_VAR) {
23920 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23921 }
23922 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23923}
23924
23925static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23926{
23927 USE_OPLINE
23928 zval *property, *container, *result;
23929
23930 SAVE_OPLINE();
23931
23932 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23933 property = RT_CONSTANT(opline, opline->op2);
23934 result = EX_VAR(opline->result.var);
23935 zend_fetch_property_address(
23936 result, container, IS_VAR, property, IS_CONST,
23937 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
23938 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
23939
23940 if (IS_VAR == IS_VAR) {
23941 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23942 }
23943 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23944}
23945
23946static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23947{
23948 USE_OPLINE
23949 zval *property, *container, *result;
23950
23951 SAVE_OPLINE();
23952 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23953 property = RT_CONSTANT(opline, opline->op2);
23954 result = EX_VAR(opline->result.var);
23955 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);
23956
23957 if (IS_VAR == IS_VAR) {
23958 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23959 }
23960 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23961}
23962
23963static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23964{
23965#if 0
23966 USE_OPLINE
23967#endif
23968
23969 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
23970 /* Behave like FETCH_OBJ_W */
23971 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
23972 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23973 }
23974 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23975 } else {
23976 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23977 }
23978}
23979
23980static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23981{
23982 USE_OPLINE
23983 zval *container, *property, *result;
23984
23985 SAVE_OPLINE();
23986 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23987 property = RT_CONSTANT(opline, opline->op2);
23988 result = EX_VAR(opline->result.var);
23989 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);
23990
23991 if (IS_VAR == IS_VAR) {
23992 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23993 }
23994 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23995}
23996
23997static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23998{
23999 USE_OPLINE
24000 zval *container, *dim;
24001
24002 SAVE_OPLINE();
24003 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24004 dim = RT_CONSTANT(opline, opline->op2);
24005
24006 if (IS_VAR == IS_VAR
24007 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
24008 && UNEXPECTED(!Z_ISREF_P(container))
24009 ) {
24010 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
24011 zend_fetch_dimension_address_LIST_r(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
24012 } else {
24013 zend_fetch_dimension_address_W(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
24014 }
24015
24016 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24017}
24018
24019static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24020{
24021 USE_OPLINE
24022 zval *object, *value, tmp;
24023 zend_object *zobj;
24024 zend_string *name, *tmp_name;
24025 zend_refcounted *garbage = NULL;
24026
24027 SAVE_OPLINE();
24028 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24029 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24030
24031 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24032 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24033 object = Z_REFVAL_P(object);
24034 goto assign_object;
24035 }
24036 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24037 value = &EG(uninitialized_zval);
24038 goto free_and_exit_assign_obj;
24039 }
24040
24041assign_object:
24042 zobj = Z_OBJ_P(object);
24043 if (IS_CONST == IS_CONST) {
24044 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24045 void **cache_slot = CACHE_ADDR(opline->extended_value);
24046 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24047 zval *property_val;
24048 zend_property_info *prop_info;
24049
24050 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24051 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24052
24053assign_obj_simple:
24054 property_val = OBJ_PROP(zobj, prop_offset);
24055 if (Z_TYPE_P(property_val) != IS_UNDEF) {
24056 if (prop_info != NULL) {
24057 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24058 goto free_and_exit_assign_obj;
24059 } else {
24060fast_assign_obj:
24061 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24062 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24063 ZVAL_COPY(EX_VAR(opline->result.var), value);
24064 }
24065 goto exit_assign_obj;
24066 }
24067 }
24068 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24069 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24070 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24071 zobj = zend_lazy_object_init(zobj);
24072 if (!zobj) {
24073 value = &EG(uninitialized_zval);
24074 goto free_and_exit_assign_obj;
24075 }
24076 }
24077 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24078 rebuild_object_properties_internal(zobj);
24079 }
24080 if (EXPECTED(zobj->properties != NULL)) {
24081 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24082 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24083 GC_DELREF(zobj->properties);
24084 }
24085 zobj->properties = zend_array_dup(zobj->properties);
24086 }
24087 property_val = zend_hash_find_known_hash(zobj->properties, name);
24088 if (property_val) {
24089 goto fast_assign_obj;
24090 }
24091 }
24092
24093 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24094 if (IS_CONST == IS_CONST) {
24095 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24096 Z_ADDREF_P(value);
24097 }
24098 } else if (IS_CONST != IS_TMP_VAR) {
24099 if (Z_ISREF_P(value)) {
24100 if (IS_CONST == IS_VAR) {
24101 zend_reference *ref = Z_REF_P(value);
24102 if (GC_DELREF(ref) == 0) {
24103 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24104 efree_size(ref, sizeof(zend_reference));
24105 value = &tmp;
24106 } else {
24107 value = Z_REFVAL_P(value);
24108 Z_TRY_ADDREF_P(value);
24109 }
24110 } else {
24111 value = Z_REFVAL_P(value);
24112 Z_TRY_ADDREF_P(value);
24113 }
24114 } else if (IS_CONST == IS_CV) {
24115 Z_TRY_ADDREF_P(value);
24116 }
24117 }
24118 zend_hash_add_new(zobj->properties, name, value);
24119 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24120 ZVAL_COPY(EX_VAR(opline->result.var), value);
24121 }
24122 goto exit_assign_obj;
24123 }
24124 } else {
24125 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24126 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24127 prop_info = CACHED_PTR_EX(cache_slot + 2);
24128 prop_offset = prop_info->offset;
24129 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24130 prop_info = NULL;
24131 }
24132 goto assign_obj_simple;
24133 }
24134 /* Fall through to write_property for hooks. */
24135 }
24136 }
24137 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24138 } else {
24139 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24140 if (UNEXPECTED(!name)) {
24141
24142 UNDEF_RESULT();
24143 goto exit_assign_obj;
24144 }
24145 }
24146
24147 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24148 ZVAL_DEREF(value);
24149 }
24150
24151 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24152
24153 if (IS_CONST != IS_CONST) {
24154 zend_tmp_string_release(tmp_name);
24155 }
24156
24157free_and_exit_assign_obj:
24158 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24159 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24160 }
24161
24162exit_assign_obj:
24163 if (garbage) {
24164 GC_DTOR_NO_REF(garbage);
24165 }
24166
24167 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24168 /* assign_obj has two opcodes! */
24169 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24170}
24171
24172/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24173static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24174{
24175 USE_OPLINE
24176 zval *object, *value, tmp;
24177 zend_object *zobj;
24178 zend_string *name, *tmp_name;
24179 zend_refcounted *garbage = NULL;
24180
24181 SAVE_OPLINE();
24182 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24183 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24184
24185 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24186 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24187 object = Z_REFVAL_P(object);
24188 goto assign_object;
24189 }
24190 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24191 value = &EG(uninitialized_zval);
24192 goto free_and_exit_assign_obj;
24193 }
24194
24195assign_object:
24196 zobj = Z_OBJ_P(object);
24197 if (IS_CONST == IS_CONST) {
24198 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24199 void **cache_slot = CACHE_ADDR(opline->extended_value);
24200 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24201 zval *property_val;
24202 zend_property_info *prop_info;
24203
24204 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24205 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24206
24207assign_obj_simple:
24208 property_val = OBJ_PROP(zobj, prop_offset);
24209 if (Z_TYPE_P(property_val) != IS_UNDEF) {
24210 if (prop_info != NULL) {
24211 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24212 goto free_and_exit_assign_obj;
24213 } else {
24214fast_assign_obj:
24215 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
24216 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24217 ZVAL_COPY(EX_VAR(opline->result.var), value);
24218 }
24219 goto exit_assign_obj;
24220 }
24221 }
24222 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24223 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24224 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24225 zobj = zend_lazy_object_init(zobj);
24226 if (!zobj) {
24227 value = &EG(uninitialized_zval);
24228 goto free_and_exit_assign_obj;
24229 }
24230 }
24231 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24232 rebuild_object_properties_internal(zobj);
24233 }
24234 if (EXPECTED(zobj->properties != NULL)) {
24235 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24236 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24237 GC_DELREF(zobj->properties);
24238 }
24239 zobj->properties = zend_array_dup(zobj->properties);
24240 }
24241 property_val = zend_hash_find_known_hash(zobj->properties, name);
24242 if (property_val) {
24243 goto fast_assign_obj;
24244 }
24245 }
24246
24247 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24248 if (IS_TMP_VAR == IS_CONST) {
24249 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24250 Z_ADDREF_P(value);
24251 }
24252 } else if (IS_TMP_VAR != IS_TMP_VAR) {
24253 if (Z_ISREF_P(value)) {
24254 if (IS_TMP_VAR == IS_VAR) {
24255 zend_reference *ref = Z_REF_P(value);
24256 if (GC_DELREF(ref) == 0) {
24257 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24258 efree_size(ref, sizeof(zend_reference));
24259 value = &tmp;
24260 } else {
24261 value = Z_REFVAL_P(value);
24262 Z_TRY_ADDREF_P(value);
24263 }
24264 } else {
24265 value = Z_REFVAL_P(value);
24266 Z_TRY_ADDREF_P(value);
24267 }
24268 } else if (IS_TMP_VAR == IS_CV) {
24269 Z_TRY_ADDREF_P(value);
24270 }
24271 }
24272 zend_hash_add_new(zobj->properties, name, value);
24273 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24274 ZVAL_COPY(EX_VAR(opline->result.var), value);
24275 }
24276 goto exit_assign_obj;
24277 }
24278 } else {
24279 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24280 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24281 prop_info = CACHED_PTR_EX(cache_slot + 2);
24282 prop_offset = prop_info->offset;
24283 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24284 prop_info = NULL;
24285 }
24286 goto assign_obj_simple;
24287 }
24288 /* Fall through to write_property for hooks. */
24289 }
24290 }
24291 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24292 } else {
24293 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24294 if (UNEXPECTED(!name)) {
24295 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24296 UNDEF_RESULT();
24297 goto exit_assign_obj;
24298 }
24299 }
24300
24301 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
24302 ZVAL_DEREF(value);
24303 }
24304
24305 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24306
24307 if (IS_CONST != IS_CONST) {
24308 zend_tmp_string_release(tmp_name);
24309 }
24310
24311free_and_exit_assign_obj:
24312 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24313 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24314 }
24315 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24316exit_assign_obj:
24317 if (garbage) {
24318 GC_DTOR_NO_REF(garbage);
24319 }
24320
24321 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24322 /* assign_obj has two opcodes! */
24323 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24324}
24325
24326/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24327static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24328{
24329 USE_OPLINE
24330 zval *object, *value, tmp;
24331 zend_object *zobj;
24332 zend_string *name, *tmp_name;
24333 zend_refcounted *garbage = NULL;
24334
24335 SAVE_OPLINE();
24336 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24337 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24338
24339 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24340 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24341 object = Z_REFVAL_P(object);
24342 goto assign_object;
24343 }
24344 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24345 value = &EG(uninitialized_zval);
24346 goto free_and_exit_assign_obj;
24347 }
24348
24349assign_object:
24350 zobj = Z_OBJ_P(object);
24351 if (IS_CONST == IS_CONST) {
24352 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24353 void **cache_slot = CACHE_ADDR(opline->extended_value);
24354 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24355 zval *property_val;
24356 zend_property_info *prop_info;
24357
24358 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24359 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24360
24361assign_obj_simple:
24362 property_val = OBJ_PROP(zobj, prop_offset);
24363 if (Z_TYPE_P(property_val) != IS_UNDEF) {
24364 if (prop_info != NULL) {
24365 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24366 goto free_and_exit_assign_obj;
24367 } else {
24368fast_assign_obj:
24369 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
24370 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24371 ZVAL_COPY(EX_VAR(opline->result.var), value);
24372 }
24373 goto exit_assign_obj;
24374 }
24375 }
24376 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24377 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24378 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24379 zobj = zend_lazy_object_init(zobj);
24380 if (!zobj) {
24381 value = &EG(uninitialized_zval);
24382 goto free_and_exit_assign_obj;
24383 }
24384 }
24385 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24386 rebuild_object_properties_internal(zobj);
24387 }
24388 if (EXPECTED(zobj->properties != NULL)) {
24389 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24390 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24391 GC_DELREF(zobj->properties);
24392 }
24393 zobj->properties = zend_array_dup(zobj->properties);
24394 }
24395 property_val = zend_hash_find_known_hash(zobj->properties, name);
24396 if (property_val) {
24397 goto fast_assign_obj;
24398 }
24399 }
24400
24401 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24402 if (IS_VAR == IS_CONST) {
24403 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24404 Z_ADDREF_P(value);
24405 }
24406 } else if (IS_VAR != IS_TMP_VAR) {
24407 if (Z_ISREF_P(value)) {
24408 if (IS_VAR == IS_VAR) {
24409 zend_reference *ref = Z_REF_P(value);
24410 if (GC_DELREF(ref) == 0) {
24411 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24412 efree_size(ref, sizeof(zend_reference));
24413 value = &tmp;
24414 } else {
24415 value = Z_REFVAL_P(value);
24416 Z_TRY_ADDREF_P(value);
24417 }
24418 } else {
24419 value = Z_REFVAL_P(value);
24420 Z_TRY_ADDREF_P(value);
24421 }
24422 } else if (IS_VAR == IS_CV) {
24423 Z_TRY_ADDREF_P(value);
24424 }
24425 }
24426 zend_hash_add_new(zobj->properties, name, value);
24427 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24428 ZVAL_COPY(EX_VAR(opline->result.var), value);
24429 }
24430 goto exit_assign_obj;
24431 }
24432 } else {
24433 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24434 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24435 prop_info = CACHED_PTR_EX(cache_slot + 2);
24436 prop_offset = prop_info->offset;
24437 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24438 prop_info = NULL;
24439 }
24440 goto assign_obj_simple;
24441 }
24442 /* Fall through to write_property for hooks. */
24443 }
24444 }
24445 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24446 } else {
24447 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24448 if (UNEXPECTED(!name)) {
24449 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24450 UNDEF_RESULT();
24451 goto exit_assign_obj;
24452 }
24453 }
24454
24455 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
24456 ZVAL_DEREF(value);
24457 }
24458
24459 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24460
24461 if (IS_CONST != IS_CONST) {
24462 zend_tmp_string_release(tmp_name);
24463 }
24464
24465free_and_exit_assign_obj:
24466 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24467 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24468 }
24469 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24470exit_assign_obj:
24471 if (garbage) {
24472 GC_DTOR_NO_REF(garbage);
24473 }
24474
24475 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24476 /* assign_obj has two opcodes! */
24477 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24478}
24479
24480/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24481static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24482{
24483 USE_OPLINE
24484 zval *object, *value, tmp;
24485 zend_object *zobj;
24486 zend_string *name, *tmp_name;
24487 zend_refcounted *garbage = NULL;
24488
24489 SAVE_OPLINE();
24490 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24491 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
24492
24493 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24494 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24495 object = Z_REFVAL_P(object);
24496 goto assign_object;
24497 }
24498 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24499 value = &EG(uninitialized_zval);
24500 goto free_and_exit_assign_obj;
24501 }
24502
24503assign_object:
24504 zobj = Z_OBJ_P(object);
24505 if (IS_CONST == IS_CONST) {
24506 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24507 void **cache_slot = CACHE_ADDR(opline->extended_value);
24508 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24509 zval *property_val;
24510 zend_property_info *prop_info;
24511
24512 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24513 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24514
24515assign_obj_simple:
24516 property_val = OBJ_PROP(zobj, prop_offset);
24517 if (Z_TYPE_P(property_val) != IS_UNDEF) {
24518 if (prop_info != NULL) {
24519 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24520 goto free_and_exit_assign_obj;
24521 } else {
24522fast_assign_obj:
24523 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
24524 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24525 ZVAL_COPY(EX_VAR(opline->result.var), value);
24526 }
24527 goto exit_assign_obj;
24528 }
24529 }
24530 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24531 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24532 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24533 zobj = zend_lazy_object_init(zobj);
24534 if (!zobj) {
24535 value = &EG(uninitialized_zval);
24536 goto free_and_exit_assign_obj;
24537 }
24538 }
24539 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24540 rebuild_object_properties_internal(zobj);
24541 }
24542 if (EXPECTED(zobj->properties != NULL)) {
24543 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24544 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24545 GC_DELREF(zobj->properties);
24546 }
24547 zobj->properties = zend_array_dup(zobj->properties);
24548 }
24549 property_val = zend_hash_find_known_hash(zobj->properties, name);
24550 if (property_val) {
24551 goto fast_assign_obj;
24552 }
24553 }
24554
24555 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24556 if (IS_CV == IS_CONST) {
24557 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24558 Z_ADDREF_P(value);
24559 }
24560 } else if (IS_CV != IS_TMP_VAR) {
24561 if (Z_ISREF_P(value)) {
24562 if (IS_CV == IS_VAR) {
24563 zend_reference *ref = Z_REF_P(value);
24564 if (GC_DELREF(ref) == 0) {
24565 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24566 efree_size(ref, sizeof(zend_reference));
24567 value = &tmp;
24568 } else {
24569 value = Z_REFVAL_P(value);
24570 Z_TRY_ADDREF_P(value);
24571 }
24572 } else {
24573 value = Z_REFVAL_P(value);
24574 Z_TRY_ADDREF_P(value);
24575 }
24576 } else if (IS_CV == IS_CV) {
24577 Z_TRY_ADDREF_P(value);
24578 }
24579 }
24580 zend_hash_add_new(zobj->properties, name, value);
24581 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24582 ZVAL_COPY(EX_VAR(opline->result.var), value);
24583 }
24584 goto exit_assign_obj;
24585 }
24586 } else {
24587 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24588 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24589 prop_info = CACHED_PTR_EX(cache_slot + 2);
24590 prop_offset = prop_info->offset;
24591 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
24592 prop_info = NULL;
24593 }
24594 goto assign_obj_simple;
24595 }
24596 /* Fall through to write_property for hooks. */
24597 }
24598 }
24599 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24600 } else {
24601 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24602 if (UNEXPECTED(!name)) {
24603
24604 UNDEF_RESULT();
24605 goto exit_assign_obj;
24606 }
24607 }
24608
24609 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24610 ZVAL_DEREF(value);
24611 }
24612
24613 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24614
24615 if (IS_CONST != IS_CONST) {
24616 zend_tmp_string_release(tmp_name);
24617 }
24618
24619free_and_exit_assign_obj:
24620 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24621 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24622 }
24623
24624exit_assign_obj:
24625 if (garbage) {
24626 GC_DTOR_NO_REF(garbage);
24627 }
24628
24629 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24630 /* assign_obj has two opcodes! */
24631 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24632}
24633
24634/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
24635static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24636{
24637 USE_OPLINE
24638 zval *object_ptr, *orig_object_ptr;
24639 zval *value;
24640 zval *variable_ptr;
24641 zval *dim;
24642 zend_refcounted *garbage = NULL;
24643
24644 SAVE_OPLINE();
24645 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24646
24647 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24648try_assign_dim_array:
24649 SEPARATE_ARRAY(object_ptr);
24650 if (IS_CONST == IS_UNUSED) {
24651 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24652 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24653 HashTable *ht = Z_ARRVAL_P(object_ptr);
24654 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24655 GC_ADDREF(ht);
24656 }
24657 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24658 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24659 zend_array_destroy(ht);
24660 goto assign_dim_error;
24661 }
24662 }
24663 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24664 ZVAL_DEREF(value);
24665 }
24666 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24667 if (UNEXPECTED(value == NULL)) {
24668 zend_cannot_add_element();
24669 goto assign_dim_error;
24670 } else if (IS_CONST == IS_CV) {
24671 if (Z_REFCOUNTED_P(value)) {
24672 Z_ADDREF_P(value);
24673 }
24674 } else if (IS_CONST == IS_VAR) {
24675 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24676 if (Z_ISREF_P(free_op_data)) {
24677 if (Z_REFCOUNTED_P(value)) {
24678 Z_ADDREF_P(value);
24679 }
24680 zval_ptr_dtor_nogc(free_op_data);
24681 }
24682 } else if (IS_CONST == IS_CONST) {
24683 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24684 Z_ADDREF_P(value);
24685 }
24686 }
24687 } else {
24688 dim = RT_CONSTANT(opline, opline->op2);
24689 if (IS_CONST == IS_CONST) {
24690 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24691 } else {
24692 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24693 }
24694 if (UNEXPECTED(variable_ptr == NULL)) {
24695 goto assign_dim_error;
24696 }
24697 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24698 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24699 }
24700 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24701 ZVAL_COPY(EX_VAR(opline->result.var), value);
24702 }
24703 if (garbage) {
24704 GC_DTOR_NO_REF(garbage);
24705 }
24706 } else {
24707 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24708 object_ptr = Z_REFVAL_P(object_ptr);
24709 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24710 goto try_assign_dim_array;
24711 }
24712 }
24713 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24714 zend_object *obj = Z_OBJ_P(object_ptr);
24715
24716 GC_ADDREF(obj);
24717 dim = RT_CONSTANT(opline, opline->op2);
24718 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24719 dim = ZVAL_UNDEFINED_OP2();
24720 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24721 dim++;
24722 }
24723
24724 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24725 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24726 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24727 } else if (IS_CONST & (IS_CV|IS_VAR)) {
24728 ZVAL_DEREF(value);
24729 }
24730
24731 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24732
24733 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24734 zend_objects_store_del(obj);
24735 }
24736 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24737 if (IS_CONST == IS_UNUSED) {
24738 zend_use_new_element_for_string();
24739
24740 UNDEF_RESULT();
24741 } else {
24742 dim = RT_CONSTANT(opline, opline->op2);
24743 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24744 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24745
24746 }
24747 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24748 if (Z_ISREF_P(orig_object_ptr)
24749 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24750 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24751 dim = RT_CONSTANT(opline, opline->op2);
24752
24753 UNDEF_RESULT();
24754 } else {
24755 HashTable *ht = zend_new_array(8);
24756 uint8_t old_type = Z_TYPE_P(object_ptr);
24757
24758 ZVAL_ARR(object_ptr, ht);
24759 if (UNEXPECTED(old_type == IS_FALSE)) {
24760 GC_ADDREF(ht);
24761 zend_false_to_array_deprecated();
24762 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24763 zend_array_destroy(ht);
24764 goto assign_dim_error;
24765 }
24766 }
24767 goto try_assign_dim_array;
24768 }
24769 } else {
24770 zend_use_scalar_as_array();
24771 dim = RT_CONSTANT(opline, opline->op2);
24772assign_dim_error:
24773
24774 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24775 ZVAL_NULL(EX_VAR(opline->result.var));
24776 }
24777 }
24778 }
24779 if (IS_CONST != IS_UNUSED) {
24780
24781 }
24782 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24783 /* assign_dim has two opcodes! */
24784 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24785}
24786
24787static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24788{
24789 USE_OPLINE
24790 zval *object_ptr, *orig_object_ptr;
24791 zval *value;
24792 zval *variable_ptr;
24793 zval *dim;
24794 zend_refcounted *garbage = NULL;
24795
24796 SAVE_OPLINE();
24797 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24798
24799 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24800try_assign_dim_array:
24801 SEPARATE_ARRAY(object_ptr);
24802 if (IS_CONST == IS_UNUSED) {
24803 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24804 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24805 HashTable *ht = Z_ARRVAL_P(object_ptr);
24806 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24807 GC_ADDREF(ht);
24808 }
24809 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24810 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24811 zend_array_destroy(ht);
24812 goto assign_dim_error;
24813 }
24814 }
24815 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
24816 ZVAL_DEREF(value);
24817 }
24818 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24819 if (UNEXPECTED(value == NULL)) {
24820 zend_cannot_add_element();
24821 goto assign_dim_error;
24822 } else if (IS_TMP_VAR == IS_CV) {
24823 if (Z_REFCOUNTED_P(value)) {
24824 Z_ADDREF_P(value);
24825 }
24826 } else if (IS_TMP_VAR == IS_VAR) {
24827 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24828 if (Z_ISREF_P(free_op_data)) {
24829 if (Z_REFCOUNTED_P(value)) {
24830 Z_ADDREF_P(value);
24831 }
24832 zval_ptr_dtor_nogc(free_op_data);
24833 }
24834 } else if (IS_TMP_VAR == IS_CONST) {
24835 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24836 Z_ADDREF_P(value);
24837 }
24838 }
24839 } else {
24840 dim = RT_CONSTANT(opline, opline->op2);
24841 if (IS_CONST == IS_CONST) {
24842 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24843 } else {
24844 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24845 }
24846 if (UNEXPECTED(variable_ptr == NULL)) {
24847 goto assign_dim_error;
24848 }
24849 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24850 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
24851 }
24852 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24853 ZVAL_COPY(EX_VAR(opline->result.var), value);
24854 }
24855 if (garbage) {
24856 GC_DTOR_NO_REF(garbage);
24857 }
24858 } else {
24859 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24860 object_ptr = Z_REFVAL_P(object_ptr);
24861 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24862 goto try_assign_dim_array;
24863 }
24864 }
24865 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24866 zend_object *obj = Z_OBJ_P(object_ptr);
24867
24868 GC_ADDREF(obj);
24869 dim = RT_CONSTANT(opline, opline->op2);
24870 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24871 dim = ZVAL_UNDEFINED_OP2();
24872 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24873 dim++;
24874 }
24875
24876 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24877 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24878 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24879 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
24880 ZVAL_DEREF(value);
24881 }
24882
24883 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24884
24885 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24886 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24887 zend_objects_store_del(obj);
24888 }
24889 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24890 if (IS_CONST == IS_UNUSED) {
24891 zend_use_new_element_for_string();
24892 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24893 UNDEF_RESULT();
24894 } else {
24895 dim = RT_CONSTANT(opline, opline->op2);
24896 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24897 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24898 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24899 }
24900 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24901 if (Z_ISREF_P(orig_object_ptr)
24902 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24903 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24904 dim = RT_CONSTANT(opline, opline->op2);
24905 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24906 UNDEF_RESULT();
24907 } else {
24908 HashTable *ht = zend_new_array(8);
24909 uint8_t old_type = Z_TYPE_P(object_ptr);
24910
24911 ZVAL_ARR(object_ptr, ht);
24912 if (UNEXPECTED(old_type == IS_FALSE)) {
24913 GC_ADDREF(ht);
24914 zend_false_to_array_deprecated();
24915 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24916 zend_array_destroy(ht);
24917 goto assign_dim_error;
24918 }
24919 }
24920 goto try_assign_dim_array;
24921 }
24922 } else {
24923 zend_use_scalar_as_array();
24924 dim = RT_CONSTANT(opline, opline->op2);
24925assign_dim_error:
24926 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24927 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24928 ZVAL_NULL(EX_VAR(opline->result.var));
24929 }
24930 }
24931 }
24932 if (IS_CONST != IS_UNUSED) {
24933
24934 }
24935 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24936 /* assign_dim has two opcodes! */
24937 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24938}
24939
24940static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24941{
24942 USE_OPLINE
24943 zval *object_ptr, *orig_object_ptr;
24944 zval *value;
24945 zval *variable_ptr;
24946 zval *dim;
24947 zend_refcounted *garbage = NULL;
24948
24949 SAVE_OPLINE();
24950 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24951
24952 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24953try_assign_dim_array:
24954 SEPARATE_ARRAY(object_ptr);
24955 if (IS_CONST == IS_UNUSED) {
24956 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24957 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24958 HashTable *ht = Z_ARRVAL_P(object_ptr);
24959 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24960 GC_ADDREF(ht);
24961 }
24962 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24963 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24964 zend_array_destroy(ht);
24965 goto assign_dim_error;
24966 }
24967 }
24968 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
24969 ZVAL_DEREF(value);
24970 }
24971 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24972 if (UNEXPECTED(value == NULL)) {
24973 zend_cannot_add_element();
24974 goto assign_dim_error;
24975 } else if (IS_VAR == IS_CV) {
24976 if (Z_REFCOUNTED_P(value)) {
24977 Z_ADDREF_P(value);
24978 }
24979 } else if (IS_VAR == IS_VAR) {
24980 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24981 if (Z_ISREF_P(free_op_data)) {
24982 if (Z_REFCOUNTED_P(value)) {
24983 Z_ADDREF_P(value);
24984 }
24985 zval_ptr_dtor_nogc(free_op_data);
24986 }
24987 } else if (IS_VAR == IS_CONST) {
24988 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24989 Z_ADDREF_P(value);
24990 }
24991 }
24992 } else {
24993 dim = RT_CONSTANT(opline, opline->op2);
24994 if (IS_CONST == IS_CONST) {
24995 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24996 } else {
24997 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24998 }
24999 if (UNEXPECTED(variable_ptr == NULL)) {
25000 goto assign_dim_error;
25001 }
25002 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25003 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
25004 }
25005 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25006 ZVAL_COPY(EX_VAR(opline->result.var), value);
25007 }
25008 if (garbage) {
25009 GC_DTOR_NO_REF(garbage);
25010 }
25011 } else {
25012 if (EXPECTED(Z_ISREF_P(object_ptr))) {
25013 object_ptr = Z_REFVAL_P(object_ptr);
25014 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25015 goto try_assign_dim_array;
25016 }
25017 }
25018 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
25019 zend_object *obj = Z_OBJ_P(object_ptr);
25020
25021 GC_ADDREF(obj);
25022 dim = RT_CONSTANT(opline, opline->op2);
25023 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
25024 dim = ZVAL_UNDEFINED_OP2();
25025 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
25026 dim++;
25027 }
25028
25029 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25030 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
25031 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25032 } else if (IS_VAR & (IS_CV|IS_VAR)) {
25033 ZVAL_DEREF(value);
25034 }
25035
25036 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
25037
25038 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25039 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
25040 zend_objects_store_del(obj);
25041 }
25042 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
25043 if (IS_CONST == IS_UNUSED) {
25044 zend_use_new_element_for_string();
25045 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25046 UNDEF_RESULT();
25047 } else {
25048 dim = RT_CONSTANT(opline, opline->op2);
25049 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25050 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
25051 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25052 }
25053 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
25054 if (Z_ISREF_P(orig_object_ptr)
25055 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
25056 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
25057 dim = RT_CONSTANT(opline, opline->op2);
25058 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25059 UNDEF_RESULT();
25060 } else {
25061 HashTable *ht = zend_new_array(8);
25062 uint8_t old_type = Z_TYPE_P(object_ptr);
25063
25064 ZVAL_ARR(object_ptr, ht);
25065 if (UNEXPECTED(old_type == IS_FALSE)) {
25066 GC_ADDREF(ht);
25067 zend_false_to_array_deprecated();
25068 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
25069 zend_array_destroy(ht);
25070 goto assign_dim_error;
25071 }
25072 }
25073 goto try_assign_dim_array;
25074 }
25075 } else {
25076 zend_use_scalar_as_array();
25077 dim = RT_CONSTANT(opline, opline->op2);
25078assign_dim_error:
25079 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25080 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25081 ZVAL_NULL(EX_VAR(opline->result.var));
25082 }
25083 }
25084 }
25085 if (IS_CONST != IS_UNUSED) {
25086
25087 }
25088 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25089 /* assign_dim has two opcodes! */
25090 ZEND_VM_NEXT_OPCODE_EX(1, 2);
25091}
25092
25093static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25094{
25095 USE_OPLINE
25096 zval *object_ptr, *orig_object_ptr;
25097 zval *value;
25098 zval *variable_ptr;
25099 zval *dim;
25100 zend_refcounted *garbage = NULL;
25101
25102 SAVE_OPLINE();
25103 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25104
25105 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25106try_assign_dim_array:
25107 SEPARATE_ARRAY(object_ptr);
25108 if (IS_CONST == IS_UNUSED) {
25109 value = EX_VAR((opline+1)->op1.var);
25110 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
25111 HashTable *ht = Z_ARRVAL_P(object_ptr);
25112 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
25113 GC_ADDREF(ht);
25114 }
25115 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25116 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
25117 zend_array_destroy(ht);
25118 goto assign_dim_error;
25119 }
25120 }
25121 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
25122 ZVAL_DEREF(value);
25123 }
25124 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
25125 if (UNEXPECTED(value == NULL)) {
25126 zend_cannot_add_element();
25127 goto assign_dim_error;
25128 } else if (IS_CV == IS_CV) {
25129 if (Z_REFCOUNTED_P(value)) {
25130 Z_ADDREF_P(value);
25131 }
25132 } else if (IS_CV == IS_VAR) {
25133 zval *free_op_data = EX_VAR((opline+1)->op1.var);
25134 if (Z_ISREF_P(free_op_data)) {
25135 if (Z_REFCOUNTED_P(value)) {
25136 Z_ADDREF_P(value);
25137 }
25138 zval_ptr_dtor_nogc(free_op_data);
25139 }
25140 } else if (IS_CV == IS_CONST) {
25141 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
25142 Z_ADDREF_P(value);
25143 }
25144 }
25145 } else {
25146 dim = RT_CONSTANT(opline, opline->op2);
25147 if (IS_CONST == IS_CONST) {
25148 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25149 } else {
25150 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25151 }
25152 if (UNEXPECTED(variable_ptr == NULL)) {
25153 goto assign_dim_error;
25154 }
25155 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
25156 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
25157 }
25158 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25159 ZVAL_COPY(EX_VAR(opline->result.var), value);
25160 }
25161 if (garbage) {
25162 GC_DTOR_NO_REF(garbage);
25163 }
25164 } else {
25165 if (EXPECTED(Z_ISREF_P(object_ptr))) {
25166 object_ptr = Z_REFVAL_P(object_ptr);
25167 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25168 goto try_assign_dim_array;
25169 }
25170 }
25171 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
25172 zend_object *obj = Z_OBJ_P(object_ptr);
25173
25174 GC_ADDREF(obj);
25175 dim = RT_CONSTANT(opline, opline->op2);
25176 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
25177 dim = ZVAL_UNDEFINED_OP2();
25178 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
25179 dim++;
25180 }
25181
25182 value = EX_VAR((opline+1)->op1.var);
25183 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
25184 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25185 } else if (IS_CV & (IS_CV|IS_VAR)) {
25186 ZVAL_DEREF(value);
25187 }
25188
25189 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
25190
25191 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
25192 zend_objects_store_del(obj);
25193 }
25194 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
25195 if (IS_CONST == IS_UNUSED) {
25196 zend_use_new_element_for_string();
25197
25198 UNDEF_RESULT();
25199 } else {
25200 dim = RT_CONSTANT(opline, opline->op2);
25201 value = EX_VAR((opline+1)->op1.var);
25202 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
25203
25204 }
25205 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
25206 if (Z_ISREF_P(orig_object_ptr)
25207 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
25208 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
25209 dim = RT_CONSTANT(opline, opline->op2);
25210
25211 UNDEF_RESULT();
25212 } else {
25213 HashTable *ht = zend_new_array(8);
25214 uint8_t old_type = Z_TYPE_P(object_ptr);
25215
25216 ZVAL_ARR(object_ptr, ht);
25217 if (UNEXPECTED(old_type == IS_FALSE)) {
25218 GC_ADDREF(ht);
25219 zend_false_to_array_deprecated();
25220 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
25221 zend_array_destroy(ht);
25222 goto assign_dim_error;
25223 }
25224 }
25225 goto try_assign_dim_array;
25226 }
25227 } else {
25228 zend_use_scalar_as_array();
25229 dim = RT_CONSTANT(opline, opline->op2);
25230assign_dim_error:
25231
25232 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25233 ZVAL_NULL(EX_VAR(opline->result.var));
25234 }
25235 }
25236 }
25237 if (IS_CONST != IS_UNUSED) {
25238
25239 }
25240 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25241 /* assign_dim has two opcodes! */
25242 ZEND_VM_NEXT_OPCODE_EX(1, 2);
25243}
25244
25245static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25246{
25247 USE_OPLINE
25248 zval *value;
25249 zval *variable_ptr;
25250
25251 SAVE_OPLINE();
25252 value = RT_CONSTANT(opline, opline->op2);
25253 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25254
25255 if (0 || UNEXPECTED(0)) {
25256 zend_refcounted *garbage = NULL;
25257
25258 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
25259 if (UNEXPECTED(0)) {
25260 ZVAL_COPY(EX_VAR(opline->result.var), value);
25261 }
25262 if (garbage) {
25263 GC_DTOR_NO_REF(garbage);
25264 }
25265 } else {
25266 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
25267 }
25268 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25269 /* zend_assign_to_variable() always takes care of op2, never free it! */
25270
25271 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25272}
25273
25274static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25275{
25276 USE_OPLINE
25277 zval *value;
25278 zval *variable_ptr;
25279
25280 SAVE_OPLINE();
25281 value = RT_CONSTANT(opline, opline->op2);
25282 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25283
25284 if (0 || UNEXPECTED(1)) {
25285 zend_refcounted *garbage = NULL;
25286
25287 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
25288 if (UNEXPECTED(1)) {
25289 ZVAL_COPY(EX_VAR(opline->result.var), value);
25290 }
25291 if (garbage) {
25292 GC_DTOR_NO_REF(garbage);
25293 }
25294 } else {
25295 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
25296 }
25297 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25298 /* zend_assign_to_variable() always takes care of op2, never free it! */
25299
25300 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25301}
25302
25303static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25304{
25305 USE_OPLINE
25306 zval *property, *container, *value_ptr;
25307
25308 SAVE_OPLINE();
25309
25310 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25311 property = RT_CONSTANT(opline, opline->op2);
25312
25313 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25314
25315 if (1) {
25316 if (IS_VAR == IS_UNUSED) {
25317 if (IS_CONST == IS_CONST) {
25318 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25319 } else {
25320 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25321 }
25322 } else {
25323 if (IS_CONST == IS_CONST) {
25324 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25325 } else {
25326 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25327 }
25328 }
25329 } else {
25330 zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25331 }
25332
25333 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25334
25335 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25336 ZEND_VM_NEXT_OPCODE_EX(1, 2);
25337}
25338
25339/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
25340static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25341{
25342 USE_OPLINE
25343 zval *property, *container, *value_ptr;
25344
25345 SAVE_OPLINE();
25346
25347 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25348 property = RT_CONSTANT(opline, opline->op2);
25349
25350 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
25351
25352 if (1) {
25353 if (IS_VAR == IS_UNUSED) {
25354 if (IS_CONST == IS_CONST) {
25355 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25356 } else {
25357 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25358 }
25359 } else {
25360 if (IS_CONST == IS_CONST) {
25361 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25362 } else {
25363 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25364 }
25365 }
25366 } else {
25367 zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25368 }
25369
25370 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25371
25372
25373 ZEND_VM_NEXT_OPCODE_EX(1, 2);
25374}
25375
25376/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
25377static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25378{
25379 USE_OPLINE
25380 zval *function_name;
25381 zend_class_entry *ce;
25382 uint32_t call_info;
25383 zend_function *fbc;
25384 zend_execute_data *call;
25385
25386 SAVE_OPLINE();
25387
25388 if (IS_VAR == IS_CONST) {
25389 /* no function found. try a static method in class */
25390 ce = CACHED_PTR(opline->result.num);
25391 if (UNEXPECTED(ce == NULL)) {
25392 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);
25393 if (UNEXPECTED(ce == NULL)) {
25394
25395 HANDLE_EXCEPTION();
25396 }
25397 if (IS_CONST != IS_CONST) {
25398 CACHE_PTR(opline->result.num, ce);
25399 }
25400 }
25401 } else if (IS_VAR == IS_UNUSED) {
25402 ce = zend_fetch_class(NULL, opline->op1.num);
25403 if (UNEXPECTED(ce == NULL)) {
25404
25405 HANDLE_EXCEPTION();
25406 }
25407 } else {
25408 ce = Z_CE_P(EX_VAR(opline->op1.var));
25409 }
25410
25411 if (IS_VAR == IS_CONST &&
25412 IS_CONST == IS_CONST &&
25413 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
25414 /* nothing to do */
25415 } else if (IS_VAR != IS_CONST &&
25416 IS_CONST == IS_CONST &&
25417 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
25418 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
25419 } else if (IS_CONST != IS_UNUSED) {
25420 function_name = RT_CONSTANT(opline, opline->op2);
25421 if (IS_CONST != IS_CONST) {
25422 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
25423 do {
25424 if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
25425 function_name = Z_REFVAL_P(function_name);
25426 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
25427 break;
25428 }
25429 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
25430 ZVAL_UNDEFINED_OP2();
25431 if (UNEXPECTED(EG(exception) != NULL)) {
25432 HANDLE_EXCEPTION();
25433 }
25434 }
25435 zend_throw_error(NULL, "Method name must be a string");
25436
25437 HANDLE_EXCEPTION();
25438 } while (0);
25439 }
25440 }
25441
25442 if (ce->get_static_method) {
25443 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
25444 } else {
25445 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
25446 }
25447 if (UNEXPECTED(fbc == NULL)) {
25448 if (EXPECTED(!EG(exception))) {
25449 zend_undefined_method(ce, Z_STR_P(function_name));
25450 }
25451
25452 HANDLE_EXCEPTION();
25453 }
25454 if (IS_CONST == IS_CONST &&
25455 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
25456 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
25457 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
25458 }
25459 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
25460 init_func_run_time_cache(&fbc->op_array);
25461 }
25462 if (IS_CONST != IS_CONST) {
25463
25464 }
25465 } else {
25466 if (UNEXPECTED(ce->constructor == NULL)) {
25467 zend_throw_error(NULL, "Cannot call constructor");
25468 HANDLE_EXCEPTION();
25469 }
25470 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
25471 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
25472 HANDLE_EXCEPTION();
25473 }
25474 fbc = ce->constructor;
25475 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
25476 init_func_run_time_cache(&fbc->op_array);
25477 }
25478 }
25479
25480 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
25481 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
25482 ce = (zend_class_entry*)Z_OBJ(EX(This));
25483 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
25484 } else {
25485 zend_non_static_method_call(fbc);
25486 HANDLE_EXCEPTION();
25487 }
25488 } else {
25489 /* previous opcode is ZEND_FETCH_CLASS */
25490 if (IS_VAR == IS_UNUSED
25491 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
25492 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
25493 if (Z_TYPE(EX(This)) == IS_OBJECT) {
25494 ce = Z_OBJCE(EX(This));
25495 } else {
25496 ce = Z_CE(EX(This));
25497 }
25498 }
25499 call_info = ZEND_CALL_NESTED_FUNCTION;
25500 }
25501
25502 call = zend_vm_stack_push_call_frame(call_info,
25503 fbc, opline->extended_value, ce);
25504 call->prev_execute_data = EX(call);
25505 EX(call) = call;
25506
25507 ZEND_VM_NEXT_OPCODE();
25508}
25509
25510static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25511{
25512 USE_OPLINE
25513 zval *varptr, *arg;
25514
25515 if (IS_CONST == IS_CONST) {
25516 SAVE_OPLINE();
25517 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25518 uint32_t arg_num;
25519 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25520 if (UNEXPECTED(!arg)) {
25521 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25522 HANDLE_EXCEPTION();
25523 }
25524 } else {
25525 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25526 }
25527
25528 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25529 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
25530 SAVE_OPLINE();
25531 ZVAL_UNDEFINED_OP1();
25532 ZVAL_NULL(arg);
25533 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25534 }
25535
25536 if (IS_VAR == IS_CV) {
25537 ZVAL_COPY_DEREF(arg, varptr);
25538 } else /* if (IS_VAR == IS_VAR) */ {
25539 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25540 zend_refcounted *ref = Z_COUNTED_P(varptr);
25541
25542 varptr = Z_REFVAL_P(varptr);
25543 ZVAL_COPY_VALUE(arg, varptr);
25544 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25545 efree_size(ref, sizeof(zend_reference));
25546 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25547 Z_ADDREF_P(arg);
25548 }
25549 } else {
25550 ZVAL_COPY_VALUE(arg, varptr);
25551 }
25552 }
25553
25554 ZEND_VM_NEXT_OPCODE();
25555}
25556
25557static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25558{
25559 USE_OPLINE
25560 zval *varptr, *arg;
25561
25562 if (IS_CONST == IS_CONST) {
25563 SAVE_OPLINE();
25564 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25565 uint32_t arg_num;
25566 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25567 if (UNEXPECTED(!arg)) {
25568 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25569 HANDLE_EXCEPTION();
25570 }
25571 } else {
25572 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25573 }
25574
25575 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25576 ZVAL_COPY_VALUE(arg, varptr);
25577
25578 if (EXPECTED(Z_ISREF_P(varptr))) {
25579 ZEND_VM_NEXT_OPCODE();
25580 }
25581
25582 SAVE_OPLINE();
25583 ZVAL_NEW_REF(arg, arg);
25584 zend_error(E_NOTICE, "Only variables should be passed by reference");
25585 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25586}
25587
25588static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25589{
25590 USE_OPLINE
25591 zval *varptr, *arg;
25592 uint32_t arg_num;
25593
25594 if (IS_CONST == IS_CONST) {
25595 SAVE_OPLINE();
25596 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25597 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25598 if (UNEXPECTED(!arg)) {
25599 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25600 HANDLE_EXCEPTION();
25601 }
25602 } else {
25603 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25604 arg_num = opline->op2.num;
25605 }
25606
25607 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
25608 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25609 goto send_var;
25610 }
25611
25612 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25613 ZVAL_COPY_VALUE(arg, varptr);
25614
25615 if (EXPECTED(Z_ISREF_P(varptr) ||
25616 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
25617 ZEND_VM_NEXT_OPCODE();
25618 }
25619 } else {
25620 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25621 goto send_var;
25622 }
25623
25624 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25625 ZVAL_COPY_VALUE(arg, varptr);
25626
25627 if (EXPECTED(Z_ISREF_P(varptr) ||
25628 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
25629 ZEND_VM_NEXT_OPCODE();
25630 }
25631 }
25632
25633 SAVE_OPLINE();
25634 ZVAL_NEW_REF(arg, arg);
25635 zend_error(E_NOTICE, "Only variables should be passed by reference");
25636 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25637
25638send_var:
25639 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25640 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25641 zend_refcounted *ref = Z_COUNTED_P(varptr);
25642
25643 varptr = Z_REFVAL_P(varptr);
25644 ZVAL_COPY_VALUE(arg, varptr);
25645 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25646 efree_size(ref, sizeof(zend_reference));
25647 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25648 Z_ADDREF_P(arg);
25649 }
25650 } else {
25651 ZVAL_COPY_VALUE(arg, varptr);
25652 }
25653 ZEND_VM_NEXT_OPCODE();
25654}
25655
25656static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25657{
25658 USE_OPLINE
25659 zval *varptr, *arg;
25660
25661 SAVE_OPLINE();
25662 if (IS_CONST == IS_CONST) {
25663 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25664 uint32_t arg_num;
25665 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25666 if (UNEXPECTED(!arg)) {
25667 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25668 HANDLE_EXCEPTION();
25669 }
25670 } else {
25671 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25672 }
25673
25674 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25675 if (Z_ISREF_P(varptr)) {
25676 Z_ADDREF_P(varptr);
25677 } else {
25678 ZVAL_MAKE_REF_EX(varptr, 2);
25679 }
25680 ZVAL_REF(arg, Z_REF_P(varptr));
25681
25682 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25683 ZEND_VM_NEXT_OPCODE();
25684}
25685
25686static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25687{
25688 USE_OPLINE
25689 zval *varptr, *arg;
25690 uint32_t arg_num;
25691
25692 if (IS_CONST == IS_CONST) {
25693 SAVE_OPLINE();
25694 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25695 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25696 if (UNEXPECTED(!arg)) {
25697 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25698 HANDLE_EXCEPTION();
25699 }
25700 } else {
25701 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25702 arg_num = opline->op2.num;
25703 }
25704
25705 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
25706 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25707 goto send_var_by_ref;
25708 }
25709 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25710send_var_by_ref:
25711 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25712 if (Z_ISREF_P(varptr)) {
25713 Z_ADDREF_P(varptr);
25714 } else {
25715 ZVAL_MAKE_REF_EX(varptr, 2);
25716 }
25717 ZVAL_REF(arg, Z_REF_P(varptr));
25718
25719 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25720 ZEND_VM_NEXT_OPCODE();
25721 }
25722
25723 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25724 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
25725 SAVE_OPLINE();
25726 ZVAL_UNDEFINED_OP1();
25727 ZVAL_NULL(arg);
25728 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25729 }
25730
25731 if (IS_VAR == IS_CV) {
25732 ZVAL_COPY_DEREF(arg, varptr);
25733 } else /* if (IS_VAR == IS_VAR) */ {
25734 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25735 zend_refcounted *ref = Z_COUNTED_P(varptr);
25736
25737 varptr = Z_REFVAL_P(varptr);
25738 ZVAL_COPY_VALUE(arg, varptr);
25739 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25740 efree_size(ref, sizeof(zend_reference));
25741 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25742 Z_ADDREF_P(arg);
25743 }
25744 } else {
25745 ZVAL_COPY_VALUE(arg, varptr);
25746 }
25747 }
25748
25749 ZEND_VM_NEXT_OPCODE();
25750}
25751
25752static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25753{
25754 USE_OPLINE
25755 zval *varptr, *arg;
25756
25757 if (IS_CONST == IS_CONST) {
25758 // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
25759 SAVE_OPLINE();
25760 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25761 uint32_t arg_num;
25762 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25763 if (UNEXPECTED(!arg)) {
25764 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25765 HANDLE_EXCEPTION();
25766 }
25767 } else {
25768 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25769 }
25770
25771 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
25772 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25773 if (Z_ISREF_P(varptr)) {
25774 Z_ADDREF_P(varptr);
25775 } else {
25776 ZVAL_MAKE_REF_EX(varptr, 2);
25777 }
25778 ZVAL_REF(arg, Z_REF_P(varptr));
25779
25780 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25781 ZEND_VM_NEXT_OPCODE();
25782 }
25783
25784 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25785
25786 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25787 zend_refcounted *ref = Z_COUNTED_P(varptr);
25788
25789 varptr = Z_REFVAL_P(varptr);
25790 ZVAL_COPY_VALUE(arg, varptr);
25791 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25792 efree_size(ref, sizeof(zend_reference));
25793 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25794 Z_ADDREF_P(arg);
25795 }
25796 } else {
25797 ZVAL_COPY_VALUE(arg, varptr);
25798 }
25799
25800 ZEND_VM_NEXT_OPCODE();
25801}
25802
25803static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25804{
25805 zend_class_entry *ce, *scope;
25806 zend_class_constant *c;
25807 zval *value, *zv, *constant_zv;
25808 zend_string *constant_name;
25809 USE_OPLINE
25810
25811 SAVE_OPLINE();
25812
25813 do {
25814 if (IS_VAR == IS_CONST && IS_CONST == IS_CONST) {
25815 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
25816 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25817 break;
25818 }
25819 }
25820 if (IS_VAR == IS_CONST) {
25821 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
25822 ce = CACHED_PTR(opline->extended_value);
25823 } else {
25824 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);
25825 if (UNEXPECTED(ce == NULL)) {
25826 ZVAL_UNDEF(EX_VAR(opline->result.var));
25827
25828 HANDLE_EXCEPTION();
25829 }
25830 CACHE_PTR(opline->extended_value, ce);
25831 }
25832 } else if (IS_VAR == IS_UNUSED) {
25833 ce = zend_fetch_class(NULL, opline->op1.num);
25834 if (UNEXPECTED(ce == NULL)) {
25835 ZVAL_UNDEF(EX_VAR(opline->result.var));
25836
25837 HANDLE_EXCEPTION();
25838 }
25839 } else {
25840 ce = Z_CE_P(EX_VAR(opline->op1.var));
25841 }
25842 if (IS_VAR != IS_CONST
25843 && IS_CONST == IS_CONST
25844 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
25845 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25846 break;
25847 }
25848
25849 constant_zv = RT_CONSTANT(opline, opline->op2);
25850 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
25851 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
25852 ZVAL_UNDEF(EX_VAR(opline->result.var));
25853
25854 HANDLE_EXCEPTION();
25855 }
25856 constant_name = Z_STR_P(constant_zv);
25857 /* Magic 'class' for constant OP2 is caught at compile-time */
25858 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
25859 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
25860
25861 ZEND_VM_NEXT_OPCODE();
25862 }
25863 zv = IS_CONST == IS_CONST
25864 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
25865 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
25866
25867 if (EXPECTED(zv != NULL)) {
25868 c = Z_PTR_P(zv);
25869 scope = EX(func)->op_array.scope;
25870 if (!zend_verify_const_access(c, scope)) {
25871 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));
25872 ZVAL_UNDEF(EX_VAR(opline->result.var));
25873
25874 HANDLE_EXCEPTION();
25875 }
25876
25877 if (ce->ce_flags & ZEND_ACC_TRAIT) {
25878 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25879 ZVAL_UNDEF(EX_VAR(opline->result.var));
25880
25881 HANDLE_EXCEPTION();
25882 }
25883
25884 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
25885 if (UNEXPECTED(is_constant_deprecated)) {
25886 zend_deprecated_class_constant(c, constant_name);
25887
25888 if (EG(exception)) {
25889 ZVAL_UNDEF(EX_VAR(opline->result.var));
25890
25891 HANDLE_EXCEPTION();
25892 }
25893 }
25894
25895 value = &c->value;
25896 // Enums require loading of all class constants to build the backed enum table
25897 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)) {
25898 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
25899 ZVAL_UNDEF(EX_VAR(opline->result.var));
25900
25901 HANDLE_EXCEPTION();
25902 }
25903 }
25904 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
25905 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
25906 ZVAL_UNDEF(EX_VAR(opline->result.var));
25907
25908 HANDLE_EXCEPTION();
25909 }
25910 }
25911 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
25912 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
25913 }
25914 } else {
25915 zend_throw_error(NULL, "Undefined constant %s::%s",
25916 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25917 ZVAL_UNDEF(EX_VAR(opline->result.var));
25918
25919 HANDLE_EXCEPTION();
25920 }
25921 } while (0);
25922
25923 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
25924
25925 ZEND_VM_NEXT_OPCODE();
25926}
25927
25928static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25929{
25930 USE_OPLINE
25931 zval *expr_ptr, new_expr;
25932
25933 SAVE_OPLINE();
25934 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
25935 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
25936 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25937 if (Z_ISREF_P(expr_ptr)) {
25938 Z_ADDREF_P(expr_ptr);
25939 } else {
25940 ZVAL_MAKE_REF_EX(expr_ptr, 2);
25941 }
25942 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25943 } else {
25944 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25945 if (IS_VAR == IS_TMP_VAR) {
25946 /* pass */
25947 } else if (IS_VAR == IS_CONST) {
25948 Z_TRY_ADDREF_P(expr_ptr);
25949 } else if (IS_VAR == IS_CV) {
25950 ZVAL_DEREF(expr_ptr);
25951 Z_TRY_ADDREF_P(expr_ptr);
25952 } else /* if (IS_VAR == IS_VAR) */ {
25953 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
25954 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
25955
25956 expr_ptr = Z_REFVAL_P(expr_ptr);
25957 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25958 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
25959 expr_ptr = &new_expr;
25960 efree_size(ref, sizeof(zend_reference));
25961 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
25962 Z_ADDREF_P(expr_ptr);
25963 }
25964 }
25965 }
25966 }
25967
25968 if (IS_CONST != IS_UNUSED) {
25969 zval *offset = RT_CONSTANT(opline, opline->op2);
25970 zend_string *str;
25971 zend_ulong hval;
25972
25973add_again:
25974 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
25975 str = Z_STR_P(offset);
25976 if (IS_CONST != IS_CONST) {
25977 if (ZEND_HANDLE_NUMERIC(str, hval)) {
25978 goto num_index;
25979 }
25980 }
25981str_index:
25982 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
25983 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
25984 hval = Z_LVAL_P(offset);
25985num_index:
25986 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
25987 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
25988 offset = Z_REFVAL_P(offset);
25989 goto add_again;
25990 } else if (Z_TYPE_P(offset) == IS_NULL) {
25991 str = ZSTR_EMPTY_ALLOC();
25992 goto str_index;
25993 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
25994 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
25995 goto num_index;
25996 } else if (Z_TYPE_P(offset) == IS_FALSE) {
25997 hval = 0;
25998 goto num_index;
25999 } else if (Z_TYPE_P(offset) == IS_TRUE) {
26000 hval = 1;
26001 goto num_index;
26002 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
26003 zend_use_resource_as_offset(offset);
26004 hval = Z_RES_HANDLE_P(offset);
26005 goto num_index;
26006 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
26007 ZVAL_UNDEFINED_OP2();
26008 str = ZSTR_EMPTY_ALLOC();
26009 goto str_index;
26010 } else {
26011 zend_illegal_array_offset_access(offset);
26012 zval_ptr_dtor_nogc(expr_ptr);
26013 }
26014
26015 } else {
26016 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
26017 zend_cannot_add_element();
26018 zval_ptr_dtor_nogc(expr_ptr);
26019 }
26020 }
26021 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26022}
26023
26024static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26025{
26026 zval *array;
26027 uint32_t size;
26028 USE_OPLINE
26029
26030 SAVE_OPLINE();
26031 array = EX_VAR(opline->result.var);
26032 if (IS_VAR != IS_UNUSED) {
26033 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
26034 ZVAL_ARR(array, zend_new_array(size));
26035 /* Explicitly initialize array as not-packed if flag is set */
26036 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
26037 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
26038 }
26039 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26040 } else {
26041 ZVAL_ARR(array, zend_new_array(0));
26042 ZEND_VM_NEXT_OPCODE();
26043 }
26044}
26045
26046static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26047{
26048 USE_OPLINE
26049 zval *container;
26050 zval *offset;
26051 zend_ulong hval;
26052 zend_string *key;
26053
26054 SAVE_OPLINE();
26055 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26056 offset = RT_CONSTANT(opline, opline->op2);
26057
26058 do {
26059 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26060 HashTable *ht;
26061
26062unset_dim_array:
26063 SEPARATE_ARRAY(container);
26064 ht = Z_ARRVAL_P(container);
26065offset_again:
26066 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
26067 key = Z_STR_P(offset);
26068 if (IS_CONST != IS_CONST) {
26069 if (ZEND_HANDLE_NUMERIC(key, hval)) {
26070 goto num_index_dim;
26071 }
26072 }
26073str_index_dim:
26074 ZEND_ASSERT(ht != &EG(symbol_table));
26075 zend_hash_del(ht, key);
26076 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
26077 hval = Z_LVAL_P(offset);
26078num_index_dim:
26079 zend_hash_index_del(ht, hval);
26080 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
26081 offset = Z_REFVAL_P(offset);
26082 goto offset_again;
26083 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
26084 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
26085 goto num_index_dim;
26086 } else if (Z_TYPE_P(offset) == IS_NULL) {
26087 key = ZSTR_EMPTY_ALLOC();
26088 goto str_index_dim;
26089 } else if (Z_TYPE_P(offset) == IS_FALSE) {
26090 hval = 0;
26091 goto num_index_dim;
26092 } else if (Z_TYPE_P(offset) == IS_TRUE) {
26093 hval = 1;
26094 goto num_index_dim;
26095 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
26096 zend_use_resource_as_offset(offset);
26097 hval = Z_RES_HANDLE_P(offset);
26098 goto num_index_dim;
26099 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
26100 ZVAL_UNDEFINED_OP2();
26101 key = ZSTR_EMPTY_ALLOC();
26102 goto str_index_dim;
26103 } else {
26104 zend_illegal_array_offset_unset(offset);
26105 }
26106 break;
26107 } else if (Z_ISREF_P(container)) {
26108 container = Z_REFVAL_P(container);
26109 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26110 goto unset_dim_array;
26111 }
26112 }
26113 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
26114 container = ZVAL_UNDEFINED_OP1();
26115 }
26116 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
26117 offset = ZVAL_UNDEFINED_OP2();
26118 }
26119 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
26120 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
26121 offset++;
26122 }
26123 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
26124 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
26125 zend_throw_error(NULL, "Cannot unset string offsets");
26126 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
26127 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
26128 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
26129 zend_false_to_array_deprecated();
26130 }
26131 } while (0);
26132
26133 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26134 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26135}
26136
26137static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26138{
26139 USE_OPLINE
26140 zval *container;
26141 zval *offset;
26142 zend_string *name, *tmp_name;
26143
26144 SAVE_OPLINE();
26145 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26146 offset = RT_CONSTANT(opline, opline->op2);
26147
26148 do {
26149 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
26150 if (Z_ISREF_P(container)) {
26151 container = Z_REFVAL_P(container);
26152 if (Z_TYPE_P(container) != IS_OBJECT) {
26153 if (IS_VAR == IS_CV
26154 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
26155 ZVAL_UNDEFINED_OP1();
26156 }
26157 break;
26158 }
26159 } else {
26160 break;
26161 }
26162 }
26163 if (IS_CONST == IS_CONST) {
26164 name = Z_STR_P(offset);
26165 } else {
26166 name = zval_try_get_tmp_string(offset, &tmp_name);
26167 if (UNEXPECTED(!name)) {
26168 break;
26169 }
26170 }
26171 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
26172 if (IS_CONST != IS_CONST) {
26173 zend_tmp_string_release(tmp_name);
26174 }
26175 } while (0);
26176
26177 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26178 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26179}
26180
26181static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26182{
26183 USE_OPLINE
26184
26185 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
26186
26187 SAVE_OPLINE();
26188 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
26189 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26190 }
26191
26192 /* Destroy the previously yielded value */
26193 zval_ptr_dtor(&generator->value);
26194
26195 /* Destroy the previously yielded key */
26196 zval_ptr_dtor(&generator->key);
26197
26198 /* Set the new yielded value */
26199 if (IS_VAR != IS_UNUSED) {
26200 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
26201 /* Constants and temporary variables aren't yieldable by reference,
26202 * but we still allow them with a notice. */
26203 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
26204 zval *value;
26205
26206 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
26207
26208 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26209 ZVAL_COPY_VALUE(&generator->value, value);
26210 if (IS_VAR == IS_CONST) {
26211 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
26212 Z_ADDREF(generator->value);
26213 }
26214 }
26215 } else {
26216 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26217
26218 /* If a function call result is yielded and the function did
26219 * not return by reference we throw a notice. */
26220 do {
26221 if (IS_VAR == IS_VAR) {
26222 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
26223 if (opline->extended_value == ZEND_RETURNS_FUNCTION
26224 && !Z_ISREF_P(value_ptr)) {
26225 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
26226 ZVAL_COPY(&generator->value, value_ptr);
26227 break;
26228 }
26229 }
26230 if (Z_ISREF_P(value_ptr)) {
26231 Z_ADDREF_P(value_ptr);
26232 } else {
26233 ZVAL_MAKE_REF_EX(value_ptr, 2);
26234 }
26235 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
26236 } while (0);
26237
26238 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26239 }
26240 } else {
26241 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26242
26243 /* Consts, temporary variables and references need copying */
26244 if (IS_VAR == IS_CONST) {
26245 ZVAL_COPY_VALUE(&generator->value, value);
26246 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
26247 Z_ADDREF(generator->value);
26248 }
26249 } else if (IS_VAR == IS_TMP_VAR) {
26250 ZVAL_COPY_VALUE(&generator->value, value);
26251 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
26252 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
26253 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26254 } else {
26255 ZVAL_COPY_VALUE(&generator->value, value);
26256 if (IS_VAR == IS_CV) {
26257 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
26258 }
26259 }
26260 }
26261 } else {
26262 /* If no value was specified yield null */
26263 ZVAL_NULL(&generator->value);
26264 }
26265
26266 /* Set the new yielded key */
26267 if (IS_CONST != IS_UNUSED) {
26268 zval *key = RT_CONSTANT(opline, opline->op2);
26269 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
26270 key = Z_REFVAL_P(key);
26271 }
26272 ZVAL_COPY(&generator->key, key);
26273
26274 if (Z_TYPE(generator->key) == IS_LONG
26275 && Z_LVAL(generator->key) > generator->largest_used_integer_key
26276 ) {
26277 generator->largest_used_integer_key = Z_LVAL(generator->key);
26278 }
26279 } else {
26280 /* If no key was specified we use auto-increment keys */
26281 generator->largest_used_integer_key++;
26282 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
26283 }
26284
26285 if (RETURN_VALUE_USED(opline)) {
26286 /* If the return value of yield is used set the send
26287 * target and initialize it to NULL */
26288 generator->send_target = EX_VAR(opline->result.var);
26289 ZVAL_NULL(generator->send_target);
26290 } else {
26291 generator->send_target = NULL;
26292 }
26293
26294 /* The GOTO VM uses a local opline variable. We need to set the opline
26295 * variable in execute_data so we don't resume at an old position. */
26296 SAVE_OPLINE();
26297
26298 ZEND_VM_RETURN();
26299}
26300
26301static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26302{
26303 USE_OPLINE
26304 zval *op1;
26305 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
26306 zval *result;
26307
26308 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26309 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26310 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_VAR == IS_CONST);
26311 if (IS_VAR & (IS_TMP_VAR|IS_VAR)) {
26312 zval_ptr_dtor_str(op1);
26313 }
26314 ZEND_VM_SMART_BRANCH(result, 0);
26315 }
26316
26317 if (opline->extended_value) {
26318 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
26319 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
26320 ZEND_VM_SMART_BRANCH(result, 0);
26321 }
26322 SAVE_OPLINE();
26323 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
26324 op1 = Z_REFVAL_P(op1);
26325 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26326 result = zend_hash_find(ht, Z_STR_P(op1));
26327 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26328 ZEND_VM_SMART_BRANCH(result, 0);
26329 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
26330 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
26331 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26332 ZEND_VM_SMART_BRANCH(result, 0);
26333 }
26334 } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
26335 ZVAL_UNDEFINED_OP1();
26336 }
26337 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
26338 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
26339 SAVE_OPLINE();
26340 ZVAL_UNDEFINED_OP1();
26341 if (UNEXPECTED(EG(exception) != NULL)) {
26342 HANDLE_EXCEPTION();
26343 }
26344 }
26345 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
26346 ZEND_VM_SMART_BRANCH(result, 0);
26347 } else {
26348 zend_string *key;
26349 zval key_tmp;
26350
26351 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
26352 op1 = Z_REFVAL_P(op1);
26353 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26354 result = zend_hash_find(ht, Z_STR_P(op1));
26355 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26356 ZEND_VM_SMART_BRANCH(result, 0);
26357 }
26358 }
26359
26360 SAVE_OPLINE();
26361 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
26362 ZVAL_STR(&key_tmp, key);
26363 if (zend_compare(op1, &key_tmp) == 0) {
26364 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26365 ZEND_VM_SMART_BRANCH(1, 1);
26366 }
26367 } ZEND_HASH_FOREACH_END();
26368 }
26369 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26370 ZEND_VM_SMART_BRANCH(0, 1);
26371}
26372
26373static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26374{
26375 zend_class_entry *ce, *scope;
26376 zend_class_constant *c;
26377 zval *value, *zv, *constant_zv;
26378 zend_string *constant_name;
26379 USE_OPLINE
26380
26381 SAVE_OPLINE();
26382
26383 do {
26384 if (IS_VAR == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
26385 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
26386 value = CACHED_PTR(opline->extended_value + sizeof(void*));
26387 break;
26388 }
26389 }
26390 if (IS_VAR == IS_CONST) {
26391 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
26392 ce = CACHED_PTR(opline->extended_value);
26393 } else {
26394 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);
26395 if (UNEXPECTED(ce == NULL)) {
26396 ZVAL_UNDEF(EX_VAR(opline->result.var));
26397 FREE_OP(opline->op2_type, opline->op2.var);
26398 HANDLE_EXCEPTION();
26399 }
26400 CACHE_PTR(opline->extended_value, ce);
26401 }
26402 } else if (IS_VAR == IS_UNUSED) {
26403 ce = zend_fetch_class(NULL, opline->op1.num);
26404 if (UNEXPECTED(ce == NULL)) {
26405 ZVAL_UNDEF(EX_VAR(opline->result.var));
26406 FREE_OP(opline->op2_type, opline->op2.var);
26407 HANDLE_EXCEPTION();
26408 }
26409 } else {
26410 ce = Z_CE_P(EX_VAR(opline->op1.var));
26411 }
26412 if (IS_VAR != IS_CONST
26413 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
26414 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
26415 value = CACHED_PTR(opline->extended_value + sizeof(void*));
26416 break;
26417 }
26418
26419 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
26420 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
26421 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
26422 ZVAL_UNDEF(EX_VAR(opline->result.var));
26423 FREE_OP(opline->op2_type, opline->op2.var);
26424 HANDLE_EXCEPTION();
26425 }
26426 constant_name = Z_STR_P(constant_zv);
26427 /* Magic 'class' for constant OP2 is caught at compile-time */
26428 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
26429 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
26430 FREE_OP(opline->op2_type, opline->op2.var);
26431 ZEND_VM_NEXT_OPCODE();
26432 }
26433 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
26434 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
26435 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
26436
26437 if (EXPECTED(zv != NULL)) {
26438 c = Z_PTR_P(zv);
26439 scope = EX(func)->op_array.scope;
26440 if (!zend_verify_const_access(c, scope)) {
26441 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));
26442 ZVAL_UNDEF(EX_VAR(opline->result.var));
26443 FREE_OP(opline->op2_type, opline->op2.var);
26444 HANDLE_EXCEPTION();
26445 }
26446
26447 if (ce->ce_flags & ZEND_ACC_TRAIT) {
26448 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
26449 ZVAL_UNDEF(EX_VAR(opline->result.var));
26450 FREE_OP(opline->op2_type, opline->op2.var);
26451 HANDLE_EXCEPTION();
26452 }
26453
26454 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
26455 if (UNEXPECTED(is_constant_deprecated)) {
26456 zend_deprecated_class_constant(c, constant_name);
26457
26458 if (EG(exception)) {
26459 ZVAL_UNDEF(EX_VAR(opline->result.var));
26460 FREE_OP(opline->op2_type, opline->op2.var);
26461 HANDLE_EXCEPTION();
26462 }
26463 }
26464
26465 value = &c->value;
26466 // Enums require loading of all class constants to build the backed enum table
26467 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)) {
26468 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
26469 ZVAL_UNDEF(EX_VAR(opline->result.var));
26470 FREE_OP(opline->op2_type, opline->op2.var);
26471 HANDLE_EXCEPTION();
26472 }
26473 }
26474 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
26475 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
26476 ZVAL_UNDEF(EX_VAR(opline->result.var));
26477 FREE_OP(opline->op2_type, opline->op2.var);
26478 HANDLE_EXCEPTION();
26479 }
26480 }
26481 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
26482 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
26483 }
26484 } else {
26485 zend_throw_error(NULL, "Undefined constant %s::%s",
26486 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
26487 ZVAL_UNDEF(EX_VAR(opline->result.var));
26488 FREE_OP(opline->op2_type, opline->op2.var);
26489 HANDLE_EXCEPTION();
26490 }
26491 } while (0);
26492
26493 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
26494
26495 FREE_OP(opline->op2_type, opline->op2.var);
26496 ZEND_VM_NEXT_OPCODE();
26497}
26498
26499static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26500{
26501 USE_OPLINE
26502 zval *object;
26503 zval *property;
26504 zval *value;
26505 zval *zptr;
26506 void *_cache_slot[3] = {0};
26507 void **cache_slot;
26508 zend_property_info *prop_info;
26509 zend_object *zobj;
26510 zend_string *name, *tmp_name;
26511
26512 SAVE_OPLINE();
26513 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26514 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26515
26516 do {
26517 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
26518
26519 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26520 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26521 object = Z_REFVAL_P(object);
26522 goto assign_op_object;
26523 }
26524 if (IS_VAR == IS_CV
26525 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26526 ZVAL_UNDEFINED_OP1();
26527 }
26528 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26529 break;
26530 }
26531
26532assign_op_object:
26533 /* here we are sure we are dealing with an object */
26534 zobj = Z_OBJ_P(object);
26535 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26536 name = Z_STR_P(property);
26537 } else {
26538 name = zval_try_get_tmp_string(property, &tmp_name);
26539 if (UNEXPECTED(!name)) {
26540 UNDEF_RESULT();
26541 break;
26542 }
26543 }
26544 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
26545 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26546 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26547 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26548 ZVAL_NULL(EX_VAR(opline->result.var));
26549 }
26550 } else {
26551 zend_reference *ref;
26552
26553 do {
26554 if (UNEXPECTED(Z_ISREF_P(zptr))) {
26555 ref = Z_REF_P(zptr);
26556 zptr = Z_REFVAL_P(zptr);
26557 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26558 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26559 break;
26560 }
26561 }
26562
26563 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
26564 if (prop_info) {
26565 /* special case for typed properties */
26566 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
26567 } else {
26568 zend_binary_op(zptr, zptr, value OPLINE_CC);
26569 }
26570 } while (0);
26571
26572 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26573 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
26574 }
26575 }
26576 } else {
26577 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
26578 }
26579 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26580 zend_tmp_string_release(tmp_name);
26581 }
26582 } while (0);
26583
26584 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26585 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26586 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26587 /* assign_obj has two opcodes! */
26588 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26589}
26590
26591/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
26592static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26593{
26594 USE_OPLINE
26595 zval *var_ptr;
26596 zval *value, *container, *dim;
26597 HashTable *ht;
26598
26599 SAVE_OPLINE();
26600 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26601
26602 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26603assign_dim_op_array:
26604 SEPARATE_ARRAY(container);
26605 ht = Z_ARRVAL_P(container);
26606assign_dim_op_new_array:
26607 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26608 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
26609 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
26610 if (UNEXPECTED(!var_ptr)) {
26611 zend_cannot_add_element();
26612 goto assign_dim_op_ret_null;
26613 }
26614 } else {
26615 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26616 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
26617 } else {
26618 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
26619 }
26620 if (UNEXPECTED(!var_ptr)) {
26621 goto assign_dim_op_ret_null;
26622 }
26623 }
26624
26625 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
26626
26627 do {
26628 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
26629 zend_reference *ref = Z_REF_P(var_ptr);
26630 var_ptr = Z_REFVAL_P(var_ptr);
26631 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26632 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26633 break;
26634 }
26635 }
26636 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26637 } while (0);
26638
26639 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26640 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26641 }
26642 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26643 } else {
26644 if (EXPECTED(Z_ISREF_P(container))) {
26645 container = Z_REFVAL_P(container);
26646 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26647 goto assign_dim_op_array;
26648 }
26649 }
26650
26651 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
26652 zend_object *obj = Z_OBJ_P(container);
26653
26654 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26655 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
26656 dim++;
26657 }
26658 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
26659 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
26660 uint8_t old_type;
26661
26662 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
26663 ZVAL_UNDEFINED_OP1();
26664 }
26665 ht = zend_new_array(8);
26666 old_type = Z_TYPE_P(container);
26667 ZVAL_ARR(container, ht);
26668 if (UNEXPECTED(old_type == IS_FALSE)) {
26669 GC_ADDREF(ht);
26670 zend_false_to_array_deprecated();
26671 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
26672 zend_array_destroy(ht);
26673 goto assign_dim_op_ret_null;
26674 }
26675 }
26676 goto assign_dim_op_new_array;
26677 } else {
26678 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26679 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
26680assign_dim_op_ret_null:
26681 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26682 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26683 ZVAL_NULL(EX_VAR(opline->result.var));
26684 }
26685 }
26686 }
26687
26688 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26689 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26690 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26691}
26692
26693static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26694{
26695 USE_OPLINE
26696 zval *var_ptr;
26697 zval *value;
26698
26699 SAVE_OPLINE();
26700 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26701 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26702
26703 do {
26704 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
26705 zend_reference *ref = Z_REF_P(var_ptr);
26706 var_ptr = Z_REFVAL_P(var_ptr);
26707 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26708 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26709 break;
26710 }
26711 }
26712 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26713 } while (0);
26714
26715 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26716 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26717 }
26718
26719 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26720 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26721 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26722}
26723
26724static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26725{
26726 USE_OPLINE
26727 zval *object;
26728 zval *property;
26729 zval *zptr;
26730 void *_cache_slot[3] = {0};
26731 void **cache_slot;
26732 zend_property_info *prop_info;
26733 zend_object *zobj;
26734 zend_string *name, *tmp_name;
26735
26736 SAVE_OPLINE();
26737 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26738 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26739
26740 do {
26741 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26742 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26743 object = Z_REFVAL_P(object);
26744 goto pre_incdec_object;
26745 }
26746 if (IS_VAR == IS_CV
26747 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26748 ZVAL_UNDEFINED_OP1();
26749 }
26750 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26751 break;
26752 }
26753
26754pre_incdec_object:
26755 /* here we are sure we are dealing with an object */
26756 zobj = Z_OBJ_P(object);
26757 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26758 name = Z_STR_P(property);
26759 } else {
26760 name = zval_try_get_tmp_string(property, &tmp_name);
26761 if (UNEXPECTED(!name)) {
26762 UNDEF_RESULT();
26763 break;
26764 }
26765 }
26766 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
26767 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26768 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26769 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26770 ZVAL_NULL(EX_VAR(opline->result.var));
26771 }
26772 } else {
26773 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
26774 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26775 }
26776 } else {
26777 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26778 }
26779 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26780 zend_tmp_string_release(tmp_name);
26781 }
26782 } while (0);
26783
26784 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26785 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26786 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26787}
26788
26789static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26790{
26791 USE_OPLINE
26792 zval *object;
26793 zval *property;
26794 zval *zptr;
26795 void *_cache_slot[3] = {0};
26796 void **cache_slot;
26797 zend_property_info *prop_info;
26798 zend_object *zobj;
26799 zend_string *name, *tmp_name;
26800
26801 SAVE_OPLINE();
26802 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26803 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26804
26805 do {
26806 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26807 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26808 object = Z_REFVAL_P(object);
26809 goto post_incdec_object;
26810 }
26811 if (IS_VAR == IS_CV
26812 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26813 ZVAL_UNDEFINED_OP1();
26814 }
26815 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26816 break;
26817 }
26818
26819post_incdec_object:
26820 /* here we are sure we are dealing with an object */
26821 zobj = Z_OBJ_P(object);
26822 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26823 name = Z_STR_P(property);
26824 } else {
26825 name = zval_try_get_tmp_string(property, &tmp_name);
26826 if (UNEXPECTED(!name)) {
26827 ZVAL_UNDEF(EX_VAR(opline->result.var));
26828 break;
26829 }
26830 }
26831 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
26832 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26833 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26834 ZVAL_NULL(EX_VAR(opline->result.var));
26835 } else {
26836 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
26837 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26838 }
26839 } else {
26840 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26841 }
26842 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26843 zend_tmp_string_release(tmp_name);
26844 }
26845 } while (0);
26846
26847 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26848 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26849 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26850}
26851
26852static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26853{
26854 USE_OPLINE
26855 zval *container;
26856
26857 SAVE_OPLINE();
26858 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26859 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);
26860 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26861 if (IS_VAR == IS_VAR) {
26862 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26863 }
26864 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26865}
26866
26867static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26868{
26869 USE_OPLINE
26870 zval *container;
26871
26872 SAVE_OPLINE();
26873 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26874 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);
26875 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26876 if (IS_VAR == IS_VAR) {
26877 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26878 }
26879 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26880}
26881
26882static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26883{
26884#if 0
26885 USE_OPLINE
26886#endif
26887
26888 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
26889 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
26890 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26891 }
26892 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26893 } else {
26894 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
26895 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26896 }
26897 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26898 }
26899}
26900
26901static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26902{
26903 USE_OPLINE
26904 zval *container;
26905
26906 SAVE_OPLINE();
26907 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26908 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);
26909 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26910 if (IS_VAR == IS_VAR) {
26911 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26912 }
26913 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26914}
26915
26916static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26917{
26918 USE_OPLINE
26919 zval *property, *container, *result;
26920
26921 SAVE_OPLINE();
26922
26923 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26924 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26925 result = EX_VAR(opline->result.var);
26926 zend_fetch_property_address(
26927 result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR),
26928 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
26929 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
26930 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26931 if (IS_VAR == IS_VAR) {
26932 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26933 }
26934 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26935}
26936
26937static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26938{
26939 USE_OPLINE
26940 zval *property, *container, *result;
26941
26942 SAVE_OPLINE();
26943 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26944 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26945 result = EX_VAR(opline->result.var);
26946 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);
26947 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26948 if (IS_VAR == IS_VAR) {
26949 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26950 }
26951 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26952}
26953
26954static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26955{
26956#if 0
26957 USE_OPLINE
26958#endif
26959
26960 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
26961 /* Behave like FETCH_OBJ_W */
26962 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
26963 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26964 }
26965 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26966 } else {
26967 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26968 }
26969}
26970
26971static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26972{
26973 USE_OPLINE
26974 zval *container, *property, *result;
26975
26976 SAVE_OPLINE();
26977 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26978 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26979 result = EX_VAR(opline->result.var);
26980 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);
26981 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26982 if (IS_VAR == IS_VAR) {
26983 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26984 }
26985 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26986}
26987
26988static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26989{
26990 USE_OPLINE
26991 zval *container, *dim;
26992
26993 SAVE_OPLINE();
26994 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26995 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26996
26997 if (IS_VAR == IS_VAR
26998 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
26999 && UNEXPECTED(!Z_ISREF_P(container))
27000 ) {
27001 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
27002 zend_fetch_dimension_address_LIST_r(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
27003 } else {
27004 zend_fetch_dimension_address_W(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
27005 }
27006
27007 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27008 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27009}
27010
27011static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27012{
27013 USE_OPLINE
27014 zval *object, *value, tmp;
27015 zend_object *zobj;
27016 zend_string *name, *tmp_name;
27017 zend_refcounted *garbage = NULL;
27018
27019 SAVE_OPLINE();
27020 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27021 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27022
27023 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27024 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27025 object = Z_REFVAL_P(object);
27026 goto assign_object;
27027 }
27028 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27029 value = &EG(uninitialized_zval);
27030 goto free_and_exit_assign_obj;
27031 }
27032
27033assign_object:
27034 zobj = Z_OBJ_P(object);
27035 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27036 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27037 void **cache_slot = CACHE_ADDR(opline->extended_value);
27038 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27039 zval *property_val;
27040 zend_property_info *prop_info;
27041
27042 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27043 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27044
27045assign_obj_simple:
27046 property_val = OBJ_PROP(zobj, prop_offset);
27047 if (Z_TYPE_P(property_val) != IS_UNDEF) {
27048 if (prop_info != NULL) {
27049 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27050 goto free_and_exit_assign_obj;
27051 } else {
27052fast_assign_obj:
27053 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
27054 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27055 ZVAL_COPY(EX_VAR(opline->result.var), value);
27056 }
27057 goto exit_assign_obj;
27058 }
27059 }
27060 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27061 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27062 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27063 zobj = zend_lazy_object_init(zobj);
27064 if (!zobj) {
27065 value = &EG(uninitialized_zval);
27066 goto free_and_exit_assign_obj;
27067 }
27068 }
27069 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27070 rebuild_object_properties_internal(zobj);
27071 }
27072 if (EXPECTED(zobj->properties != NULL)) {
27073 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27074 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27075 GC_DELREF(zobj->properties);
27076 }
27077 zobj->properties = zend_array_dup(zobj->properties);
27078 }
27079 property_val = zend_hash_find_known_hash(zobj->properties, name);
27080 if (property_val) {
27081 goto fast_assign_obj;
27082 }
27083 }
27084
27085 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27086 if (IS_CONST == IS_CONST) {
27087 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27088 Z_ADDREF_P(value);
27089 }
27090 } else if (IS_CONST != IS_TMP_VAR) {
27091 if (Z_ISREF_P(value)) {
27092 if (IS_CONST == IS_VAR) {
27093 zend_reference *ref = Z_REF_P(value);
27094 if (GC_DELREF(ref) == 0) {
27095 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27096 efree_size(ref, sizeof(zend_reference));
27097 value = &tmp;
27098 } else {
27099 value = Z_REFVAL_P(value);
27100 Z_TRY_ADDREF_P(value);
27101 }
27102 } else {
27103 value = Z_REFVAL_P(value);
27104 Z_TRY_ADDREF_P(value);
27105 }
27106 } else if (IS_CONST == IS_CV) {
27107 Z_TRY_ADDREF_P(value);
27108 }
27109 }
27110 zend_hash_add_new(zobj->properties, name, value);
27111 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27112 ZVAL_COPY(EX_VAR(opline->result.var), value);
27113 }
27114 goto exit_assign_obj;
27115 }
27116 } else {
27117 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27118 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27119 prop_info = CACHED_PTR_EX(cache_slot + 2);
27120 prop_offset = prop_info->offset;
27121 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27122 prop_info = NULL;
27123 }
27124 goto assign_obj_simple;
27125 }
27126 /* Fall through to write_property for hooks. */
27127 }
27128 }
27129 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27130 } else {
27131 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27132 if (UNEXPECTED(!name)) {
27133
27134 UNDEF_RESULT();
27135 goto exit_assign_obj;
27136 }
27137 }
27138
27139 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
27140 ZVAL_DEREF(value);
27141 }
27142
27143 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27144
27145 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27146 zend_tmp_string_release(tmp_name);
27147 }
27148
27149free_and_exit_assign_obj:
27150 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27151 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27152 }
27153
27154exit_assign_obj:
27155 if (garbage) {
27156 GC_DTOR_NO_REF(garbage);
27157 }
27158 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27159 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27160 /* assign_obj has two opcodes! */
27161 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27162}
27163
27164/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27165static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27166{
27167 USE_OPLINE
27168 zval *object, *value, tmp;
27169 zend_object *zobj;
27170 zend_string *name, *tmp_name;
27171 zend_refcounted *garbage = NULL;
27172
27173 SAVE_OPLINE();
27174 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27175 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27176
27177 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27178 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27179 object = Z_REFVAL_P(object);
27180 goto assign_object;
27181 }
27182 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27183 value = &EG(uninitialized_zval);
27184 goto free_and_exit_assign_obj;
27185 }
27186
27187assign_object:
27188 zobj = Z_OBJ_P(object);
27189 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27190 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27191 void **cache_slot = CACHE_ADDR(opline->extended_value);
27192 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27193 zval *property_val;
27194 zend_property_info *prop_info;
27195
27196 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27197 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27198
27199assign_obj_simple:
27200 property_val = OBJ_PROP(zobj, prop_offset);
27201 if (Z_TYPE_P(property_val) != IS_UNDEF) {
27202 if (prop_info != NULL) {
27203 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27204 goto free_and_exit_assign_obj;
27205 } else {
27206fast_assign_obj:
27207 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
27208 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27209 ZVAL_COPY(EX_VAR(opline->result.var), value);
27210 }
27211 goto exit_assign_obj;
27212 }
27213 }
27214 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27215 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27216 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27217 zobj = zend_lazy_object_init(zobj);
27218 if (!zobj) {
27219 value = &EG(uninitialized_zval);
27220 goto free_and_exit_assign_obj;
27221 }
27222 }
27223 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27224 rebuild_object_properties_internal(zobj);
27225 }
27226 if (EXPECTED(zobj->properties != NULL)) {
27227 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27228 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27229 GC_DELREF(zobj->properties);
27230 }
27231 zobj->properties = zend_array_dup(zobj->properties);
27232 }
27233 property_val = zend_hash_find_known_hash(zobj->properties, name);
27234 if (property_val) {
27235 goto fast_assign_obj;
27236 }
27237 }
27238
27239 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27240 if (IS_TMP_VAR == IS_CONST) {
27241 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27242 Z_ADDREF_P(value);
27243 }
27244 } else if (IS_TMP_VAR != IS_TMP_VAR) {
27245 if (Z_ISREF_P(value)) {
27246 if (IS_TMP_VAR == IS_VAR) {
27247 zend_reference *ref = Z_REF_P(value);
27248 if (GC_DELREF(ref) == 0) {
27249 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27250 efree_size(ref, sizeof(zend_reference));
27251 value = &tmp;
27252 } else {
27253 value = Z_REFVAL_P(value);
27254 Z_TRY_ADDREF_P(value);
27255 }
27256 } else {
27257 value = Z_REFVAL_P(value);
27258 Z_TRY_ADDREF_P(value);
27259 }
27260 } else if (IS_TMP_VAR == IS_CV) {
27261 Z_TRY_ADDREF_P(value);
27262 }
27263 }
27264 zend_hash_add_new(zobj->properties, name, value);
27265 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27266 ZVAL_COPY(EX_VAR(opline->result.var), value);
27267 }
27268 goto exit_assign_obj;
27269 }
27270 } else {
27271 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27272 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27273 prop_info = CACHED_PTR_EX(cache_slot + 2);
27274 prop_offset = prop_info->offset;
27275 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27276 prop_info = NULL;
27277 }
27278 goto assign_obj_simple;
27279 }
27280 /* Fall through to write_property for hooks. */
27281 }
27282 }
27283 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27284 } else {
27285 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27286 if (UNEXPECTED(!name)) {
27287 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27288 UNDEF_RESULT();
27289 goto exit_assign_obj;
27290 }
27291 }
27292
27293 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27294 ZVAL_DEREF(value);
27295 }
27296
27297 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27298
27299 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27300 zend_tmp_string_release(tmp_name);
27301 }
27302
27303free_and_exit_assign_obj:
27304 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27305 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27306 }
27307 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27308exit_assign_obj:
27309 if (garbage) {
27310 GC_DTOR_NO_REF(garbage);
27311 }
27312 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27313 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27314 /* assign_obj has two opcodes! */
27315 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27316}
27317
27318/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27319static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27320{
27321 USE_OPLINE
27322 zval *object, *value, tmp;
27323 zend_object *zobj;
27324 zend_string *name, *tmp_name;
27325 zend_refcounted *garbage = NULL;
27326
27327 SAVE_OPLINE();
27328 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27329 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27330
27331 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27332 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27333 object = Z_REFVAL_P(object);
27334 goto assign_object;
27335 }
27336 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27337 value = &EG(uninitialized_zval);
27338 goto free_and_exit_assign_obj;
27339 }
27340
27341assign_object:
27342 zobj = Z_OBJ_P(object);
27343 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27344 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27345 void **cache_slot = CACHE_ADDR(opline->extended_value);
27346 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27347 zval *property_val;
27348 zend_property_info *prop_info;
27349
27350 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27351 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27352
27353assign_obj_simple:
27354 property_val = OBJ_PROP(zobj, prop_offset);
27355 if (Z_TYPE_P(property_val) != IS_UNDEF) {
27356 if (prop_info != NULL) {
27357 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27358 goto free_and_exit_assign_obj;
27359 } else {
27360fast_assign_obj:
27361 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
27362 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27363 ZVAL_COPY(EX_VAR(opline->result.var), value);
27364 }
27365 goto exit_assign_obj;
27366 }
27367 }
27368 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27369 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27370 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27371 zobj = zend_lazy_object_init(zobj);
27372 if (!zobj) {
27373 value = &EG(uninitialized_zval);
27374 goto free_and_exit_assign_obj;
27375 }
27376 }
27377 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27378 rebuild_object_properties_internal(zobj);
27379 }
27380 if (EXPECTED(zobj->properties != NULL)) {
27381 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27382 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27383 GC_DELREF(zobj->properties);
27384 }
27385 zobj->properties = zend_array_dup(zobj->properties);
27386 }
27387 property_val = zend_hash_find_known_hash(zobj->properties, name);
27388 if (property_val) {
27389 goto fast_assign_obj;
27390 }
27391 }
27392
27393 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27394 if (IS_VAR == IS_CONST) {
27395 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27396 Z_ADDREF_P(value);
27397 }
27398 } else if (IS_VAR != IS_TMP_VAR) {
27399 if (Z_ISREF_P(value)) {
27400 if (IS_VAR == IS_VAR) {
27401 zend_reference *ref = Z_REF_P(value);
27402 if (GC_DELREF(ref) == 0) {
27403 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27404 efree_size(ref, sizeof(zend_reference));
27405 value = &tmp;
27406 } else {
27407 value = Z_REFVAL_P(value);
27408 Z_TRY_ADDREF_P(value);
27409 }
27410 } else {
27411 value = Z_REFVAL_P(value);
27412 Z_TRY_ADDREF_P(value);
27413 }
27414 } else if (IS_VAR == IS_CV) {
27415 Z_TRY_ADDREF_P(value);
27416 }
27417 }
27418 zend_hash_add_new(zobj->properties, name, value);
27419 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27420 ZVAL_COPY(EX_VAR(opline->result.var), value);
27421 }
27422 goto exit_assign_obj;
27423 }
27424 } else {
27425 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27426 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27427 prop_info = CACHED_PTR_EX(cache_slot + 2);
27428 prop_offset = prop_info->offset;
27429 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27430 prop_info = NULL;
27431 }
27432 goto assign_obj_simple;
27433 }
27434 /* Fall through to write_property for hooks. */
27435 }
27436 }
27437 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27438 } else {
27439 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27440 if (UNEXPECTED(!name)) {
27441 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27442 UNDEF_RESULT();
27443 goto exit_assign_obj;
27444 }
27445 }
27446
27447 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
27448 ZVAL_DEREF(value);
27449 }
27450
27451 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27452
27453 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27454 zend_tmp_string_release(tmp_name);
27455 }
27456
27457free_and_exit_assign_obj:
27458 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27459 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27460 }
27461 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27462exit_assign_obj:
27463 if (garbage) {
27464 GC_DTOR_NO_REF(garbage);
27465 }
27466 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27467 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27468 /* assign_obj has two opcodes! */
27469 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27470}
27471
27472/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27473static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27474{
27475 USE_OPLINE
27476 zval *object, *value, tmp;
27477 zend_object *zobj;
27478 zend_string *name, *tmp_name;
27479 zend_refcounted *garbage = NULL;
27480
27481 SAVE_OPLINE();
27482 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27483 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
27484
27485 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27486 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27487 object = Z_REFVAL_P(object);
27488 goto assign_object;
27489 }
27490 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27491 value = &EG(uninitialized_zval);
27492 goto free_and_exit_assign_obj;
27493 }
27494
27495assign_object:
27496 zobj = Z_OBJ_P(object);
27497 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27498 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27499 void **cache_slot = CACHE_ADDR(opline->extended_value);
27500 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27501 zval *property_val;
27502 zend_property_info *prop_info;
27503
27504 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27505 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27506
27507assign_obj_simple:
27508 property_val = OBJ_PROP(zobj, prop_offset);
27509 if (Z_TYPE_P(property_val) != IS_UNDEF) {
27510 if (prop_info != NULL) {
27511 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27512 goto free_and_exit_assign_obj;
27513 } else {
27514fast_assign_obj:
27515 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
27516 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27517 ZVAL_COPY(EX_VAR(opline->result.var), value);
27518 }
27519 goto exit_assign_obj;
27520 }
27521 }
27522 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27523 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27524 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27525 zobj = zend_lazy_object_init(zobj);
27526 if (!zobj) {
27527 value = &EG(uninitialized_zval);
27528 goto free_and_exit_assign_obj;
27529 }
27530 }
27531 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27532 rebuild_object_properties_internal(zobj);
27533 }
27534 if (EXPECTED(zobj->properties != NULL)) {
27535 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27536 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27537 GC_DELREF(zobj->properties);
27538 }
27539 zobj->properties = zend_array_dup(zobj->properties);
27540 }
27541 property_val = zend_hash_find_known_hash(zobj->properties, name);
27542 if (property_val) {
27543 goto fast_assign_obj;
27544 }
27545 }
27546
27547 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27548 if (IS_CV == IS_CONST) {
27549 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27550 Z_ADDREF_P(value);
27551 }
27552 } else if (IS_CV != IS_TMP_VAR) {
27553 if (Z_ISREF_P(value)) {
27554 if (IS_CV == IS_VAR) {
27555 zend_reference *ref = Z_REF_P(value);
27556 if (GC_DELREF(ref) == 0) {
27557 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27558 efree_size(ref, sizeof(zend_reference));
27559 value = &tmp;
27560 } else {
27561 value = Z_REFVAL_P(value);
27562 Z_TRY_ADDREF_P(value);
27563 }
27564 } else {
27565 value = Z_REFVAL_P(value);
27566 Z_TRY_ADDREF_P(value);
27567 }
27568 } else if (IS_CV == IS_CV) {
27569 Z_TRY_ADDREF_P(value);
27570 }
27571 }
27572 zend_hash_add_new(zobj->properties, name, value);
27573 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27574 ZVAL_COPY(EX_VAR(opline->result.var), value);
27575 }
27576 goto exit_assign_obj;
27577 }
27578 } else {
27579 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27580 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27581 prop_info = CACHED_PTR_EX(cache_slot + 2);
27582 prop_offset = prop_info->offset;
27583 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
27584 prop_info = NULL;
27585 }
27586 goto assign_obj_simple;
27587 }
27588 /* Fall through to write_property for hooks. */
27589 }
27590 }
27591 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27592 } else {
27593 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27594 if (UNEXPECTED(!name)) {
27595
27596 UNDEF_RESULT();
27597 goto exit_assign_obj;
27598 }
27599 }
27600
27601 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
27602 ZVAL_DEREF(value);
27603 }
27604
27605 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27606
27607 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27608 zend_tmp_string_release(tmp_name);
27609 }
27610
27611free_and_exit_assign_obj:
27612 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27613 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27614 }
27615
27616exit_assign_obj:
27617 if (garbage) {
27618 GC_DTOR_NO_REF(garbage);
27619 }
27620 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27621 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27622 /* assign_obj has two opcodes! */
27623 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27624}
27625
27626/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
27627static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27628{
27629 USE_OPLINE
27630 zval *object_ptr, *orig_object_ptr;
27631 zval *value;
27632 zval *variable_ptr;
27633 zval *dim;
27634 zend_refcounted *garbage = NULL;
27635
27636 SAVE_OPLINE();
27637 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27638
27639 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27640try_assign_dim_array:
27641 SEPARATE_ARRAY(object_ptr);
27642 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27643 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27644 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27645 HashTable *ht = Z_ARRVAL_P(object_ptr);
27646 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27647 GC_ADDREF(ht);
27648 }
27649 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27650 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27651 zend_array_destroy(ht);
27652 goto assign_dim_error;
27653 }
27654 }
27655 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
27656 ZVAL_DEREF(value);
27657 }
27658 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27659 if (UNEXPECTED(value == NULL)) {
27660 zend_cannot_add_element();
27661 goto assign_dim_error;
27662 } else if (IS_CONST == IS_CV) {
27663 if (Z_REFCOUNTED_P(value)) {
27664 Z_ADDREF_P(value);
27665 }
27666 } else if (IS_CONST == IS_VAR) {
27667 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27668 if (Z_ISREF_P(free_op_data)) {
27669 if (Z_REFCOUNTED_P(value)) {
27670 Z_ADDREF_P(value);
27671 }
27672 zval_ptr_dtor_nogc(free_op_data);
27673 }
27674 } else if (IS_CONST == IS_CONST) {
27675 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27676 Z_ADDREF_P(value);
27677 }
27678 }
27679 } else {
27680 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27681 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27682 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27683 } else {
27684 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27685 }
27686 if (UNEXPECTED(variable_ptr == NULL)) {
27687 goto assign_dim_error;
27688 }
27689 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27690 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
27691 }
27692 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27693 ZVAL_COPY(EX_VAR(opline->result.var), value);
27694 }
27695 if (garbage) {
27696 GC_DTOR_NO_REF(garbage);
27697 }
27698 } else {
27699 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27700 object_ptr = Z_REFVAL_P(object_ptr);
27701 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27702 goto try_assign_dim_array;
27703 }
27704 }
27705 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27706 zend_object *obj = Z_OBJ_P(object_ptr);
27707
27708 GC_ADDREF(obj);
27709 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27710 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27711 dim = ZVAL_UNDEFINED_OP2();
27712 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27713 dim++;
27714 }
27715
27716 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27717 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27718 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27719 } else if (IS_CONST & (IS_CV|IS_VAR)) {
27720 ZVAL_DEREF(value);
27721 }
27722
27723 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27724
27725 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27726 zend_objects_store_del(obj);
27727 }
27728 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27729 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27730 zend_use_new_element_for_string();
27731
27732 UNDEF_RESULT();
27733 } else {
27734 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27735 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27736 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27737
27738 }
27739 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27740 if (Z_ISREF_P(orig_object_ptr)
27741 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27742 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27743 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27744
27745 UNDEF_RESULT();
27746 } else {
27747 HashTable *ht = zend_new_array(8);
27748 uint8_t old_type = Z_TYPE_P(object_ptr);
27749
27750 ZVAL_ARR(object_ptr, ht);
27751 if (UNEXPECTED(old_type == IS_FALSE)) {
27752 GC_ADDREF(ht);
27753 zend_false_to_array_deprecated();
27754 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27755 zend_array_destroy(ht);
27756 goto assign_dim_error;
27757 }
27758 }
27759 goto try_assign_dim_array;
27760 }
27761 } else {
27762 zend_use_scalar_as_array();
27763 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27764assign_dim_error:
27765
27766 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27767 ZVAL_NULL(EX_VAR(opline->result.var));
27768 }
27769 }
27770 }
27771 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27772 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27773 }
27774 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27775 /* assign_dim has two opcodes! */
27776 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27777}
27778
27779static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27780{
27781 USE_OPLINE
27782 zval *object_ptr, *orig_object_ptr;
27783 zval *value;
27784 zval *variable_ptr;
27785 zval *dim;
27786 zend_refcounted *garbage = NULL;
27787
27788 SAVE_OPLINE();
27789 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27790
27791 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27792try_assign_dim_array:
27793 SEPARATE_ARRAY(object_ptr);
27794 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27795 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27796 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27797 HashTable *ht = Z_ARRVAL_P(object_ptr);
27798 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27799 GC_ADDREF(ht);
27800 }
27801 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27802 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27803 zend_array_destroy(ht);
27804 goto assign_dim_error;
27805 }
27806 }
27807 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27808 ZVAL_DEREF(value);
27809 }
27810 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27811 if (UNEXPECTED(value == NULL)) {
27812 zend_cannot_add_element();
27813 goto assign_dim_error;
27814 } else if (IS_TMP_VAR == IS_CV) {
27815 if (Z_REFCOUNTED_P(value)) {
27816 Z_ADDREF_P(value);
27817 }
27818 } else if (IS_TMP_VAR == IS_VAR) {
27819 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27820 if (Z_ISREF_P(free_op_data)) {
27821 if (Z_REFCOUNTED_P(value)) {
27822 Z_ADDREF_P(value);
27823 }
27824 zval_ptr_dtor_nogc(free_op_data);
27825 }
27826 } else if (IS_TMP_VAR == IS_CONST) {
27827 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27828 Z_ADDREF_P(value);
27829 }
27830 }
27831 } else {
27832 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27833 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27834 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27835 } else {
27836 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27837 }
27838 if (UNEXPECTED(variable_ptr == NULL)) {
27839 goto assign_dim_error;
27840 }
27841 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27842 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
27843 }
27844 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27845 ZVAL_COPY(EX_VAR(opline->result.var), value);
27846 }
27847 if (garbage) {
27848 GC_DTOR_NO_REF(garbage);
27849 }
27850 } else {
27851 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27852 object_ptr = Z_REFVAL_P(object_ptr);
27853 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27854 goto try_assign_dim_array;
27855 }
27856 }
27857 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27858 zend_object *obj = Z_OBJ_P(object_ptr);
27859
27860 GC_ADDREF(obj);
27861 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27862 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27863 dim = ZVAL_UNDEFINED_OP2();
27864 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27865 dim++;
27866 }
27867
27868 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27869 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27870 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27871 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
27872 ZVAL_DEREF(value);
27873 }
27874
27875 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27876
27877 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27878 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27879 zend_objects_store_del(obj);
27880 }
27881 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27882 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27883 zend_use_new_element_for_string();
27884 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27885 UNDEF_RESULT();
27886 } else {
27887 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27888 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27889 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27890 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27891 }
27892 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27893 if (Z_ISREF_P(orig_object_ptr)
27894 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27895 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27896 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27897 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27898 UNDEF_RESULT();
27899 } else {
27900 HashTable *ht = zend_new_array(8);
27901 uint8_t old_type = Z_TYPE_P(object_ptr);
27902
27903 ZVAL_ARR(object_ptr, ht);
27904 if (UNEXPECTED(old_type == IS_FALSE)) {
27905 GC_ADDREF(ht);
27906 zend_false_to_array_deprecated();
27907 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27908 zend_array_destroy(ht);
27909 goto assign_dim_error;
27910 }
27911 }
27912 goto try_assign_dim_array;
27913 }
27914 } else {
27915 zend_use_scalar_as_array();
27916 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27917assign_dim_error:
27918 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27919 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27920 ZVAL_NULL(EX_VAR(opline->result.var));
27921 }
27922 }
27923 }
27924 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27925 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27926 }
27927 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27928 /* assign_dim has two opcodes! */
27929 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27930}
27931
27932static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27933{
27934 USE_OPLINE
27935 zval *object_ptr, *orig_object_ptr;
27936 zval *value;
27937 zval *variable_ptr;
27938 zval *dim;
27939 zend_refcounted *garbage = NULL;
27940
27941 SAVE_OPLINE();
27942 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27943
27944 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27945try_assign_dim_array:
27946 SEPARATE_ARRAY(object_ptr);
27947 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27948 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27949 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27950 HashTable *ht = Z_ARRVAL_P(object_ptr);
27951 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27952 GC_ADDREF(ht);
27953 }
27954 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27955 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27956 zend_array_destroy(ht);
27957 goto assign_dim_error;
27958 }
27959 }
27960 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
27961 ZVAL_DEREF(value);
27962 }
27963 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27964 if (UNEXPECTED(value == NULL)) {
27965 zend_cannot_add_element();
27966 goto assign_dim_error;
27967 } else if (IS_VAR == IS_CV) {
27968 if (Z_REFCOUNTED_P(value)) {
27969 Z_ADDREF_P(value);
27970 }
27971 } else if (IS_VAR == IS_VAR) {
27972 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27973 if (Z_ISREF_P(free_op_data)) {
27974 if (Z_REFCOUNTED_P(value)) {
27975 Z_ADDREF_P(value);
27976 }
27977 zval_ptr_dtor_nogc(free_op_data);
27978 }
27979 } else if (IS_VAR == IS_CONST) {
27980 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27981 Z_ADDREF_P(value);
27982 }
27983 }
27984 } else {
27985 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27986 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27987 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27988 } else {
27989 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27990 }
27991 if (UNEXPECTED(variable_ptr == NULL)) {
27992 goto assign_dim_error;
27993 }
27994 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27995 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
27996 }
27997 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27998 ZVAL_COPY(EX_VAR(opline->result.var), value);
27999 }
28000 if (garbage) {
28001 GC_DTOR_NO_REF(garbage);
28002 }
28003 } else {
28004 if (EXPECTED(Z_ISREF_P(object_ptr))) {
28005 object_ptr = Z_REFVAL_P(object_ptr);
28006 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28007 goto try_assign_dim_array;
28008 }
28009 }
28010 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28011 zend_object *obj = Z_OBJ_P(object_ptr);
28012
28013 GC_ADDREF(obj);
28014 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28015 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28016 dim = ZVAL_UNDEFINED_OP2();
28017 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28018 dim++;
28019 }
28020
28021 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28022 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28023 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28024 } else if (IS_VAR & (IS_CV|IS_VAR)) {
28025 ZVAL_DEREF(value);
28026 }
28027
28028 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28029
28030 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28031 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28032 zend_objects_store_del(obj);
28033 }
28034 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28035 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28036 zend_use_new_element_for_string();
28037 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28038 UNDEF_RESULT();
28039 } else {
28040 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28041 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28042 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28043 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28044 }
28045 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28046 if (Z_ISREF_P(orig_object_ptr)
28047 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28048 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28049 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28050 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28051 UNDEF_RESULT();
28052 } else {
28053 HashTable *ht = zend_new_array(8);
28054 uint8_t old_type = Z_TYPE_P(object_ptr);
28055
28056 ZVAL_ARR(object_ptr, ht);
28057 if (UNEXPECTED(old_type == IS_FALSE)) {
28058 GC_ADDREF(ht);
28059 zend_false_to_array_deprecated();
28060 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28061 zend_array_destroy(ht);
28062 goto assign_dim_error;
28063 }
28064 }
28065 goto try_assign_dim_array;
28066 }
28067 } else {
28068 zend_use_scalar_as_array();
28069 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28070assign_dim_error:
28071 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28072 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28073 ZVAL_NULL(EX_VAR(opline->result.var));
28074 }
28075 }
28076 }
28077 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28078 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28079 }
28080 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28081 /* assign_dim has two opcodes! */
28082 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28083}
28084
28085static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28086{
28087 USE_OPLINE
28088 zval *object_ptr, *orig_object_ptr;
28089 zval *value;
28090 zval *variable_ptr;
28091 zval *dim;
28092 zend_refcounted *garbage = NULL;
28093
28094 SAVE_OPLINE();
28095 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28096
28097 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28098try_assign_dim_array:
28099 SEPARATE_ARRAY(object_ptr);
28100 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28101 value = EX_VAR((opline+1)->op1.var);
28102 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28103 HashTable *ht = Z_ARRVAL_P(object_ptr);
28104 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28105 GC_ADDREF(ht);
28106 }
28107 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28108 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28109 zend_array_destroy(ht);
28110 goto assign_dim_error;
28111 }
28112 }
28113 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
28114 ZVAL_DEREF(value);
28115 }
28116 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28117 if (UNEXPECTED(value == NULL)) {
28118 zend_cannot_add_element();
28119 goto assign_dim_error;
28120 } else if (IS_CV == IS_CV) {
28121 if (Z_REFCOUNTED_P(value)) {
28122 Z_ADDREF_P(value);
28123 }
28124 } else if (IS_CV == IS_VAR) {
28125 zval *free_op_data = EX_VAR((opline+1)->op1.var);
28126 if (Z_ISREF_P(free_op_data)) {
28127 if (Z_REFCOUNTED_P(value)) {
28128 Z_ADDREF_P(value);
28129 }
28130 zval_ptr_dtor_nogc(free_op_data);
28131 }
28132 } else if (IS_CV == IS_CONST) {
28133 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28134 Z_ADDREF_P(value);
28135 }
28136 }
28137 } else {
28138 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28139 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28140 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28141 } else {
28142 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28143 }
28144 if (UNEXPECTED(variable_ptr == NULL)) {
28145 goto assign_dim_error;
28146 }
28147 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
28148 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
28149 }
28150 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28151 ZVAL_COPY(EX_VAR(opline->result.var), value);
28152 }
28153 if (garbage) {
28154 GC_DTOR_NO_REF(garbage);
28155 }
28156 } else {
28157 if (EXPECTED(Z_ISREF_P(object_ptr))) {
28158 object_ptr = Z_REFVAL_P(object_ptr);
28159 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28160 goto try_assign_dim_array;
28161 }
28162 }
28163 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28164 zend_object *obj = Z_OBJ_P(object_ptr);
28165
28166 GC_ADDREF(obj);
28167 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28168 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28169 dim = ZVAL_UNDEFINED_OP2();
28170 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28171 dim++;
28172 }
28173
28174 value = EX_VAR((opline+1)->op1.var);
28175 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28176 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28177 } else if (IS_CV & (IS_CV|IS_VAR)) {
28178 ZVAL_DEREF(value);
28179 }
28180
28181 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28182
28183 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28184 zend_objects_store_del(obj);
28185 }
28186 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28187 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28188 zend_use_new_element_for_string();
28189
28190 UNDEF_RESULT();
28191 } else {
28192 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28193 value = EX_VAR((opline+1)->op1.var);
28194 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28195
28196 }
28197 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28198 if (Z_ISREF_P(orig_object_ptr)
28199 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28200 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28201 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28202
28203 UNDEF_RESULT();
28204 } else {
28205 HashTable *ht = zend_new_array(8);
28206 uint8_t old_type = Z_TYPE_P(object_ptr);
28207
28208 ZVAL_ARR(object_ptr, ht);
28209 if (UNEXPECTED(old_type == IS_FALSE)) {
28210 GC_ADDREF(ht);
28211 zend_false_to_array_deprecated();
28212 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28213 zend_array_destroy(ht);
28214 goto assign_dim_error;
28215 }
28216 }
28217 goto try_assign_dim_array;
28218 }
28219 } else {
28220 zend_use_scalar_as_array();
28221 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28222assign_dim_error:
28223
28224 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28225 ZVAL_NULL(EX_VAR(opline->result.var));
28226 }
28227 }
28228 }
28229 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28230 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28231 }
28232 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28233 /* assign_dim has two opcodes! */
28234 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28235}
28236
28237static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28238{
28239 USE_OPLINE
28240 zval *property, *container, *value_ptr;
28241
28242 SAVE_OPLINE();
28243
28244 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28245 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28246
28247 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28248
28249 if (1) {
28250 if (IS_VAR == IS_UNUSED) {
28251 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28252 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28253 } else {
28254 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28255 }
28256 } else {
28257 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28258 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28259 } else {
28260 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28261 }
28262 }
28263 } else {
28264 zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
28265 }
28266
28267 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28268 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28269 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28270 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28271}
28272
28273/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
28274static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28275{
28276 USE_OPLINE
28277 zval *property, *container, *value_ptr;
28278
28279 SAVE_OPLINE();
28280
28281 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28282 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28283
28284 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
28285
28286 if (1) {
28287 if (IS_VAR == IS_UNUSED) {
28288 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28289 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28290 } else {
28291 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28292 }
28293 } else {
28294 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28295 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28296 } else {
28297 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28298 }
28299 }
28300 } else {
28301 zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
28302 }
28303
28304 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28305 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28306
28307 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28308}
28309
28310/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
28311static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28312{
28313 USE_OPLINE
28314 zval *function_name;
28315 zend_class_entry *ce;
28316 uint32_t call_info;
28317 zend_function *fbc;
28318 zend_execute_data *call;
28319
28320 SAVE_OPLINE();
28321
28322 if (IS_VAR == IS_CONST) {
28323 /* no function found. try a static method in class */
28324 ce = CACHED_PTR(opline->result.num);
28325 if (UNEXPECTED(ce == NULL)) {
28326 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);
28327 if (UNEXPECTED(ce == NULL)) {
28328 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28329 HANDLE_EXCEPTION();
28330 }
28331 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28332 CACHE_PTR(opline->result.num, ce);
28333 }
28334 }
28335 } else if (IS_VAR == IS_UNUSED) {
28336 ce = zend_fetch_class(NULL, opline->op1.num);
28337 if (UNEXPECTED(ce == NULL)) {
28338 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28339 HANDLE_EXCEPTION();
28340 }
28341 } else {
28342 ce = Z_CE_P(EX_VAR(opline->op1.var));
28343 }
28344
28345 if (IS_VAR == IS_CONST &&
28346 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
28347 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
28348 /* nothing to do */
28349 } else if (IS_VAR != IS_CONST &&
28350 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
28351 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
28352 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
28353 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28354 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28355 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28356 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
28357 do {
28358 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
28359 function_name = Z_REFVAL_P(function_name);
28360 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
28361 break;
28362 }
28363 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
28364 ZVAL_UNDEFINED_OP2();
28365 if (UNEXPECTED(EG(exception) != NULL)) {
28366 HANDLE_EXCEPTION();
28367 }
28368 }
28369 zend_throw_error(NULL, "Method name must be a string");
28370 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28371 HANDLE_EXCEPTION();
28372 } while (0);
28373 }
28374 }
28375
28376 if (ce->get_static_method) {
28377 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
28378 } else {
28379 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));
28380 }
28381 if (UNEXPECTED(fbc == NULL)) {
28382 if (EXPECTED(!EG(exception))) {
28383 zend_undefined_method(ce, Z_STR_P(function_name));
28384 }
28385 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28386 HANDLE_EXCEPTION();
28387 }
28388 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
28389 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
28390 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
28391 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
28392 }
28393 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
28394 init_func_run_time_cache(&fbc->op_array);
28395 }
28396 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28397 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28398 }
28399 } else {
28400 if (UNEXPECTED(ce->constructor == NULL)) {
28401 zend_throw_error(NULL, "Cannot call constructor");
28402 HANDLE_EXCEPTION();
28403 }
28404 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
28405 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
28406 HANDLE_EXCEPTION();
28407 }
28408 fbc = ce->constructor;
28409 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
28410 init_func_run_time_cache(&fbc->op_array);
28411 }
28412 }
28413
28414 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
28415 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
28416 ce = (zend_class_entry*)Z_OBJ(EX(This));
28417 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
28418 } else {
28419 zend_non_static_method_call(fbc);
28420 HANDLE_EXCEPTION();
28421 }
28422 } else {
28423 /* previous opcode is ZEND_FETCH_CLASS */
28424 if (IS_VAR == IS_UNUSED
28425 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
28426 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
28427 if (Z_TYPE(EX(This)) == IS_OBJECT) {
28428 ce = Z_OBJCE(EX(This));
28429 } else {
28430 ce = Z_CE(EX(This));
28431 }
28432 }
28433 call_info = ZEND_CALL_NESTED_FUNCTION;
28434 }
28435
28436 call = zend_vm_stack_push_call_frame(call_info,
28437 fbc, opline->extended_value, ce);
28438 call->prev_execute_data = EX(call);
28439 EX(call) = call;
28440
28441 ZEND_VM_NEXT_OPCODE();
28442}
28443
28444static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28445{
28446 USE_OPLINE
28447 zval *expr_ptr, new_expr;
28448
28449 SAVE_OPLINE();
28450 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
28451 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
28452 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28453 if (Z_ISREF_P(expr_ptr)) {
28454 Z_ADDREF_P(expr_ptr);
28455 } else {
28456 ZVAL_MAKE_REF_EX(expr_ptr, 2);
28457 }
28458 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28459 } else {
28460 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28461 if (IS_VAR == IS_TMP_VAR) {
28462 /* pass */
28463 } else if (IS_VAR == IS_CONST) {
28464 Z_TRY_ADDREF_P(expr_ptr);
28465 } else if (IS_VAR == IS_CV) {
28466 ZVAL_DEREF(expr_ptr);
28467 Z_TRY_ADDREF_P(expr_ptr);
28468 } else /* if (IS_VAR == IS_VAR) */ {
28469 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
28470 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
28471
28472 expr_ptr = Z_REFVAL_P(expr_ptr);
28473 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
28474 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
28475 expr_ptr = &new_expr;
28476 efree_size(ref, sizeof(zend_reference));
28477 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
28478 Z_ADDREF_P(expr_ptr);
28479 }
28480 }
28481 }
28482 }
28483
28484 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28485 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28486 zend_string *str;
28487 zend_ulong hval;
28488
28489add_again:
28490 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
28491 str = Z_STR_P(offset);
28492 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28493 if (ZEND_HANDLE_NUMERIC(str, hval)) {
28494 goto num_index;
28495 }
28496 }
28497str_index:
28498 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
28499 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
28500 hval = Z_LVAL_P(offset);
28501num_index:
28502 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
28503 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
28504 offset = Z_REFVAL_P(offset);
28505 goto add_again;
28506 } else if (Z_TYPE_P(offset) == IS_NULL) {
28507 str = ZSTR_EMPTY_ALLOC();
28508 goto str_index;
28509 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
28510 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
28511 goto num_index;
28512 } else if (Z_TYPE_P(offset) == IS_FALSE) {
28513 hval = 0;
28514 goto num_index;
28515 } else if (Z_TYPE_P(offset) == IS_TRUE) {
28516 hval = 1;
28517 goto num_index;
28518 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
28519 zend_use_resource_as_offset(offset);
28520 hval = Z_RES_HANDLE_P(offset);
28521 goto num_index;
28522 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
28523 ZVAL_UNDEFINED_OP2();
28524 str = ZSTR_EMPTY_ALLOC();
28525 goto str_index;
28526 } else {
28527 zend_illegal_array_offset_access(offset);
28528 zval_ptr_dtor_nogc(expr_ptr);
28529 }
28530 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28531 } else {
28532 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
28533 zend_cannot_add_element();
28534 zval_ptr_dtor_nogc(expr_ptr);
28535 }
28536 }
28537 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28538}
28539
28540static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28541{
28542 zval *array;
28543 uint32_t size;
28544 USE_OPLINE
28545
28546 SAVE_OPLINE();
28547 array = EX_VAR(opline->result.var);
28548 if (IS_VAR != IS_UNUSED) {
28549 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
28550 ZVAL_ARR(array, zend_new_array(size));
28551 /* Explicitly initialize array as not-packed if flag is set */
28552 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
28553 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
28554 }
28555 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28556 } else {
28557 ZVAL_ARR(array, zend_new_array(0));
28558 ZEND_VM_NEXT_OPCODE();
28559 }
28560}
28561
28562static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28563{
28564 USE_OPLINE
28565 zval *container;
28566 zval *offset;
28567 zend_ulong hval;
28568 zend_string *key;
28569
28570 SAVE_OPLINE();
28571 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28572 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28573
28574 do {
28575 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28576 HashTable *ht;
28577
28578unset_dim_array:
28579 SEPARATE_ARRAY(container);
28580 ht = Z_ARRVAL_P(container);
28581offset_again:
28582 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
28583 key = Z_STR_P(offset);
28584 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28585 if (ZEND_HANDLE_NUMERIC(key, hval)) {
28586 goto num_index_dim;
28587 }
28588 }
28589str_index_dim:
28590 ZEND_ASSERT(ht != &EG(symbol_table));
28591 zend_hash_del(ht, key);
28592 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
28593 hval = Z_LVAL_P(offset);
28594num_index_dim:
28595 zend_hash_index_del(ht, hval);
28596 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
28597 offset = Z_REFVAL_P(offset);
28598 goto offset_again;
28599 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
28600 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
28601 goto num_index_dim;
28602 } else if (Z_TYPE_P(offset) == IS_NULL) {
28603 key = ZSTR_EMPTY_ALLOC();
28604 goto str_index_dim;
28605 } else if (Z_TYPE_P(offset) == IS_FALSE) {
28606 hval = 0;
28607 goto num_index_dim;
28608 } else if (Z_TYPE_P(offset) == IS_TRUE) {
28609 hval = 1;
28610 goto num_index_dim;
28611 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
28612 zend_use_resource_as_offset(offset);
28613 hval = Z_RES_HANDLE_P(offset);
28614 goto num_index_dim;
28615 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
28616 ZVAL_UNDEFINED_OP2();
28617 key = ZSTR_EMPTY_ALLOC();
28618 goto str_index_dim;
28619 } else {
28620 zend_illegal_array_offset_unset(offset);
28621 }
28622 break;
28623 } else if (Z_ISREF_P(container)) {
28624 container = Z_REFVAL_P(container);
28625 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28626 goto unset_dim_array;
28627 }
28628 }
28629 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
28630 container = ZVAL_UNDEFINED_OP1();
28631 }
28632 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
28633 offset = ZVAL_UNDEFINED_OP2();
28634 }
28635 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
28636 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
28637 offset++;
28638 }
28639 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
28640 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
28641 zend_throw_error(NULL, "Cannot unset string offsets");
28642 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
28643 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
28644 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
28645 zend_false_to_array_deprecated();
28646 }
28647 } while (0);
28648
28649 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28650 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28651 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28652}
28653
28654static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28655{
28656 USE_OPLINE
28657 zval *container;
28658 zval *offset;
28659 zend_string *name, *tmp_name;
28660
28661 SAVE_OPLINE();
28662 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28663 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28664
28665 do {
28666 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
28667 if (Z_ISREF_P(container)) {
28668 container = Z_REFVAL_P(container);
28669 if (Z_TYPE_P(container) != IS_OBJECT) {
28670 if (IS_VAR == IS_CV
28671 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
28672 ZVAL_UNDEFINED_OP1();
28673 }
28674 break;
28675 }
28676 } else {
28677 break;
28678 }
28679 }
28680 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28681 name = Z_STR_P(offset);
28682 } else {
28683 name = zval_try_get_tmp_string(offset, &tmp_name);
28684 if (UNEXPECTED(!name)) {
28685 break;
28686 }
28687 }
28688 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));
28689 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28690 zend_tmp_string_release(tmp_name);
28691 }
28692 } while (0);
28693
28694 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28695 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28696 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28697}
28698
28699static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28700{
28701 USE_OPLINE
28702
28703 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
28704
28705 SAVE_OPLINE();
28706 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
28707 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28708 }
28709
28710 /* Destroy the previously yielded value */
28711 zval_ptr_dtor(&generator->value);
28712
28713 /* Destroy the previously yielded key */
28714 zval_ptr_dtor(&generator->key);
28715
28716 /* Set the new yielded value */
28717 if (IS_VAR != IS_UNUSED) {
28718 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
28719 /* Constants and temporary variables aren't yieldable by reference,
28720 * but we still allow them with a notice. */
28721 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
28722 zval *value;
28723
28724 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28725
28726 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28727 ZVAL_COPY_VALUE(&generator->value, value);
28728 if (IS_VAR == IS_CONST) {
28729 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28730 Z_ADDREF(generator->value);
28731 }
28732 }
28733 } else {
28734 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28735
28736 /* If a function call result is yielded and the function did
28737 * not return by reference we throw a notice. */
28738 do {
28739 if (IS_VAR == IS_VAR) {
28740 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
28741 if (opline->extended_value == ZEND_RETURNS_FUNCTION
28742 && !Z_ISREF_P(value_ptr)) {
28743 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28744 ZVAL_COPY(&generator->value, value_ptr);
28745 break;
28746 }
28747 }
28748 if (Z_ISREF_P(value_ptr)) {
28749 Z_ADDREF_P(value_ptr);
28750 } else {
28751 ZVAL_MAKE_REF_EX(value_ptr, 2);
28752 }
28753 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
28754 } while (0);
28755
28756 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28757 }
28758 } else {
28759 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28760
28761 /* Consts, temporary variables and references need copying */
28762 if (IS_VAR == IS_CONST) {
28763 ZVAL_COPY_VALUE(&generator->value, value);
28764 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28765 Z_ADDREF(generator->value);
28766 }
28767 } else if (IS_VAR == IS_TMP_VAR) {
28768 ZVAL_COPY_VALUE(&generator->value, value);
28769 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
28770 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
28771 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28772 } else {
28773 ZVAL_COPY_VALUE(&generator->value, value);
28774 if (IS_VAR == IS_CV) {
28775 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
28776 }
28777 }
28778 }
28779 } else {
28780 /* If no value was specified yield null */
28781 ZVAL_NULL(&generator->value);
28782 }
28783
28784 /* Set the new yielded key */
28785 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28786 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28787 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
28788 key = Z_REFVAL_P(key);
28789 }
28790 ZVAL_COPY(&generator->key, key);
28791 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28792
28793 if (Z_TYPE(generator->key) == IS_LONG
28794 && Z_LVAL(generator->key) > generator->largest_used_integer_key
28795 ) {
28796 generator->largest_used_integer_key = Z_LVAL(generator->key);
28797 }
28798 } else {
28799 /* If no key was specified we use auto-increment keys */
28800 generator->largest_used_integer_key++;
28801 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
28802 }
28803
28804 if (RETURN_VALUE_USED(opline)) {
28805 /* If the return value of yield is used set the send
28806 * target and initialize it to NULL */
28807 generator->send_target = EX_VAR(opline->result.var);
28808 ZVAL_NULL(generator->send_target);
28809 } else {
28810 generator->send_target = NULL;
28811 }
28812
28813 /* The GOTO VM uses a local opline variable. We need to set the opline
28814 * variable in execute_data so we don't resume at an old position. */
28815 SAVE_OPLINE();
28816
28817 ZEND_VM_RETURN();
28818}
28819
28820static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28821{
28822 USE_OPLINE
28823 zval *op1, *op2;
28824 bool result;
28825
28826 SAVE_OPLINE();
28827 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28828 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28829 result = fast_is_identical_function(op1, op2);
28830 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28831 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28832 ZEND_VM_SMART_BRANCH(result, 1);
28833}
28834
28835static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28836{
28837 USE_OPLINE
28838 zval *op1, *op2;
28839 bool result;
28840
28841 SAVE_OPLINE();
28842 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28843 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28844 result = fast_is_identical_function(op1, op2);
28845 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28846 ZEND_VM_SMART_BRANCH(result, 1);
28847}
28848
28849static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28850{
28851 USE_OPLINE
28852 zval *op1, *op2;
28853 bool result;
28854
28855 SAVE_OPLINE();
28856 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28857 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28858 result = fast_is_not_identical_function(op1, op2);
28859 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28860 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28861 ZEND_VM_SMART_BRANCH(result, 1);
28862}
28863
28864static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28865{
28866 USE_OPLINE
28867 zval *value;
28868 zval *variable_ptr;
28869
28870 SAVE_OPLINE();
28871 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28872 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28873
28874 if (0 || UNEXPECTED(0)) {
28875 zend_refcounted *garbage = NULL;
28876
28877 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28878 if (UNEXPECTED(0)) {
28879 ZVAL_COPY(EX_VAR(opline->result.var), value);
28880 }
28881 if (garbage) {
28882 GC_DTOR_NO_REF(garbage);
28883 }
28884 } else {
28885 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
28886 }
28887 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28888 /* zend_assign_to_variable() always takes care of op2, never free it! */
28889
28890 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28891}
28892
28893static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28894{
28895 USE_OPLINE
28896 zval *value;
28897 zval *variable_ptr;
28898
28899 SAVE_OPLINE();
28900 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28901 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28902
28903 if (0 || UNEXPECTED(1)) {
28904 zend_refcounted *garbage = NULL;
28905
28906 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28907 if (UNEXPECTED(1)) {
28908 ZVAL_COPY(EX_VAR(opline->result.var), value);
28909 }
28910 if (garbage) {
28911 GC_DTOR_NO_REF(garbage);
28912 }
28913 } else {
28914 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
28915 }
28916 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28917 /* zend_assign_to_variable() always takes care of op2, never free it! */
28918
28919 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28920}
28921
28922static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28923{
28924 USE_OPLINE
28925 zval *op1, *op2;
28926 bool result;
28927
28928 SAVE_OPLINE();
28929 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28930 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28931 result = fast_is_identical_function(op1, op2);
28932 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28933 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28934 ZEND_VM_SMART_BRANCH(result, 1);
28935}
28936
28937static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28938{
28939 USE_OPLINE
28940 zval *op1, *op2;
28941 bool result;
28942
28943 SAVE_OPLINE();
28944 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28945 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28946 result = fast_is_identical_function(op1, op2);
28947 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28948 ZEND_VM_SMART_BRANCH(result, 1);
28949}
28950
28951static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28952{
28953 USE_OPLINE
28954 zval *op1, *op2;
28955 bool result;
28956
28957 SAVE_OPLINE();
28958 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28959 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28960 result = fast_is_not_identical_function(op1, op2);
28961 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28962 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28963 ZEND_VM_SMART_BRANCH(result, 1);
28964}
28965
28966static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28967{
28968 USE_OPLINE
28969 zval *value;
28970 zval *variable_ptr;
28971
28972 SAVE_OPLINE();
28973 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28974 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28975
28976 if (0 || UNEXPECTED(0)) {
28977 zend_refcounted *garbage = NULL;
28978
28979 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
28980 if (UNEXPECTED(0)) {
28981 ZVAL_COPY(EX_VAR(opline->result.var), value);
28982 }
28983 if (garbage) {
28984 GC_DTOR_NO_REF(garbage);
28985 }
28986 } else {
28987 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
28988 }
28989 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28990 /* zend_assign_to_variable() always takes care of op2, never free it! */
28991
28992 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28993}
28994
28995static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28996{
28997 USE_OPLINE
28998 zval *value;
28999 zval *variable_ptr;
29000
29001 SAVE_OPLINE();
29002 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
29003 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29004
29005 if (0 || UNEXPECTED(1)) {
29006 zend_refcounted *garbage = NULL;
29007
29008 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
29009 if (UNEXPECTED(1)) {
29010 ZVAL_COPY(EX_VAR(opline->result.var), value);
29011 }
29012 if (garbage) {
29013 GC_DTOR_NO_REF(garbage);
29014 }
29015 } else {
29016 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
29017 }
29018 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29019 /* zend_assign_to_variable() always takes care of op2, never free it! */
29020
29021 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29022}
29023
29024static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29025{
29026 USE_OPLINE
29027 zval *variable_ptr;
29028 zval *value_ptr;
29029 zend_refcounted *garbage = NULL;
29030
29031 SAVE_OPLINE();
29032 value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
29033 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29034
29035 if (IS_VAR == IS_VAR &&
29036 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
29037
29038 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
29039 variable_ptr = &EG(uninitialized_zval);
29040 } else if (IS_VAR == IS_VAR &&
29041 opline->extended_value == ZEND_RETURNS_FUNCTION &&
29042 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
29043
29044 variable_ptr = zend_wrong_assign_to_variable_reference(
29045 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
29046 } else {
29047 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
29048 }
29049
29050 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29051 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
29052 }
29053
29054 if (garbage) {
29055 GC_DTOR(garbage);
29056 }
29057
29058 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
29059 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29060 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29061}
29062
29063static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29064{
29065 USE_OPLINE
29066 zval *var_ptr;
29067 zval *value, *container, *dim;
29068 HashTable *ht;
29069
29070 SAVE_OPLINE();
29071 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29072
29073 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
29074assign_dim_op_array:
29075 SEPARATE_ARRAY(container);
29076 ht = Z_ARRVAL_P(container);
29077assign_dim_op_new_array:
29078 dim = NULL;
29079 if (IS_UNUSED == IS_UNUSED) {
29080 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
29081 if (UNEXPECTED(!var_ptr)) {
29082 zend_cannot_add_element();
29083 goto assign_dim_op_ret_null;
29084 }
29085 } else {
29086 if (IS_UNUSED == IS_CONST) {
29087 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
29088 } else {
29089 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
29090 }
29091 if (UNEXPECTED(!var_ptr)) {
29092 goto assign_dim_op_ret_null;
29093 }
29094 }
29095
29096 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
29097
29098 do {
29099 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
29100 zend_reference *ref = Z_REF_P(var_ptr);
29101 var_ptr = Z_REFVAL_P(var_ptr);
29102 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
29103 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
29104 break;
29105 }
29106 }
29107 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
29108 } while (0);
29109
29110 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29111 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
29112 }
29113 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
29114 } else {
29115 if (EXPECTED(Z_ISREF_P(container))) {
29116 container = Z_REFVAL_P(container);
29117 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
29118 goto assign_dim_op_array;
29119 }
29120 }
29121
29122 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
29123 zend_object *obj = Z_OBJ_P(container);
29124
29125 dim = NULL;
29126 if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29127 dim++;
29128 }
29129 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
29130 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
29131 uint8_t old_type;
29132
29133 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
29134 ZVAL_UNDEFINED_OP1();
29135 }
29136 ht = zend_new_array(8);
29137 old_type = Z_TYPE_P(container);
29138 ZVAL_ARR(container, ht);
29139 if (UNEXPECTED(old_type == IS_FALSE)) {
29140 GC_ADDREF(ht);
29141 zend_false_to_array_deprecated();
29142 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29143 zend_array_destroy(ht);
29144 goto assign_dim_op_ret_null;
29145 }
29146 }
29147 goto assign_dim_op_new_array;
29148 } else {
29149 dim = NULL;
29150 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
29151assign_dim_op_ret_null:
29152 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
29153 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29154 ZVAL_NULL(EX_VAR(opline->result.var));
29155 }
29156 }
29157 }
29158
29159 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29160 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29161}
29162
29163static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29164{
29165 USE_OPLINE
29166 zval *container;
29167
29168 SAVE_OPLINE();
29169 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29170 zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
29171
29172 if (IS_VAR == IS_VAR) {
29173 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
29174 }
29175 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29176}
29177
29178static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29179{
29180 USE_OPLINE
29181 zval *container;
29182
29183 SAVE_OPLINE();
29184 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29185 zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
29186
29187 if (IS_VAR == IS_VAR) {
29188 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
29189 }
29190 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29191}
29192
29193static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29194{
29195#if 0
29196 USE_OPLINE
29197#endif
29198
29199 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
29200 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
29201 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29202 }
29203 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29204 } else {
29205 if (IS_UNUSED == IS_UNUSED) {
29206 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29207 }
29208 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29209 }
29210}
29211
29212static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29213{
29214 USE_OPLINE
29215 zval *object_ptr, *orig_object_ptr;
29216 zval *value;
29217 zval *variable_ptr;
29218 zval *dim;
29219 zend_refcounted *garbage = NULL;
29220
29221 SAVE_OPLINE();
29222 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29223
29224 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29225try_assign_dim_array:
29226 SEPARATE_ARRAY(object_ptr);
29227 if (IS_UNUSED == IS_UNUSED) {
29228 value = RT_CONSTANT((opline+1), (opline+1)->op1);
29229 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29230 HashTable *ht = Z_ARRVAL_P(object_ptr);
29231 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29232 GC_ADDREF(ht);
29233 }
29234 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29235 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29236 zend_array_destroy(ht);
29237 goto assign_dim_error;
29238 }
29239 }
29240 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
29241 ZVAL_DEREF(value);
29242 }
29243 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29244 if (UNEXPECTED(value == NULL)) {
29245 zend_cannot_add_element();
29246 goto assign_dim_error;
29247 } else if (IS_CONST == IS_CV) {
29248 if (Z_REFCOUNTED_P(value)) {
29249 Z_ADDREF_P(value);
29250 }
29251 } else if (IS_CONST == IS_VAR) {
29252 zval *free_op_data = EX_VAR((opline+1)->op1.var);
29253 if (Z_ISREF_P(free_op_data)) {
29254 if (Z_REFCOUNTED_P(value)) {
29255 Z_ADDREF_P(value);
29256 }
29257 zval_ptr_dtor_nogc(free_op_data);
29258 }
29259 } else if (IS_CONST == IS_CONST) {
29260 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29261 Z_ADDREF_P(value);
29262 }
29263 }
29264 } else {
29265 dim = NULL;
29266 if (IS_UNUSED == IS_CONST) {
29267 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29268 } else {
29269 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29270 }
29271 if (UNEXPECTED(variable_ptr == NULL)) {
29272 goto assign_dim_error;
29273 }
29274 value = RT_CONSTANT((opline+1), (opline+1)->op1);
29275 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
29276 }
29277 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29278 ZVAL_COPY(EX_VAR(opline->result.var), value);
29279 }
29280 if (garbage) {
29281 GC_DTOR_NO_REF(garbage);
29282 }
29283 } else {
29284 if (EXPECTED(Z_ISREF_P(object_ptr))) {
29285 object_ptr = Z_REFVAL_P(object_ptr);
29286 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29287 goto try_assign_dim_array;
29288 }
29289 }
29290 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29291 zend_object *obj = Z_OBJ_P(object_ptr);
29292
29293 GC_ADDREF(obj);
29294 dim = NULL;
29295 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29296 dim = ZVAL_UNDEFINED_OP2();
29297 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29298 dim++;
29299 }
29300
29301 value = RT_CONSTANT((opline+1), (opline+1)->op1);
29302 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29303 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29304 } else if (IS_CONST & (IS_CV|IS_VAR)) {
29305 ZVAL_DEREF(value);
29306 }
29307
29308 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29309
29310 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29311 zend_objects_store_del(obj);
29312 }
29313 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29314 if (IS_UNUSED == IS_UNUSED) {
29315 zend_use_new_element_for_string();
29316
29317 UNDEF_RESULT();
29318 } else {
29319 dim = NULL;
29320 value = RT_CONSTANT((opline+1), (opline+1)->op1);
29321 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29322
29323 }
29324 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29325 if (Z_ISREF_P(orig_object_ptr)
29326 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29327 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29328 dim = NULL;
29329
29330 UNDEF_RESULT();
29331 } else {
29332 HashTable *ht = zend_new_array(8);
29333 uint8_t old_type = Z_TYPE_P(object_ptr);
29334
29335 ZVAL_ARR(object_ptr, ht);
29336 if (UNEXPECTED(old_type == IS_FALSE)) {
29337 GC_ADDREF(ht);
29338 zend_false_to_array_deprecated();
29339 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29340 zend_array_destroy(ht);
29341 goto assign_dim_error;
29342 }
29343 }
29344 goto try_assign_dim_array;
29345 }
29346 } else {
29347 zend_use_scalar_as_array();
29348 dim = NULL;
29349assign_dim_error:
29350
29351 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29352 ZVAL_NULL(EX_VAR(opline->result.var));
29353 }
29354 }
29355 }
29356 if (IS_UNUSED != IS_UNUSED) {
29357
29358 }
29359 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29360 /* assign_dim has two opcodes! */
29361 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29362}
29363
29364static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29365{
29366 USE_OPLINE
29367 zval *object_ptr, *orig_object_ptr;
29368 zval *value;
29369 zval *variable_ptr;
29370 zval *dim;
29371 zend_refcounted *garbage = NULL;
29372
29373 SAVE_OPLINE();
29374 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29375
29376 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29377try_assign_dim_array:
29378 SEPARATE_ARRAY(object_ptr);
29379 if (IS_UNUSED == IS_UNUSED) {
29380 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29381 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29382 HashTable *ht = Z_ARRVAL_P(object_ptr);
29383 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29384 GC_ADDREF(ht);
29385 }
29386 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29387 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29388 zend_array_destroy(ht);
29389 goto assign_dim_error;
29390 }
29391 }
29392 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
29393 ZVAL_DEREF(value);
29394 }
29395 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29396 if (UNEXPECTED(value == NULL)) {
29397 zend_cannot_add_element();
29398 goto assign_dim_error;
29399 } else if (IS_TMP_VAR == IS_CV) {
29400 if (Z_REFCOUNTED_P(value)) {
29401 Z_ADDREF_P(value);
29402 }
29403 } else if (IS_TMP_VAR == IS_VAR) {
29404 zval *free_op_data = EX_VAR((opline+1)->op1.var);
29405 if (Z_ISREF_P(free_op_data)) {
29406 if (Z_REFCOUNTED_P(value)) {
29407 Z_ADDREF_P(value);
29408 }
29409 zval_ptr_dtor_nogc(free_op_data);
29410 }
29411 } else if (IS_TMP_VAR == IS_CONST) {
29412 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29413 Z_ADDREF_P(value);
29414 }
29415 }
29416 } else {
29417 dim = NULL;
29418 if (IS_UNUSED == IS_CONST) {
29419 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29420 } else {
29421 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29422 }
29423 if (UNEXPECTED(variable_ptr == NULL)) {
29424 goto assign_dim_error;
29425 }
29426 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29427 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
29428 }
29429 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29430 ZVAL_COPY(EX_VAR(opline->result.var), value);
29431 }
29432 if (garbage) {
29433 GC_DTOR_NO_REF(garbage);
29434 }
29435 } else {
29436 if (EXPECTED(Z_ISREF_P(object_ptr))) {
29437 object_ptr = Z_REFVAL_P(object_ptr);
29438 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29439 goto try_assign_dim_array;
29440 }
29441 }
29442 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29443 zend_object *obj = Z_OBJ_P(object_ptr);
29444
29445 GC_ADDREF(obj);
29446 dim = NULL;
29447 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29448 dim = ZVAL_UNDEFINED_OP2();
29449 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29450 dim++;
29451 }
29452
29453 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29454 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29455 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29456 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
29457 ZVAL_DEREF(value);
29458 }
29459
29460 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29461
29462 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29463 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29464 zend_objects_store_del(obj);
29465 }
29466 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29467 if (IS_UNUSED == IS_UNUSED) {
29468 zend_use_new_element_for_string();
29469 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29470 UNDEF_RESULT();
29471 } else {
29472 dim = NULL;
29473 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29474 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29475 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29476 }
29477 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29478 if (Z_ISREF_P(orig_object_ptr)
29479 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29480 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29481 dim = NULL;
29482 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29483 UNDEF_RESULT();
29484 } else {
29485 HashTable *ht = zend_new_array(8);
29486 uint8_t old_type = Z_TYPE_P(object_ptr);
29487
29488 ZVAL_ARR(object_ptr, ht);
29489 if (UNEXPECTED(old_type == IS_FALSE)) {
29490 GC_ADDREF(ht);
29491 zend_false_to_array_deprecated();
29492 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29493 zend_array_destroy(ht);
29494 goto assign_dim_error;
29495 }
29496 }
29497 goto try_assign_dim_array;
29498 }
29499 } else {
29500 zend_use_scalar_as_array();
29501 dim = NULL;
29502assign_dim_error:
29503 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29504 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29505 ZVAL_NULL(EX_VAR(opline->result.var));
29506 }
29507 }
29508 }
29509 if (IS_UNUSED != IS_UNUSED) {
29510
29511 }
29512 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29513 /* assign_dim has two opcodes! */
29514 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29515}
29516
29517static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29518{
29519 USE_OPLINE
29520 zval *object_ptr, *orig_object_ptr;
29521 zval *value;
29522 zval *variable_ptr;
29523 zval *dim;
29524 zend_refcounted *garbage = NULL;
29525
29526 SAVE_OPLINE();
29527 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29528
29529 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29530try_assign_dim_array:
29531 SEPARATE_ARRAY(object_ptr);
29532 if (IS_UNUSED == IS_UNUSED) {
29533 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29534 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29535 HashTable *ht = Z_ARRVAL_P(object_ptr);
29536 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29537 GC_ADDREF(ht);
29538 }
29539 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29540 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29541 zend_array_destroy(ht);
29542 goto assign_dim_error;
29543 }
29544 }
29545 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
29546 ZVAL_DEREF(value);
29547 }
29548 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29549 if (UNEXPECTED(value == NULL)) {
29550 zend_cannot_add_element();
29551 goto assign_dim_error;
29552 } else if (IS_VAR == IS_CV) {
29553 if (Z_REFCOUNTED_P(value)) {
29554 Z_ADDREF_P(value);
29555 }
29556 } else if (IS_VAR == IS_VAR) {
29557 zval *free_op_data = EX_VAR((opline+1)->op1.var);
29558 if (Z_ISREF_P(free_op_data)) {
29559 if (Z_REFCOUNTED_P(value)) {
29560 Z_ADDREF_P(value);
29561 }
29562 zval_ptr_dtor_nogc(free_op_data);
29563 }
29564 } else if (IS_VAR == IS_CONST) {
29565 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29566 Z_ADDREF_P(value);
29567 }
29568 }
29569 } else {
29570 dim = NULL;
29571 if (IS_UNUSED == IS_CONST) {
29572 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29573 } else {
29574 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29575 }
29576 if (UNEXPECTED(variable_ptr == NULL)) {
29577 goto assign_dim_error;
29578 }
29579 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29580 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
29581 }
29582 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29583 ZVAL_COPY(EX_VAR(opline->result.var), value);
29584 }
29585 if (garbage) {
29586 GC_DTOR_NO_REF(garbage);
29587 }
29588 } else {
29589 if (EXPECTED(Z_ISREF_P(object_ptr))) {
29590 object_ptr = Z_REFVAL_P(object_ptr);
29591 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29592 goto try_assign_dim_array;
29593 }
29594 }
29595 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29596 zend_object *obj = Z_OBJ_P(object_ptr);
29597
29598 GC_ADDREF(obj);
29599 dim = NULL;
29600 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29601 dim = ZVAL_UNDEFINED_OP2();
29602 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29603 dim++;
29604 }
29605
29606 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29607 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29608 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29609 } else if (IS_VAR & (IS_CV|IS_VAR)) {
29610 ZVAL_DEREF(value);
29611 }
29612
29613 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29614
29615 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29616 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29617 zend_objects_store_del(obj);
29618 }
29619 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29620 if (IS_UNUSED == IS_UNUSED) {
29621 zend_use_new_element_for_string();
29622 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29623 UNDEF_RESULT();
29624 } else {
29625 dim = NULL;
29626 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29627 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29628 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29629 }
29630 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29631 if (Z_ISREF_P(orig_object_ptr)
29632 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29633 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29634 dim = NULL;
29635 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29636 UNDEF_RESULT();
29637 } else {
29638 HashTable *ht = zend_new_array(8);
29639 uint8_t old_type = Z_TYPE_P(object_ptr);
29640
29641 ZVAL_ARR(object_ptr, ht);
29642 if (UNEXPECTED(old_type == IS_FALSE)) {
29643 GC_ADDREF(ht);
29644 zend_false_to_array_deprecated();
29645 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29646 zend_array_destroy(ht);
29647 goto assign_dim_error;
29648 }
29649 }
29650 goto try_assign_dim_array;
29651 }
29652 } else {
29653 zend_use_scalar_as_array();
29654 dim = NULL;
29655assign_dim_error:
29656 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29657 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29658 ZVAL_NULL(EX_VAR(opline->result.var));
29659 }
29660 }
29661 }
29662 if (IS_UNUSED != IS_UNUSED) {
29663
29664 }
29665 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29666 /* assign_dim has two opcodes! */
29667 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29668}
29669
29670static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29671{
29672 USE_OPLINE
29673 zval *object_ptr, *orig_object_ptr;
29674 zval *value;
29675 zval *variable_ptr;
29676 zval *dim;
29677 zend_refcounted *garbage = NULL;
29678
29679 SAVE_OPLINE();
29680 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29681
29682 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29683try_assign_dim_array:
29684 SEPARATE_ARRAY(object_ptr);
29685 if (IS_UNUSED == IS_UNUSED) {
29686 value = EX_VAR((opline+1)->op1.var);
29687 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29688 HashTable *ht = Z_ARRVAL_P(object_ptr);
29689 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29690 GC_ADDREF(ht);
29691 }
29692 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29693 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29694 zend_array_destroy(ht);
29695 goto assign_dim_error;
29696 }
29697 }
29698 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
29699 ZVAL_DEREF(value);
29700 }
29701 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29702 if (UNEXPECTED(value == NULL)) {
29703 zend_cannot_add_element();
29704 goto assign_dim_error;
29705 } else if (IS_CV == IS_CV) {
29706 if (Z_REFCOUNTED_P(value)) {
29707 Z_ADDREF_P(value);
29708 }
29709 } else if (IS_CV == IS_VAR) {
29710 zval *free_op_data = EX_VAR((opline+1)->op1.var);
29711 if (Z_ISREF_P(free_op_data)) {
29712 if (Z_REFCOUNTED_P(value)) {
29713 Z_ADDREF_P(value);
29714 }
29715 zval_ptr_dtor_nogc(free_op_data);
29716 }
29717 } else if (IS_CV == IS_CONST) {
29718 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29719 Z_ADDREF_P(value);
29720 }
29721 }
29722 } else {
29723 dim = NULL;
29724 if (IS_UNUSED == IS_CONST) {
29725 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29726 } else {
29727 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29728 }
29729 if (UNEXPECTED(variable_ptr == NULL)) {
29730 goto assign_dim_error;
29731 }
29732 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
29733 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
29734 }
29735 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29736 ZVAL_COPY(EX_VAR(opline->result.var), value);
29737 }
29738 if (garbage) {
29739 GC_DTOR_NO_REF(garbage);
29740 }
29741 } else {
29742 if (EXPECTED(Z_ISREF_P(object_ptr))) {
29743 object_ptr = Z_REFVAL_P(object_ptr);
29744 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29745 goto try_assign_dim_array;
29746 }
29747 }
29748 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29749 zend_object *obj = Z_OBJ_P(object_ptr);
29750
29751 GC_ADDREF(obj);
29752 dim = NULL;
29753 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29754 dim = ZVAL_UNDEFINED_OP2();
29755 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29756 dim++;
29757 }
29758
29759 value = EX_VAR((opline+1)->op1.var);
29760 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29761 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29762 } else if (IS_CV & (IS_CV|IS_VAR)) {
29763 ZVAL_DEREF(value);
29764 }
29765
29766 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29767
29768 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29769 zend_objects_store_del(obj);
29770 }
29771 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29772 if (IS_UNUSED == IS_UNUSED) {
29773 zend_use_new_element_for_string();
29774
29775 UNDEF_RESULT();
29776 } else {
29777 dim = NULL;
29778 value = EX_VAR((opline+1)->op1.var);
29779 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29780
29781 }
29782 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29783 if (Z_ISREF_P(orig_object_ptr)
29784 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29785 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29786 dim = NULL;
29787
29788 UNDEF_RESULT();
29789 } else {
29790 HashTable *ht = zend_new_array(8);
29791 uint8_t old_type = Z_TYPE_P(object_ptr);
29792
29793 ZVAL_ARR(object_ptr, ht);
29794 if (UNEXPECTED(old_type == IS_FALSE)) {
29795 GC_ADDREF(ht);
29796 zend_false_to_array_deprecated();
29797 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29798 zend_array_destroy(ht);
29799 goto assign_dim_error;
29800 }
29801 }
29802 goto try_assign_dim_array;
29803 }
29804 } else {
29805 zend_use_scalar_as_array();
29806 dim = NULL;
29807assign_dim_error:
29808
29809 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29810 ZVAL_NULL(EX_VAR(opline->result.var));
29811 }
29812 }
29813 }
29814 if (IS_UNUSED != IS_UNUSED) {
29815
29816 }
29817 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29818 /* assign_dim has two opcodes! */
29819 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29820}
29821
29822static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29823{
29824 USE_OPLINE
29825 zval *function_name;
29826 zend_class_entry *ce;
29827 uint32_t call_info;
29828 zend_function *fbc;
29829 zend_execute_data *call;
29830
29831 SAVE_OPLINE();
29832
29833 if (IS_VAR == IS_CONST) {
29834 /* no function found. try a static method in class */
29835 ce = CACHED_PTR(opline->result.num);
29836 if (UNEXPECTED(ce == NULL)) {
29837 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);
29838 if (UNEXPECTED(ce == NULL)) {
29839
29840 HANDLE_EXCEPTION();
29841 }
29842 if (IS_UNUSED != IS_CONST) {
29843 CACHE_PTR(opline->result.num, ce);
29844 }
29845 }
29846 } else if (IS_VAR == IS_UNUSED) {
29847 ce = zend_fetch_class(NULL, opline->op1.num);
29848 if (UNEXPECTED(ce == NULL)) {
29849
29850 HANDLE_EXCEPTION();
29851 }
29852 } else {
29853 ce = Z_CE_P(EX_VAR(opline->op1.var));
29854 }
29855
29856 if (IS_VAR == IS_CONST &&
29857 IS_UNUSED == IS_CONST &&
29858 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
29859 /* nothing to do */
29860 } else if (IS_VAR != IS_CONST &&
29861 IS_UNUSED == IS_CONST &&
29862 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
29863 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
29864 } else if (IS_UNUSED != IS_UNUSED) {
29865 function_name = NULL;
29866 if (IS_UNUSED != IS_CONST) {
29867 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
29868 do {
29869 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
29870 function_name = Z_REFVAL_P(function_name);
29871 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
29872 break;
29873 }
29874 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
29875 ZVAL_UNDEFINED_OP2();
29876 if (UNEXPECTED(EG(exception) != NULL)) {
29877 HANDLE_EXCEPTION();
29878 }
29879 }
29880 zend_throw_error(NULL, "Method name must be a string");
29881
29882 HANDLE_EXCEPTION();
29883 } while (0);
29884 }
29885 }
29886
29887 if (ce->get_static_method) {
29888 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
29889 } else {
29890 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
29891 }
29892 if (UNEXPECTED(fbc == NULL)) {
29893 if (EXPECTED(!EG(exception))) {
29894 zend_undefined_method(ce, Z_STR_P(function_name));
29895 }
29896
29897 HANDLE_EXCEPTION();
29898 }
29899 if (IS_UNUSED == IS_CONST &&
29900 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
29901 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
29902 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
29903 }
29904 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
29905 init_func_run_time_cache(&fbc->op_array);
29906 }
29907 if (IS_UNUSED != IS_CONST) {
29908
29909 }
29910 } else {
29911 if (UNEXPECTED(ce->constructor == NULL)) {
29912 zend_throw_error(NULL, "Cannot call constructor");
29913 HANDLE_EXCEPTION();
29914 }
29915 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
29916 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
29917 HANDLE_EXCEPTION();
29918 }
29919 fbc = ce->constructor;
29920 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
29921 init_func_run_time_cache(&fbc->op_array);
29922 }
29923 }
29924
29925 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
29926 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
29927 ce = (zend_class_entry*)Z_OBJ(EX(This));
29928 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
29929 } else {
29930 zend_non_static_method_call(fbc);
29931 HANDLE_EXCEPTION();
29932 }
29933 } else {
29934 /* previous opcode is ZEND_FETCH_CLASS */
29935 if (IS_VAR == IS_UNUSED
29936 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
29937 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
29938 if (Z_TYPE(EX(This)) == IS_OBJECT) {
29939 ce = Z_OBJCE(EX(This));
29940 } else {
29941 ce = Z_CE(EX(This));
29942 }
29943 }
29944 call_info = ZEND_CALL_NESTED_FUNCTION;
29945 }
29946
29947 call = zend_vm_stack_push_call_frame(call_info,
29948 fbc, opline->extended_value, ce);
29949 call->prev_execute_data = EX(call);
29950 EX(call) = call;
29951
29952 ZEND_VM_NEXT_OPCODE();
29953}
29954
29955static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29956{
29957 if (IS_VAR == IS_UNUSED) {
29958 SAVE_OPLINE();
29959 zend_verify_missing_return_type(EX(func));
29960 HANDLE_EXCEPTION();
29961 } else {
29962/* prevents "undefined variable opline" errors */
29963#if 0 || (IS_VAR != IS_UNUSED)
29964 USE_OPLINE
29965 zval *retval_ref, *retval_ptr;
29966 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
29967 retval_ref = retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29968
29969 if (IS_VAR == IS_CONST) {
29970 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
29971 retval_ref = retval_ptr = EX_VAR(opline->result.var);
29972 } else if (IS_VAR == IS_VAR) {
29973 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
29974 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
29975 }
29976 ZVAL_DEREF(retval_ptr);
29977 } else if (IS_VAR == IS_CV) {
29978 ZVAL_DEREF(retval_ptr);
29979 }
29980
29981 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
29982 ZEND_VM_NEXT_OPCODE();
29983 }
29984
29985 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
29986 SAVE_OPLINE();
29987 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
29988 if (UNEXPECTED(EG(exception))) {
29989 HANDLE_EXCEPTION();
29990 }
29991 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
29992 ZEND_VM_NEXT_OPCODE();
29993 }
29994 }
29995
29996 zend_reference *ref = NULL;
29997 void *cache_slot = CACHE_ADDR(opline->op2.num);
29998 if (UNEXPECTED(retval_ref != retval_ptr)) {
29999 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
30000 ref = Z_REF_P(retval_ref);
30001 } else {
30002 /* A cast might happen - unwrap the reference if this is a by-value return */
30003 if (Z_REFCOUNT_P(retval_ref) == 1) {
30004 ZVAL_UNREF(retval_ref);
30005 } else {
30006 Z_DELREF_P(retval_ref);
30007 ZVAL_COPY(retval_ref, retval_ptr);
30008 }
30009 retval_ptr = retval_ref;
30010 }
30011 }
30012
30013 SAVE_OPLINE();
30014 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
30015 zend_verify_return_error(EX(func), retval_ptr);
30016 HANDLE_EXCEPTION();
30017 }
30018 ZEND_VM_NEXT_OPCODE();
30019#endif
30020 }
30021}
30022
30023static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30024{
30025 USE_OPLINE
30026 zval *varptr, *arg;
30027
30028 if (IS_UNUSED == IS_CONST) {
30029 SAVE_OPLINE();
30030 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30031 uint32_t arg_num;
30032 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30033 if (UNEXPECTED(!arg)) {
30034 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30035 HANDLE_EXCEPTION();
30036 }
30037 } else {
30038 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30039 }
30040
30041 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30042 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30043 SAVE_OPLINE();
30044 ZVAL_UNDEFINED_OP1();
30045 ZVAL_NULL(arg);
30046 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30047 }
30048
30049 if (IS_VAR == IS_CV) {
30050 ZVAL_COPY_DEREF(arg, varptr);
30051 } else /* if (IS_VAR == IS_VAR) */ {
30052 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30053 zend_refcounted *ref = Z_COUNTED_P(varptr);
30054
30055 varptr = Z_REFVAL_P(varptr);
30056 ZVAL_COPY_VALUE(arg, varptr);
30057 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30058 efree_size(ref, sizeof(zend_reference));
30059 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30060 Z_ADDREF_P(arg);
30061 }
30062 } else {
30063 ZVAL_COPY_VALUE(arg, varptr);
30064 }
30065 }
30066
30067 ZEND_VM_NEXT_OPCODE();
30068}
30069
30070static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30071{
30072 USE_OPLINE
30073 zval *varptr, *arg;
30074
30075 if (IS_UNUSED == IS_CONST) {
30076 SAVE_OPLINE();
30077 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30078 uint32_t arg_num;
30079 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30080 if (UNEXPECTED(!arg)) {
30081 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30082 HANDLE_EXCEPTION();
30083 }
30084 } else {
30085 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30086 }
30087
30088 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30089 ZVAL_COPY_VALUE(arg, varptr);
30090
30091 if (EXPECTED(Z_ISREF_P(varptr))) {
30092 ZEND_VM_NEXT_OPCODE();
30093 }
30094
30095 SAVE_OPLINE();
30096 ZVAL_NEW_REF(arg, arg);
30097 zend_error(E_NOTICE, "Only variables should be passed by reference");
30098 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30099}
30100
30101static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30102{
30103 USE_OPLINE
30104 zval *varptr, *arg;
30105 uint32_t arg_num;
30106
30107 if (IS_UNUSED == IS_CONST) {
30108 SAVE_OPLINE();
30109 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30110 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30111 if (UNEXPECTED(!arg)) {
30112 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30113 HANDLE_EXCEPTION();
30114 }
30115 } else {
30116 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30117 arg_num = opline->op2.num;
30118 }
30119
30120 if (EXPECTED(0)) {
30121 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30122 goto send_var;
30123 }
30124
30125 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30126 ZVAL_COPY_VALUE(arg, varptr);
30127
30128 if (EXPECTED(Z_ISREF_P(varptr) ||
30129 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30130 ZEND_VM_NEXT_OPCODE();
30131 }
30132 } else {
30133 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30134 goto send_var;
30135 }
30136
30137 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30138 ZVAL_COPY_VALUE(arg, varptr);
30139
30140 if (EXPECTED(Z_ISREF_P(varptr) ||
30141 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30142 ZEND_VM_NEXT_OPCODE();
30143 }
30144 }
30145
30146 SAVE_OPLINE();
30147 ZVAL_NEW_REF(arg, arg);
30148 zend_error(E_NOTICE, "Only variables should be passed by reference");
30149 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30150
30151send_var:
30152 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30153 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30154 zend_refcounted *ref = Z_COUNTED_P(varptr);
30155
30156 varptr = Z_REFVAL_P(varptr);
30157 ZVAL_COPY_VALUE(arg, varptr);
30158 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30159 efree_size(ref, sizeof(zend_reference));
30160 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30161 Z_ADDREF_P(arg);
30162 }
30163 } else {
30164 ZVAL_COPY_VALUE(arg, varptr);
30165 }
30166 ZEND_VM_NEXT_OPCODE();
30167}
30168
30169static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30170{
30171 USE_OPLINE
30172 zval *varptr, *arg;
30173 uint32_t arg_num;
30174
30175 if (IS_UNUSED == IS_CONST) {
30176 SAVE_OPLINE();
30177 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30178 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30179 if (UNEXPECTED(!arg)) {
30180 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30181 HANDLE_EXCEPTION();
30182 }
30183 } else {
30184 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30185 arg_num = opline->op2.num;
30186 }
30187
30188 if (EXPECTED(1)) {
30189 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30190 goto send_var;
30191 }
30192
30193 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30194 ZVAL_COPY_VALUE(arg, varptr);
30195
30196 if (EXPECTED(Z_ISREF_P(varptr) ||
30197 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30198 ZEND_VM_NEXT_OPCODE();
30199 }
30200 } else {
30201 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30202 goto send_var;
30203 }
30204
30205 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30206 ZVAL_COPY_VALUE(arg, varptr);
30207
30208 if (EXPECTED(Z_ISREF_P(varptr) ||
30209 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30210 ZEND_VM_NEXT_OPCODE();
30211 }
30212 }
30213
30214 SAVE_OPLINE();
30215 ZVAL_NEW_REF(arg, arg);
30216 zend_error(E_NOTICE, "Only variables should be passed by reference");
30217 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30218
30219send_var:
30220 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30221 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30222 zend_refcounted *ref = Z_COUNTED_P(varptr);
30223
30224 varptr = Z_REFVAL_P(varptr);
30225 ZVAL_COPY_VALUE(arg, varptr);
30226 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30227 efree_size(ref, sizeof(zend_reference));
30228 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30229 Z_ADDREF_P(arg);
30230 }
30231 } else {
30232 ZVAL_COPY_VALUE(arg, varptr);
30233 }
30234 ZEND_VM_NEXT_OPCODE();
30235}
30236
30237static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30238{
30239 USE_OPLINE
30240 zval *varptr, *arg;
30241
30242 SAVE_OPLINE();
30243 if (IS_UNUSED == IS_CONST) {
30244 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30245 uint32_t arg_num;
30246 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30247 if (UNEXPECTED(!arg)) {
30248 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30249 HANDLE_EXCEPTION();
30250 }
30251 } else {
30252 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30253 }
30254
30255 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30256 if (Z_ISREF_P(varptr)) {
30257 Z_ADDREF_P(varptr);
30258 } else {
30259 ZVAL_MAKE_REF_EX(varptr, 2);
30260 }
30261 ZVAL_REF(arg, Z_REF_P(varptr));
30262
30263 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30264 ZEND_VM_NEXT_OPCODE();
30265}
30266
30267static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30268{
30269 USE_OPLINE
30270 zval *varptr, *arg;
30271 uint32_t arg_num;
30272
30273 if (IS_UNUSED == IS_CONST) {
30274 SAVE_OPLINE();
30275 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30276 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30277 if (UNEXPECTED(!arg)) {
30278 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30279 HANDLE_EXCEPTION();
30280 }
30281 } else {
30282 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30283 arg_num = opline->op2.num;
30284 }
30285
30286 if (EXPECTED(0)) {
30287 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30288 goto send_var_by_ref;
30289 }
30290 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30291send_var_by_ref:
30292 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30293 if (Z_ISREF_P(varptr)) {
30294 Z_ADDREF_P(varptr);
30295 } else {
30296 ZVAL_MAKE_REF_EX(varptr, 2);
30297 }
30298 ZVAL_REF(arg, Z_REF_P(varptr));
30299
30300 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30301 ZEND_VM_NEXT_OPCODE();
30302 }
30303
30304 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30305 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30306 SAVE_OPLINE();
30307 ZVAL_UNDEFINED_OP1();
30308 ZVAL_NULL(arg);
30309 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30310 }
30311
30312 if (IS_VAR == IS_CV) {
30313 ZVAL_COPY_DEREF(arg, varptr);
30314 } else /* if (IS_VAR == IS_VAR) */ {
30315 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30316 zend_refcounted *ref = Z_COUNTED_P(varptr);
30317
30318 varptr = Z_REFVAL_P(varptr);
30319 ZVAL_COPY_VALUE(arg, varptr);
30320 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30321 efree_size(ref, sizeof(zend_reference));
30322 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30323 Z_ADDREF_P(arg);
30324 }
30325 } else {
30326 ZVAL_COPY_VALUE(arg, varptr);
30327 }
30328 }
30329
30330 ZEND_VM_NEXT_OPCODE();
30331}
30332
30333static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30334{
30335 USE_OPLINE
30336 zval *varptr, *arg;
30337 uint32_t arg_num;
30338
30339 if (IS_UNUSED == IS_CONST) {
30340 SAVE_OPLINE();
30341 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30342 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30343 if (UNEXPECTED(!arg)) {
30344 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30345 HANDLE_EXCEPTION();
30346 }
30347 } else {
30348 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30349 arg_num = opline->op2.num;
30350 }
30351
30352 if (EXPECTED(1)) {
30353 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30354 goto send_var_by_ref;
30355 }
30356 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30357send_var_by_ref:
30358 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30359 if (Z_ISREF_P(varptr)) {
30360 Z_ADDREF_P(varptr);
30361 } else {
30362 ZVAL_MAKE_REF_EX(varptr, 2);
30363 }
30364 ZVAL_REF(arg, Z_REF_P(varptr));
30365
30366 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30367 ZEND_VM_NEXT_OPCODE();
30368 }
30369
30370 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30371 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30372 SAVE_OPLINE();
30373 ZVAL_UNDEFINED_OP1();
30374 ZVAL_NULL(arg);
30375 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30376 }
30377
30378 if (IS_VAR == IS_CV) {
30379 ZVAL_COPY_DEREF(arg, varptr);
30380 } else /* if (IS_VAR == IS_VAR) */ {
30381 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30382 zend_refcounted *ref = Z_COUNTED_P(varptr);
30383
30384 varptr = Z_REFVAL_P(varptr);
30385 ZVAL_COPY_VALUE(arg, varptr);
30386 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30387 efree_size(ref, sizeof(zend_reference));
30388 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30389 Z_ADDREF_P(arg);
30390 }
30391 } else {
30392 ZVAL_COPY_VALUE(arg, varptr);
30393 }
30394 }
30395
30396 ZEND_VM_NEXT_OPCODE();
30397}
30398
30399static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30400{
30401 USE_OPLINE
30402 zval *varptr, *arg;
30403
30404 if (IS_UNUSED == IS_CONST) {
30405 // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
30406 SAVE_OPLINE();
30407 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30408 uint32_t arg_num;
30409 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30410 if (UNEXPECTED(!arg)) {
30411 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30412 HANDLE_EXCEPTION();
30413 }
30414 } else {
30415 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30416 }
30417
30418 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
30419 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30420 if (Z_ISREF_P(varptr)) {
30421 Z_ADDREF_P(varptr);
30422 } else {
30423 ZVAL_MAKE_REF_EX(varptr, 2);
30424 }
30425 ZVAL_REF(arg, Z_REF_P(varptr));
30426
30427 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30428 ZEND_VM_NEXT_OPCODE();
30429 }
30430
30431 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30432
30433 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30434 zend_refcounted *ref = Z_COUNTED_P(varptr);
30435
30436 varptr = Z_REFVAL_P(varptr);
30437 ZVAL_COPY_VALUE(arg, varptr);
30438 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30439 efree_size(ref, sizeof(zend_reference));
30440 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30441 Z_ADDREF_P(arg);
30442 }
30443 } else {
30444 ZVAL_COPY_VALUE(arg, varptr);
30445 }
30446
30447 ZEND_VM_NEXT_OPCODE();
30448}
30449
30450static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30451{
30452 USE_OPLINE
30453 zval *result;
30454 zend_function *constructor;
30455 zend_class_entry *ce;
30456 zend_execute_data *call;
30457
30458 SAVE_OPLINE();
30459 if (IS_VAR == IS_CONST) {
30460 ce = CACHED_PTR(opline->op2.num);
30461 if (UNEXPECTED(ce == NULL)) {
30462 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);
30463 if (UNEXPECTED(ce == NULL)) {
30464 ZVAL_UNDEF(EX_VAR(opline->result.var));
30465 HANDLE_EXCEPTION();
30466 }
30467 CACHE_PTR(opline->op2.num, ce);
30468 }
30469 } else if (IS_VAR == IS_UNUSED) {
30470 ce = zend_fetch_class(NULL, opline->op1.num);
30471 if (UNEXPECTED(ce == NULL)) {
30472 ZVAL_UNDEF(EX_VAR(opline->result.var));
30473 HANDLE_EXCEPTION();
30474 }
30475 } else {
30476 ce = Z_CE_P(EX_VAR(opline->op1.var));
30477 }
30478
30479 result = EX_VAR(opline->result.var);
30480 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
30481 ZVAL_UNDEF(result);
30482 HANDLE_EXCEPTION();
30483 }
30484
30485 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
30486 if (constructor == NULL) {
30487 if (UNEXPECTED(EG(exception))) {
30488 HANDLE_EXCEPTION();
30489 }
30490
30491 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
30492 * opcode is DO_FCALL in case EXT instructions are used. */
30493 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
30494 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30495 }
30496
30497 /* Perform a dummy function call */
30498 call = zend_vm_stack_push_call_frame(
30499 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
30500 opline->extended_value, NULL);
30501 } else {
30502 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
30503 init_func_run_time_cache(&constructor->op_array);
30504 }
30505 /* We are not handling overloaded classes right now */
30506 call = zend_vm_stack_push_call_frame(
30507 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
30508 constructor,
30509 opline->extended_value,
30510 Z_OBJ_P(result));
30511 Z_ADDREF_P(result);
30512 }
30513
30514 call->prev_execute_data = EX(call);
30515 EX(call) = call;
30516 ZEND_VM_NEXT_OPCODE();
30517}
30518
30519static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30520{
30521 USE_OPLINE
30522 zval *expr_ptr, new_expr;
30523
30524 SAVE_OPLINE();
30525 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
30526 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
30527 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30528 if (Z_ISREF_P(expr_ptr)) {
30529 Z_ADDREF_P(expr_ptr);
30530 } else {
30531 ZVAL_MAKE_REF_EX(expr_ptr, 2);
30532 }
30533 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30534 } else {
30535 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30536 if (IS_VAR == IS_TMP_VAR) {
30537 /* pass */
30538 } else if (IS_VAR == IS_CONST) {
30539 Z_TRY_ADDREF_P(expr_ptr);
30540 } else if (IS_VAR == IS_CV) {
30541 ZVAL_DEREF(expr_ptr);
30542 Z_TRY_ADDREF_P(expr_ptr);
30543 } else /* if (IS_VAR == IS_VAR) */ {
30544 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
30545 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
30546
30547 expr_ptr = Z_REFVAL_P(expr_ptr);
30548 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30549 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
30550 expr_ptr = &new_expr;
30551 efree_size(ref, sizeof(zend_reference));
30552 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
30553 Z_ADDREF_P(expr_ptr);
30554 }
30555 }
30556 }
30557 }
30558
30559 if (IS_UNUSED != IS_UNUSED) {
30560 zval *offset = NULL;
30561 zend_string *str;
30562 zend_ulong hval;
30563
30564add_again:
30565 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
30566 str = Z_STR_P(offset);
30567 if (IS_UNUSED != IS_CONST) {
30568 if (ZEND_HANDLE_NUMERIC(str, hval)) {
30569 goto num_index;
30570 }
30571 }
30572str_index:
30573 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
30574 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
30575 hval = Z_LVAL_P(offset);
30576num_index:
30577 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
30578 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
30579 offset = Z_REFVAL_P(offset);
30580 goto add_again;
30581 } else if (Z_TYPE_P(offset) == IS_NULL) {
30582 str = ZSTR_EMPTY_ALLOC();
30583 goto str_index;
30584 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
30585 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
30586 goto num_index;
30587 } else if (Z_TYPE_P(offset) == IS_FALSE) {
30588 hval = 0;
30589 goto num_index;
30590 } else if (Z_TYPE_P(offset) == IS_TRUE) {
30591 hval = 1;
30592 goto num_index;
30593 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
30594 zend_use_resource_as_offset(offset);
30595 hval = Z_RES_HANDLE_P(offset);
30596 goto num_index;
30597 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
30598 ZVAL_UNDEFINED_OP2();
30599 str = ZSTR_EMPTY_ALLOC();
30600 goto str_index;
30601 } else {
30602 zend_illegal_array_offset_access(offset);
30603 zval_ptr_dtor_nogc(expr_ptr);
30604 }
30605
30606 } else {
30607 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
30608 zend_cannot_add_element();
30609 zval_ptr_dtor_nogc(expr_ptr);
30610 }
30611 }
30612 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30613}
30614
30615static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30616{
30617 zval *array;
30618 uint32_t size;
30619 USE_OPLINE
30620
30621 SAVE_OPLINE();
30622 array = EX_VAR(opline->result.var);
30623 if (IS_VAR != IS_UNUSED) {
30624 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
30625 ZVAL_ARR(array, zend_new_array(size));
30626 /* Explicitly initialize array as not-packed if flag is set */
30627 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
30628 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
30629 }
30630 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30631 } else {
30632 ZVAL_ARR(array, zend_new_array(0));
30633 ZEND_VM_NEXT_OPCODE();
30634 }
30635}
30636
30637static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30638{
30639 USE_OPLINE
30640 zval *var_ptr;
30641
30642 var_ptr = EX_VAR(opline->op1.var);
30643 if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
30644 if (UNEXPECTED(Z_REFCOUNT_P(var_ptr) == 1)) {
30645 ZVAL_UNREF(var_ptr);
30646 }
30647 }
30648
30649 ZEND_VM_NEXT_OPCODE();
30650}
30651
30652static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30653{
30654 USE_OPLINE
30655
30656 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
30657
30658 SAVE_OPLINE();
30659 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
30660 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30661 }
30662
30663 /* Destroy the previously yielded value */
30664 zval_ptr_dtor(&generator->value);
30665
30666 /* Destroy the previously yielded key */
30667 zval_ptr_dtor(&generator->key);
30668
30669 /* Set the new yielded value */
30670 if (IS_VAR != IS_UNUSED) {
30671 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
30672 /* Constants and temporary variables aren't yieldable by reference,
30673 * but we still allow them with a notice. */
30674 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
30675 zval *value;
30676
30677 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30678
30679 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30680 ZVAL_COPY_VALUE(&generator->value, value);
30681 if (IS_VAR == IS_CONST) {
30682 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
30683 Z_ADDREF(generator->value);
30684 }
30685 }
30686 } else {
30687 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30688
30689 /* If a function call result is yielded and the function did
30690 * not return by reference we throw a notice. */
30691 do {
30692 if (IS_VAR == IS_VAR) {
30693 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
30694 if (opline->extended_value == ZEND_RETURNS_FUNCTION
30695 && !Z_ISREF_P(value_ptr)) {
30696 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30697 ZVAL_COPY(&generator->value, value_ptr);
30698 break;
30699 }
30700 }
30701 if (Z_ISREF_P(value_ptr)) {
30702 Z_ADDREF_P(value_ptr);
30703 } else {
30704 ZVAL_MAKE_REF_EX(value_ptr, 2);
30705 }
30706 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
30707 } while (0);
30708
30709 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30710 }
30711 } else {
30712 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30713
30714 /* Consts, temporary variables and references need copying */
30715 if (IS_VAR == IS_CONST) {
30716 ZVAL_COPY_VALUE(&generator->value, value);
30717 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
30718 Z_ADDREF(generator->value);
30719 }
30720 } else if (IS_VAR == IS_TMP_VAR) {
30721 ZVAL_COPY_VALUE(&generator->value, value);
30722 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
30723 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
30724 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30725 } else {
30726 ZVAL_COPY_VALUE(&generator->value, value);
30727 if (IS_VAR == IS_CV) {
30728 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
30729 }
30730 }
30731 }
30732 } else {
30733 /* If no value was specified yield null */
30734 ZVAL_NULL(&generator->value);
30735 }
30736
30737 /* Set the new yielded key */
30738 if (IS_UNUSED != IS_UNUSED) {
30739 zval *key = NULL;
30740 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
30741 key = Z_REFVAL_P(key);
30742 }
30743 ZVAL_COPY(&generator->key, key);
30744
30745 if (Z_TYPE(generator->key) == IS_LONG
30746 && Z_LVAL(generator->key) > generator->largest_used_integer_key
30747 ) {
30748 generator->largest_used_integer_key = Z_LVAL(generator->key);
30749 }
30750 } else {
30751 /* If no key was specified we use auto-increment keys */
30752 generator->largest_used_integer_key++;
30753 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
30754 }
30755
30756 if (RETURN_VALUE_USED(opline)) {
30757 /* If the return value of yield is used set the send
30758 * target and initialize it to NULL */
30759 generator->send_target = EX_VAR(opline->result.var);
30760 ZVAL_NULL(generator->send_target);
30761 } else {
30762 generator->send_target = NULL;
30763 }
30764
30765 /* The GOTO VM uses a local opline variable. We need to set the opline
30766 * variable in execute_data so we don't resume at an old position. */
30767 SAVE_OPLINE();
30768
30769 ZEND_VM_RETURN();
30770}
30771
30772static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30773{
30774 USE_OPLINE
30775 zval *op1 = EX_VAR(opline->op1.var);
30776
30777 if (IS_VAR == IS_CV) {
30778 if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
30779 ZVAL_NEW_EMPTY_REF(op1);
30780 Z_SET_REFCOUNT_P(op1, 2);
30781 ZVAL_NULL(Z_REFVAL_P(op1));
30782 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30783 } else {
30784 if (Z_ISREF_P(op1)) {
30785 Z_ADDREF_P(op1);
30786 } else {
30787 ZVAL_MAKE_REF_EX(op1, 2);
30788 }
30789 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30790 }
30791 } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
30792 op1 = Z_INDIRECT_P(op1);
30793 if (EXPECTED(!Z_ISREF_P(op1))) {
30794 ZVAL_MAKE_REF_EX(op1, 2);
30795 } else {
30796 GC_ADDREF(Z_REF_P(op1));
30797 }
30798 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30799 } else {
30800 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
30801 }
30802 ZEND_VM_NEXT_OPCODE();
30803}
30804
30805static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30806{
30807 USE_OPLINE
30808 zval *op1;
30809 zend_string *type;
30810
30811 SAVE_OPLINE();
30812 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30813 type = zend_zval_get_legacy_type(op1);
30814 if (EXPECTED(type)) {
30815 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
30816 } else {
30817 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
30818 }
30819 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30820 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30821}
30822
30823static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30824{
30825 USE_OPLINE
30826 zval *varptr, *arg;
30827 uint32_t arg_num = opline->op2.num;
30828
30829 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30830 ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30831 }
30832
30833 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30834 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30835
30836 if (IS_VAR == IS_CV) {
30837 ZVAL_COPY(arg, varptr);
30838 } else /* if (IS_VAR == IS_VAR) */ {
30839 ZVAL_COPY_VALUE(arg, varptr);
30840 }
30841
30842 ZEND_VM_NEXT_OPCODE();
30843}
30844
30845static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30846{
30847 USE_OPLINE
30848 zval *op1, *op2;
30849 bool result;
30850
30851 SAVE_OPLINE();
30852 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30853 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30854 result = fast_is_identical_function(op1, op2);
30855
30856 ZEND_VM_SMART_BRANCH(result, 1);
30857}
30858
30859static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30860{
30861 USE_OPLINE
30862 zval *object;
30863 zval *property;
30864 zval *value;
30865 zval *zptr;
30866 void *_cache_slot[3] = {0};
30867 void **cache_slot;
30868 zend_property_info *prop_info;
30869 zend_object *zobj;
30870 zend_string *name, *tmp_name;
30871
30872 SAVE_OPLINE();
30873 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30874 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30875
30876 do {
30877 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
30878
30879 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30880 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30881 object = Z_REFVAL_P(object);
30882 goto assign_op_object;
30883 }
30884 if (IS_VAR == IS_CV
30885 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
30886 ZVAL_UNDEFINED_OP1();
30887 }
30888 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
30889 break;
30890 }
30891
30892assign_op_object:
30893 /* here we are sure we are dealing with an object */
30894 zobj = Z_OBJ_P(object);
30895 if (IS_CV == IS_CONST) {
30896 name = Z_STR_P(property);
30897 } else {
30898 name = zval_try_get_tmp_string(property, &tmp_name);
30899 if (UNEXPECTED(!name)) {
30900 UNDEF_RESULT();
30901 break;
30902 }
30903 }
30904 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
30905 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
30906 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
30907 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30908 ZVAL_NULL(EX_VAR(opline->result.var));
30909 }
30910 } else {
30911 zend_reference *ref;
30912
30913 do {
30914 if (UNEXPECTED(Z_ISREF_P(zptr))) {
30915 ref = Z_REF_P(zptr);
30916 zptr = Z_REFVAL_P(zptr);
30917 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
30918 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
30919 break;
30920 }
30921 }
30922
30923 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
30924 if (prop_info) {
30925 /* special case for typed properties */
30926 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
30927 } else {
30928 zend_binary_op(zptr, zptr, value OPLINE_CC);
30929 }
30930 } while (0);
30931
30932 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30933 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
30934 }
30935 }
30936 } else {
30937 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
30938 }
30939 if (IS_CV != IS_CONST) {
30940 zend_tmp_string_release(tmp_name);
30941 }
30942 } while (0);
30943
30944 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
30945
30946 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30947 /* assign_obj has two opcodes! */
30948 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30949}
30950
30951/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
30952static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30953{
30954 USE_OPLINE
30955 zval *var_ptr;
30956 zval *value, *container, *dim;
30957 HashTable *ht;
30958
30959 SAVE_OPLINE();
30960 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30961
30962 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
30963assign_dim_op_array:
30964 SEPARATE_ARRAY(container);
30965 ht = Z_ARRVAL_P(container);
30966assign_dim_op_new_array:
30967 dim = EX_VAR(opline->op2.var);
30968 if (IS_CV == IS_UNUSED) {
30969 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
30970 if (UNEXPECTED(!var_ptr)) {
30971 zend_cannot_add_element();
30972 goto assign_dim_op_ret_null;
30973 }
30974 } else {
30975 if (IS_CV == IS_CONST) {
30976 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
30977 } else {
30978 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
30979 }
30980 if (UNEXPECTED(!var_ptr)) {
30981 goto assign_dim_op_ret_null;
30982 }
30983 }
30984
30985 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
30986
30987 do {
30988 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
30989 zend_reference *ref = Z_REF_P(var_ptr);
30990 var_ptr = Z_REFVAL_P(var_ptr);
30991 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
30992 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
30993 break;
30994 }
30995 }
30996 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
30997 } while (0);
30998
30999 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31000 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
31001 }
31002 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
31003 } else {
31004 if (EXPECTED(Z_ISREF_P(container))) {
31005 container = Z_REFVAL_P(container);
31006 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
31007 goto assign_dim_op_array;
31008 }
31009 }
31010
31011 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
31012 zend_object *obj = Z_OBJ_P(container);
31013
31014 dim = EX_VAR(opline->op2.var);
31015 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
31016 dim++;
31017 }
31018 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
31019 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
31020 uint8_t old_type;
31021
31022 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
31023 ZVAL_UNDEFINED_OP1();
31024 }
31025 ht = zend_new_array(8);
31026 old_type = Z_TYPE_P(container);
31027 ZVAL_ARR(container, ht);
31028 if (UNEXPECTED(old_type == IS_FALSE)) {
31029 GC_ADDREF(ht);
31030 zend_false_to_array_deprecated();
31031 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
31032 zend_array_destroy(ht);
31033 goto assign_dim_op_ret_null;
31034 }
31035 }
31036 goto assign_dim_op_new_array;
31037 } else {
31038 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31039 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
31040assign_dim_op_ret_null:
31041 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
31042 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31043 ZVAL_NULL(EX_VAR(opline->result.var));
31044 }
31045 }
31046 }
31047
31048 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31049 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31050}
31051
31052static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31053{
31054 USE_OPLINE
31055 zval *var_ptr;
31056 zval *value;
31057
31058 SAVE_OPLINE();
31059 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31060 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31061
31062 do {
31063 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
31064 zend_reference *ref = Z_REF_P(var_ptr);
31065 var_ptr = Z_REFVAL_P(var_ptr);
31066 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
31067 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
31068 break;
31069 }
31070 }
31071 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
31072 } while (0);
31073
31074 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31075 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
31076 }
31077
31078 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31079 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31080}
31081
31082static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31083{
31084 USE_OPLINE
31085 zval *object;
31086 zval *property;
31087 zval *zptr;
31088 void *_cache_slot[3] = {0};
31089 void **cache_slot;
31090 zend_property_info *prop_info;
31091 zend_object *zobj;
31092 zend_string *name, *tmp_name;
31093
31094 SAVE_OPLINE();
31095 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31096 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31097
31098 do {
31099 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31100 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31101 object = Z_REFVAL_P(object);
31102 goto pre_incdec_object;
31103 }
31104 if (IS_VAR == IS_CV
31105 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
31106 ZVAL_UNDEFINED_OP1();
31107 }
31108 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
31109 break;
31110 }
31111
31112pre_incdec_object:
31113 /* here we are sure we are dealing with an object */
31114 zobj = Z_OBJ_P(object);
31115 if (IS_CV == IS_CONST) {
31116 name = Z_STR_P(property);
31117 } else {
31118 name = zval_try_get_tmp_string(property, &tmp_name);
31119 if (UNEXPECTED(!name)) {
31120 UNDEF_RESULT();
31121 break;
31122 }
31123 }
31124 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
31125 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
31126 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
31127 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31128 ZVAL_NULL(EX_VAR(opline->result.var));
31129 }
31130 } else {
31131 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
31132 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
31133 }
31134 } else {
31135 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
31136 }
31137 if (IS_CV != IS_CONST) {
31138 zend_tmp_string_release(tmp_name);
31139 }
31140 } while (0);
31141
31142 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31143 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31144}
31145
31146static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31147{
31148 USE_OPLINE
31149 zval *object;
31150 zval *property;
31151 zval *zptr;
31152 void *_cache_slot[3] = {0};
31153 void **cache_slot;
31154 zend_property_info *prop_info;
31155 zend_object *zobj;
31156 zend_string *name, *tmp_name;
31157
31158 SAVE_OPLINE();
31159 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31160 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31161
31162 do {
31163 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31164 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31165 object = Z_REFVAL_P(object);
31166 goto post_incdec_object;
31167 }
31168 if (IS_VAR == IS_CV
31169 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
31170 ZVAL_UNDEFINED_OP1();
31171 }
31172 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
31173 break;
31174 }
31175
31176post_incdec_object:
31177 /* here we are sure we are dealing with an object */
31178 zobj = Z_OBJ_P(object);
31179 if (IS_CV == IS_CONST) {
31180 name = Z_STR_P(property);
31181 } else {
31182 name = zval_try_get_tmp_string(property, &tmp_name);
31183 if (UNEXPECTED(!name)) {
31184 ZVAL_UNDEF(EX_VAR(opline->result.var));
31185 break;
31186 }
31187 }
31188 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
31189 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
31190 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
31191 ZVAL_NULL(EX_VAR(opline->result.var));
31192 } else {
31193 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
31194 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
31195 }
31196 } else {
31197 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
31198 }
31199 if (IS_CV != IS_CONST) {
31200 zend_tmp_string_release(tmp_name);
31201 }
31202 } while (0);
31203
31204 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31205 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31206}
31207
31208static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31209{
31210 USE_OPLINE
31211 zval *container;
31212
31213 SAVE_OPLINE();
31214 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31215 zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31216
31217 if (IS_VAR == IS_VAR) {
31218 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31219 }
31220 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31221}
31222
31223static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31224{
31225 USE_OPLINE
31226 zval *container;
31227
31228 SAVE_OPLINE();
31229 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31230 zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31231
31232 if (IS_VAR == IS_VAR) {
31233 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31234 }
31235 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31236}
31237
31238static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31239{
31240#if 0
31241 USE_OPLINE
31242#endif
31243
31244 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
31245 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
31246 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31247 }
31248 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31249 } else {
31250 if (IS_CV == IS_UNUSED) {
31251 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31252 }
31253 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31254 }
31255}
31256
31257static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31258{
31259 USE_OPLINE
31260 zval *container;
31261
31262 SAVE_OPLINE();
31263 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31264 zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31265
31266 if (IS_VAR == IS_VAR) {
31267 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31268 }
31269 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31270}
31271
31272static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31273{
31274 USE_OPLINE
31275 zval *property, *container, *result;
31276
31277 SAVE_OPLINE();
31278
31279 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31280 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31281 result = EX_VAR(opline->result.var);
31282 zend_fetch_property_address(
31283 result, container, IS_VAR, property, IS_CV,
31284 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
31285 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
31286
31287 if (IS_VAR == IS_VAR) {
31288 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31289 }
31290 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31291}
31292
31293static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31294{
31295 USE_OPLINE
31296 zval *property, *container, *result;
31297
31298 SAVE_OPLINE();
31299 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31300 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31301 result = EX_VAR(opline->result.var);
31302 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);
31303
31304 if (IS_VAR == IS_VAR) {
31305 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31306 }
31307 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31308}
31309
31310static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31311{
31312#if 0
31313 USE_OPLINE
31314#endif
31315
31316 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
31317 /* Behave like FETCH_OBJ_W */
31318 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
31319 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31320 }
31321 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31322 } else {
31323 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31324 }
31325}
31326
31327static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31328{
31329 USE_OPLINE
31330 zval *container, *property, *result;
31331
31332 SAVE_OPLINE();
31333 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31334 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31335 result = EX_VAR(opline->result.var);
31336 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);
31337
31338 if (IS_VAR == IS_VAR) {
31339 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31340 }
31341 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31342}
31343
31344static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31345{
31346 USE_OPLINE
31347 zval *container, *dim;
31348
31349 SAVE_OPLINE();
31350 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31351 dim = EX_VAR(opline->op2.var);
31352
31353 if (IS_VAR == IS_VAR
31354 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
31355 && UNEXPECTED(!Z_ISREF_P(container))
31356 ) {
31357 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
31358 zend_fetch_dimension_address_LIST_r(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
31359 } else {
31360 zend_fetch_dimension_address_W(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
31361 }
31362
31363 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31364}
31365
31366static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31367{
31368 USE_OPLINE
31369 zval *object, *value, tmp;
31370 zend_object *zobj;
31371 zend_string *name, *tmp_name;
31372 zend_refcounted *garbage = NULL;
31373
31374 SAVE_OPLINE();
31375 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31376 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31377
31378 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31379 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31380 object = Z_REFVAL_P(object);
31381 goto assign_object;
31382 }
31383 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31384 value = &EG(uninitialized_zval);
31385 goto free_and_exit_assign_obj;
31386 }
31387
31388assign_object:
31389 zobj = Z_OBJ_P(object);
31390 if (IS_CV == IS_CONST) {
31391 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31392 void **cache_slot = CACHE_ADDR(opline->extended_value);
31393 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31394 zval *property_val;
31395 zend_property_info *prop_info;
31396
31397 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31398 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31399
31400assign_obj_simple:
31401 property_val = OBJ_PROP(zobj, prop_offset);
31402 if (Z_TYPE_P(property_val) != IS_UNDEF) {
31403 if (prop_info != NULL) {
31404 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31405 goto free_and_exit_assign_obj;
31406 } else {
31407fast_assign_obj:
31408 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
31409 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31410 ZVAL_COPY(EX_VAR(opline->result.var), value);
31411 }
31412 goto exit_assign_obj;
31413 }
31414 }
31415 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31416 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31417 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31418 zobj = zend_lazy_object_init(zobj);
31419 if (!zobj) {
31420 value = &EG(uninitialized_zval);
31421 goto free_and_exit_assign_obj;
31422 }
31423 }
31424 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31425 rebuild_object_properties_internal(zobj);
31426 }
31427 if (EXPECTED(zobj->properties != NULL)) {
31428 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31429 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31430 GC_DELREF(zobj->properties);
31431 }
31432 zobj->properties = zend_array_dup(zobj->properties);
31433 }
31434 property_val = zend_hash_find_known_hash(zobj->properties, name);
31435 if (property_val) {
31436 goto fast_assign_obj;
31437 }
31438 }
31439
31440 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31441 if (IS_CONST == IS_CONST) {
31442 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31443 Z_ADDREF_P(value);
31444 }
31445 } else if (IS_CONST != IS_TMP_VAR) {
31446 if (Z_ISREF_P(value)) {
31447 if (IS_CONST == IS_VAR) {
31448 zend_reference *ref = Z_REF_P(value);
31449 if (GC_DELREF(ref) == 0) {
31450 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31451 efree_size(ref, sizeof(zend_reference));
31452 value = &tmp;
31453 } else {
31454 value = Z_REFVAL_P(value);
31455 Z_TRY_ADDREF_P(value);
31456 }
31457 } else {
31458 value = Z_REFVAL_P(value);
31459 Z_TRY_ADDREF_P(value);
31460 }
31461 } else if (IS_CONST == IS_CV) {
31462 Z_TRY_ADDREF_P(value);
31463 }
31464 }
31465 zend_hash_add_new(zobj->properties, name, value);
31466 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31467 ZVAL_COPY(EX_VAR(opline->result.var), value);
31468 }
31469 goto exit_assign_obj;
31470 }
31471 } else {
31472 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31473 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31474 prop_info = CACHED_PTR_EX(cache_slot + 2);
31475 prop_offset = prop_info->offset;
31476 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
31477 prop_info = NULL;
31478 }
31479 goto assign_obj_simple;
31480 }
31481 /* Fall through to write_property for hooks. */
31482 }
31483 }
31484 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31485 } else {
31486 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31487 if (UNEXPECTED(!name)) {
31488
31489 UNDEF_RESULT();
31490 goto exit_assign_obj;
31491 }
31492 }
31493
31494 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
31495 ZVAL_DEREF(value);
31496 }
31497
31498 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31499
31500 if (IS_CV != IS_CONST) {
31501 zend_tmp_string_release(tmp_name);
31502 }
31503
31504free_and_exit_assign_obj:
31505 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31506 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31507 }
31508
31509exit_assign_obj:
31510 if (garbage) {
31511 GC_DTOR_NO_REF(garbage);
31512 }
31513
31514 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31515 /* assign_obj has two opcodes! */
31516 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31517}
31518
31519/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
31520static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31521{
31522 USE_OPLINE
31523 zval *object, *value, tmp;
31524 zend_object *zobj;
31525 zend_string *name, *tmp_name;
31526 zend_refcounted *garbage = NULL;
31527
31528 SAVE_OPLINE();
31529 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31530 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31531
31532 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31533 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31534 object = Z_REFVAL_P(object);
31535 goto assign_object;
31536 }
31537 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31538 value = &EG(uninitialized_zval);
31539 goto free_and_exit_assign_obj;
31540 }
31541
31542assign_object:
31543 zobj = Z_OBJ_P(object);
31544 if (IS_CV == IS_CONST) {
31545 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31546 void **cache_slot = CACHE_ADDR(opline->extended_value);
31547 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31548 zval *property_val;
31549 zend_property_info *prop_info;
31550
31551 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31552 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31553
31554assign_obj_simple:
31555 property_val = OBJ_PROP(zobj, prop_offset);
31556 if (Z_TYPE_P(property_val) != IS_UNDEF) {
31557 if (prop_info != NULL) {
31558 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31559 goto free_and_exit_assign_obj;
31560 } else {
31561fast_assign_obj:
31562 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
31563 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31564 ZVAL_COPY(EX_VAR(opline->result.var), value);
31565 }
31566 goto exit_assign_obj;
31567 }
31568 }
31569 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31570 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31571 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31572 zobj = zend_lazy_object_init(zobj);
31573 if (!zobj) {
31574 value = &EG(uninitialized_zval);
31575 goto free_and_exit_assign_obj;
31576 }
31577 }
31578 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31579 rebuild_object_properties_internal(zobj);
31580 }
31581 if (EXPECTED(zobj->properties != NULL)) {
31582 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31583 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31584 GC_DELREF(zobj->properties);
31585 }
31586 zobj->properties = zend_array_dup(zobj->properties);
31587 }
31588 property_val = zend_hash_find_known_hash(zobj->properties, name);
31589 if (property_val) {
31590 goto fast_assign_obj;
31591 }
31592 }
31593
31594 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31595 if (IS_TMP_VAR == IS_CONST) {
31596 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31597 Z_ADDREF_P(value);
31598 }
31599 } else if (IS_TMP_VAR != IS_TMP_VAR) {
31600 if (Z_ISREF_P(value)) {
31601 if (IS_TMP_VAR == IS_VAR) {
31602 zend_reference *ref = Z_REF_P(value);
31603 if (GC_DELREF(ref) == 0) {
31604 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31605 efree_size(ref, sizeof(zend_reference));
31606 value = &tmp;
31607 } else {
31608 value = Z_REFVAL_P(value);
31609 Z_TRY_ADDREF_P(value);
31610 }
31611 } else {
31612 value = Z_REFVAL_P(value);
31613 Z_TRY_ADDREF_P(value);
31614 }
31615 } else if (IS_TMP_VAR == IS_CV) {
31616 Z_TRY_ADDREF_P(value);
31617 }
31618 }
31619 zend_hash_add_new(zobj->properties, name, value);
31620 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31621 ZVAL_COPY(EX_VAR(opline->result.var), value);
31622 }
31623 goto exit_assign_obj;
31624 }
31625 } else {
31626 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31627 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31628 prop_info = CACHED_PTR_EX(cache_slot + 2);
31629 prop_offset = prop_info->offset;
31630 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
31631 prop_info = NULL;
31632 }
31633 goto assign_obj_simple;
31634 }
31635 /* Fall through to write_property for hooks. */
31636 }
31637 }
31638 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31639 } else {
31640 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31641 if (UNEXPECTED(!name)) {
31642 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31643 UNDEF_RESULT();
31644 goto exit_assign_obj;
31645 }
31646 }
31647
31648 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
31649 ZVAL_DEREF(value);
31650 }
31651
31652 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31653
31654 if (IS_CV != IS_CONST) {
31655 zend_tmp_string_release(tmp_name);
31656 }
31657
31658free_and_exit_assign_obj:
31659 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31660 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31661 }
31662 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31663exit_assign_obj:
31664 if (garbage) {
31665 GC_DTOR_NO_REF(garbage);
31666 }
31667
31668 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31669 /* assign_obj has two opcodes! */
31670 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31671}
31672
31673/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
31674static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31675{
31676 USE_OPLINE
31677 zval *object, *value, tmp;
31678 zend_object *zobj;
31679 zend_string *name, *tmp_name;
31680 zend_refcounted *garbage = NULL;
31681
31682 SAVE_OPLINE();
31683 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31684 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31685
31686 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31687 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31688 object = Z_REFVAL_P(object);
31689 goto assign_object;
31690 }
31691 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31692 value = &EG(uninitialized_zval);
31693 goto free_and_exit_assign_obj;
31694 }
31695
31696assign_object:
31697 zobj = Z_OBJ_P(object);
31698 if (IS_CV == IS_CONST) {
31699 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31700 void **cache_slot = CACHE_ADDR(opline->extended_value);
31701 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31702 zval *property_val;
31703 zend_property_info *prop_info;
31704
31705 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31706 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31707
31708assign_obj_simple:
31709 property_val = OBJ_PROP(zobj, prop_offset);
31710 if (Z_TYPE_P(property_val) != IS_UNDEF) {
31711 if (prop_info != NULL) {
31712 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31713 goto free_and_exit_assign_obj;
31714 } else {
31715fast_assign_obj:
31716 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
31717 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31718 ZVAL_COPY(EX_VAR(opline->result.var), value);
31719 }
31720 goto exit_assign_obj;
31721 }
31722 }
31723 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31724 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31725 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31726 zobj = zend_lazy_object_init(zobj);
31727 if (!zobj) {
31728 value = &EG(uninitialized_zval);
31729 goto free_and_exit_assign_obj;
31730 }
31731 }
31732 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31733 rebuild_object_properties_internal(zobj);
31734 }
31735 if (EXPECTED(zobj->properties != NULL)) {
31736 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31737 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31738 GC_DELREF(zobj->properties);
31739 }
31740 zobj->properties = zend_array_dup(zobj->properties);
31741 }
31742 property_val = zend_hash_find_known_hash(zobj->properties, name);
31743 if (property_val) {
31744 goto fast_assign_obj;
31745 }
31746 }
31747
31748 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31749 if (IS_VAR == IS_CONST) {
31750 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31751 Z_ADDREF_P(value);
31752 }
31753 } else if (IS_VAR != IS_TMP_VAR) {
31754 if (Z_ISREF_P(value)) {
31755 if (IS_VAR == IS_VAR) {
31756 zend_reference *ref = Z_REF_P(value);
31757 if (GC_DELREF(ref) == 0) {
31758 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31759 efree_size(ref, sizeof(zend_reference));
31760 value = &tmp;
31761 } else {
31762 value = Z_REFVAL_P(value);
31763 Z_TRY_ADDREF_P(value);
31764 }
31765 } else {
31766 value = Z_REFVAL_P(value);
31767 Z_TRY_ADDREF_P(value);
31768 }
31769 } else if (IS_VAR == IS_CV) {
31770 Z_TRY_ADDREF_P(value);
31771 }
31772 }
31773 zend_hash_add_new(zobj->properties, name, value);
31774 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31775 ZVAL_COPY(EX_VAR(opline->result.var), value);
31776 }
31777 goto exit_assign_obj;
31778 }
31779 } else {
31780 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31781 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31782 prop_info = CACHED_PTR_EX(cache_slot + 2);
31783 prop_offset = prop_info->offset;
31784 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
31785 prop_info = NULL;
31786 }
31787 goto assign_obj_simple;
31788 }
31789 /* Fall through to write_property for hooks. */
31790 }
31791 }
31792 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31793 } else {
31794 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31795 if (UNEXPECTED(!name)) {
31796 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31797 UNDEF_RESULT();
31798 goto exit_assign_obj;
31799 }
31800 }
31801
31802 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
31803 ZVAL_DEREF(value);
31804 }
31805
31806 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31807
31808 if (IS_CV != IS_CONST) {
31809 zend_tmp_string_release(tmp_name);
31810 }
31811
31812free_and_exit_assign_obj:
31813 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31814 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31815 }
31816 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31817exit_assign_obj:
31818 if (garbage) {
31819 GC_DTOR_NO_REF(garbage);
31820 }
31821
31822 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31823 /* assign_obj has two opcodes! */
31824 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31825}
31826
31827/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
31828static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31829{
31830 USE_OPLINE
31831 zval *object, *value, tmp;
31832 zend_object *zobj;
31833 zend_string *name, *tmp_name;
31834 zend_refcounted *garbage = NULL;
31835
31836 SAVE_OPLINE();
31837 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31838 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
31839
31840 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31841 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31842 object = Z_REFVAL_P(object);
31843 goto assign_object;
31844 }
31845 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31846 value = &EG(uninitialized_zval);
31847 goto free_and_exit_assign_obj;
31848 }
31849
31850assign_object:
31851 zobj = Z_OBJ_P(object);
31852 if (IS_CV == IS_CONST) {
31853 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31854 void **cache_slot = CACHE_ADDR(opline->extended_value);
31855 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31856 zval *property_val;
31857 zend_property_info *prop_info;
31858
31859 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31860 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31861
31862assign_obj_simple:
31863 property_val = OBJ_PROP(zobj, prop_offset);
31864 if (Z_TYPE_P(property_val) != IS_UNDEF) {
31865 if (prop_info != NULL) {
31866 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31867 goto free_and_exit_assign_obj;
31868 } else {
31869fast_assign_obj:
31870 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31871 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31872 ZVAL_COPY(EX_VAR(opline->result.var), value);
31873 }
31874 goto exit_assign_obj;
31875 }
31876 }
31877 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31878 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31879 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31880 zobj = zend_lazy_object_init(zobj);
31881 if (!zobj) {
31882 value = &EG(uninitialized_zval);
31883 goto free_and_exit_assign_obj;
31884 }
31885 }
31886 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31887 rebuild_object_properties_internal(zobj);
31888 }
31889 if (EXPECTED(zobj->properties != NULL)) {
31890 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31891 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31892 GC_DELREF(zobj->properties);
31893 }
31894 zobj->properties = zend_array_dup(zobj->properties);
31895 }
31896 property_val = zend_hash_find_known_hash(zobj->properties, name);
31897 if (property_val) {
31898 goto fast_assign_obj;
31899 }
31900 }
31901
31902 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31903 if (IS_CV == IS_CONST) {
31904 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31905 Z_ADDREF_P(value);
31906 }
31907 } else if (IS_CV != IS_TMP_VAR) {
31908 if (Z_ISREF_P(value)) {
31909 if (IS_CV == IS_VAR) {
31910 zend_reference *ref = Z_REF_P(value);
31911 if (GC_DELREF(ref) == 0) {
31912 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31913 efree_size(ref, sizeof(zend_reference));
31914 value = &tmp;
31915 } else {
31916 value = Z_REFVAL_P(value);
31917 Z_TRY_ADDREF_P(value);
31918 }
31919 } else {
31920 value = Z_REFVAL_P(value);
31921 Z_TRY_ADDREF_P(value);
31922 }
31923 } else if (IS_CV == IS_CV) {
31924 Z_TRY_ADDREF_P(value);
31925 }
31926 }
31927 zend_hash_add_new(zobj->properties, name, value);
31928 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31929 ZVAL_COPY(EX_VAR(opline->result.var), value);
31930 }
31931 goto exit_assign_obj;
31932 }
31933 } else {
31934 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31935 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31936 prop_info = CACHED_PTR_EX(cache_slot + 2);
31937 prop_offset = prop_info->offset;
31938 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
31939 prop_info = NULL;
31940 }
31941 goto assign_obj_simple;
31942 }
31943 /* Fall through to write_property for hooks. */
31944 }
31945 }
31946 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31947 } else {
31948 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31949 if (UNEXPECTED(!name)) {
31950
31951 UNDEF_RESULT();
31952 goto exit_assign_obj;
31953 }
31954 }
31955
31956 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
31957 ZVAL_DEREF(value);
31958 }
31959
31960 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31961
31962 if (IS_CV != IS_CONST) {
31963 zend_tmp_string_release(tmp_name);
31964 }
31965
31966free_and_exit_assign_obj:
31967 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31968 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31969 }
31970
31971exit_assign_obj:
31972 if (garbage) {
31973 GC_DTOR_NO_REF(garbage);
31974 }
31975
31976 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31977 /* assign_obj has two opcodes! */
31978 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31979}
31980
31981/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
31982static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31983{
31984 USE_OPLINE
31985 zval *object_ptr, *orig_object_ptr;
31986 zval *value;
31987 zval *variable_ptr;
31988 zval *dim;
31989 zend_refcounted *garbage = NULL;
31990
31991 SAVE_OPLINE();
31992 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31993
31994 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31995try_assign_dim_array:
31996 SEPARATE_ARRAY(object_ptr);
31997 if (IS_CV == IS_UNUSED) {
31998 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31999 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32000 HashTable *ht = Z_ARRVAL_P(object_ptr);
32001 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32002 GC_ADDREF(ht);
32003 }
32004 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32005 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32006 zend_array_destroy(ht);
32007 goto assign_dim_error;
32008 }
32009 }
32010 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
32011 ZVAL_DEREF(value);
32012 }
32013 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32014 if (UNEXPECTED(value == NULL)) {
32015 zend_cannot_add_element();
32016 goto assign_dim_error;
32017 } else if (IS_CONST == IS_CV) {
32018 if (Z_REFCOUNTED_P(value)) {
32019 Z_ADDREF_P(value);
32020 }
32021 } else if (IS_CONST == IS_VAR) {
32022 zval *free_op_data = EX_VAR((opline+1)->op1.var);
32023 if (Z_ISREF_P(free_op_data)) {
32024 if (Z_REFCOUNTED_P(value)) {
32025 Z_ADDREF_P(value);
32026 }
32027 zval_ptr_dtor_nogc(free_op_data);
32028 }
32029 } else if (IS_CONST == IS_CONST) {
32030 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32031 Z_ADDREF_P(value);
32032 }
32033 }
32034 } else {
32035 dim = EX_VAR(opline->op2.var);
32036 if (IS_CV == IS_CONST) {
32037 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32038 } else {
32039 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32040 }
32041 if (UNEXPECTED(variable_ptr == NULL)) {
32042 goto assign_dim_error;
32043 }
32044 value = RT_CONSTANT((opline+1), (opline+1)->op1);
32045 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
32046 }
32047 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32048 ZVAL_COPY(EX_VAR(opline->result.var), value);
32049 }
32050 if (garbage) {
32051 GC_DTOR_NO_REF(garbage);
32052 }
32053 } else {
32054 if (EXPECTED(Z_ISREF_P(object_ptr))) {
32055 object_ptr = Z_REFVAL_P(object_ptr);
32056 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32057 goto try_assign_dim_array;
32058 }
32059 }
32060 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32061 zend_object *obj = Z_OBJ_P(object_ptr);
32062
32063 GC_ADDREF(obj);
32064 dim = EX_VAR(opline->op2.var);
32065 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32066 dim = ZVAL_UNDEFINED_OP2();
32067 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32068 dim++;
32069 }
32070
32071 value = RT_CONSTANT((opline+1), (opline+1)->op1);
32072 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32073 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32074 } else if (IS_CONST & (IS_CV|IS_VAR)) {
32075 ZVAL_DEREF(value);
32076 }
32077
32078 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32079
32080 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32081 zend_objects_store_del(obj);
32082 }
32083 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32084 if (IS_CV == IS_UNUSED) {
32085 zend_use_new_element_for_string();
32086
32087 UNDEF_RESULT();
32088 } else {
32089 dim = EX_VAR(opline->op2.var);
32090 value = RT_CONSTANT((opline+1), (opline+1)->op1);
32091 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32092
32093 }
32094 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32095 if (Z_ISREF_P(orig_object_ptr)
32096 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32097 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32098 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32099
32100 UNDEF_RESULT();
32101 } else {
32102 HashTable *ht = zend_new_array(8);
32103 uint8_t old_type = Z_TYPE_P(object_ptr);
32104
32105 ZVAL_ARR(object_ptr, ht);
32106 if (UNEXPECTED(old_type == IS_FALSE)) {
32107 GC_ADDREF(ht);
32108 zend_false_to_array_deprecated();
32109 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32110 zend_array_destroy(ht);
32111 goto assign_dim_error;
32112 }
32113 }
32114 goto try_assign_dim_array;
32115 }
32116 } else {
32117 zend_use_scalar_as_array();
32118 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32119assign_dim_error:
32120
32121 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32122 ZVAL_NULL(EX_VAR(opline->result.var));
32123 }
32124 }
32125 }
32126 if (IS_CV != IS_UNUSED) {
32127
32128 }
32129 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32130 /* assign_dim has two opcodes! */
32131 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32132}
32133
32134static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32135{
32136 USE_OPLINE
32137 zval *object_ptr, *orig_object_ptr;
32138 zval *value;
32139 zval *variable_ptr;
32140 zval *dim;
32141 zend_refcounted *garbage = NULL;
32142
32143 SAVE_OPLINE();
32144 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32145
32146 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32147try_assign_dim_array:
32148 SEPARATE_ARRAY(object_ptr);
32149 if (IS_CV == IS_UNUSED) {
32150 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32151 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32152 HashTable *ht = Z_ARRVAL_P(object_ptr);
32153 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32154 GC_ADDREF(ht);
32155 }
32156 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32157 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32158 zend_array_destroy(ht);
32159 goto assign_dim_error;
32160 }
32161 }
32162 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
32163 ZVAL_DEREF(value);
32164 }
32165 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32166 if (UNEXPECTED(value == NULL)) {
32167 zend_cannot_add_element();
32168 goto assign_dim_error;
32169 } else if (IS_TMP_VAR == IS_CV) {
32170 if (Z_REFCOUNTED_P(value)) {
32171 Z_ADDREF_P(value);
32172 }
32173 } else if (IS_TMP_VAR == IS_VAR) {
32174 zval *free_op_data = EX_VAR((opline+1)->op1.var);
32175 if (Z_ISREF_P(free_op_data)) {
32176 if (Z_REFCOUNTED_P(value)) {
32177 Z_ADDREF_P(value);
32178 }
32179 zval_ptr_dtor_nogc(free_op_data);
32180 }
32181 } else if (IS_TMP_VAR == IS_CONST) {
32182 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32183 Z_ADDREF_P(value);
32184 }
32185 }
32186 } else {
32187 dim = EX_VAR(opline->op2.var);
32188 if (IS_CV == IS_CONST) {
32189 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32190 } else {
32191 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32192 }
32193 if (UNEXPECTED(variable_ptr == NULL)) {
32194 goto assign_dim_error;
32195 }
32196 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32197 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
32198 }
32199 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32200 ZVAL_COPY(EX_VAR(opline->result.var), value);
32201 }
32202 if (garbage) {
32203 GC_DTOR_NO_REF(garbage);
32204 }
32205 } else {
32206 if (EXPECTED(Z_ISREF_P(object_ptr))) {
32207 object_ptr = Z_REFVAL_P(object_ptr);
32208 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32209 goto try_assign_dim_array;
32210 }
32211 }
32212 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32213 zend_object *obj = Z_OBJ_P(object_ptr);
32214
32215 GC_ADDREF(obj);
32216 dim = EX_VAR(opline->op2.var);
32217 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32218 dim = ZVAL_UNDEFINED_OP2();
32219 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32220 dim++;
32221 }
32222
32223 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32224 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32225 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32226 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
32227 ZVAL_DEREF(value);
32228 }
32229
32230 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32231
32232 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32233 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32234 zend_objects_store_del(obj);
32235 }
32236 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32237 if (IS_CV == IS_UNUSED) {
32238 zend_use_new_element_for_string();
32239 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32240 UNDEF_RESULT();
32241 } else {
32242 dim = EX_VAR(opline->op2.var);
32243 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32244 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32245 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32246 }
32247 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32248 if (Z_ISREF_P(orig_object_ptr)
32249 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32250 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32251 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32252 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32253 UNDEF_RESULT();
32254 } else {
32255 HashTable *ht = zend_new_array(8);
32256 uint8_t old_type = Z_TYPE_P(object_ptr);
32257
32258 ZVAL_ARR(object_ptr, ht);
32259 if (UNEXPECTED(old_type == IS_FALSE)) {
32260 GC_ADDREF(ht);
32261 zend_false_to_array_deprecated();
32262 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32263 zend_array_destroy(ht);
32264 goto assign_dim_error;
32265 }
32266 }
32267 goto try_assign_dim_array;
32268 }
32269 } else {
32270 zend_use_scalar_as_array();
32271 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32272assign_dim_error:
32273 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32274 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32275 ZVAL_NULL(EX_VAR(opline->result.var));
32276 }
32277 }
32278 }
32279 if (IS_CV != IS_UNUSED) {
32280
32281 }
32282 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32283 /* assign_dim has two opcodes! */
32284 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32285}
32286
32287static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32288{
32289 USE_OPLINE
32290 zval *object_ptr, *orig_object_ptr;
32291 zval *value;
32292 zval *variable_ptr;
32293 zval *dim;
32294 zend_refcounted *garbage = NULL;
32295
32296 SAVE_OPLINE();
32297 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32298
32299 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32300try_assign_dim_array:
32301 SEPARATE_ARRAY(object_ptr);
32302 if (IS_CV == IS_UNUSED) {
32303 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32304 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32305 HashTable *ht = Z_ARRVAL_P(object_ptr);
32306 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32307 GC_ADDREF(ht);
32308 }
32309 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32310 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32311 zend_array_destroy(ht);
32312 goto assign_dim_error;
32313 }
32314 }
32315 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
32316 ZVAL_DEREF(value);
32317 }
32318 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32319 if (UNEXPECTED(value == NULL)) {
32320 zend_cannot_add_element();
32321 goto assign_dim_error;
32322 } else if (IS_VAR == IS_CV) {
32323 if (Z_REFCOUNTED_P(value)) {
32324 Z_ADDREF_P(value);
32325 }
32326 } else if (IS_VAR == IS_VAR) {
32327 zval *free_op_data = EX_VAR((opline+1)->op1.var);
32328 if (Z_ISREF_P(free_op_data)) {
32329 if (Z_REFCOUNTED_P(value)) {
32330 Z_ADDREF_P(value);
32331 }
32332 zval_ptr_dtor_nogc(free_op_data);
32333 }
32334 } else if (IS_VAR == IS_CONST) {
32335 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32336 Z_ADDREF_P(value);
32337 }
32338 }
32339 } else {
32340 dim = EX_VAR(opline->op2.var);
32341 if (IS_CV == IS_CONST) {
32342 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32343 } else {
32344 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32345 }
32346 if (UNEXPECTED(variable_ptr == NULL)) {
32347 goto assign_dim_error;
32348 }
32349 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32350 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
32351 }
32352 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32353 ZVAL_COPY(EX_VAR(opline->result.var), value);
32354 }
32355 if (garbage) {
32356 GC_DTOR_NO_REF(garbage);
32357 }
32358 } else {
32359 if (EXPECTED(Z_ISREF_P(object_ptr))) {
32360 object_ptr = Z_REFVAL_P(object_ptr);
32361 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32362 goto try_assign_dim_array;
32363 }
32364 }
32365 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32366 zend_object *obj = Z_OBJ_P(object_ptr);
32367
32368 GC_ADDREF(obj);
32369 dim = EX_VAR(opline->op2.var);
32370 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32371 dim = ZVAL_UNDEFINED_OP2();
32372 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32373 dim++;
32374 }
32375
32376 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32377 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32378 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32379 } else if (IS_VAR & (IS_CV|IS_VAR)) {
32380 ZVAL_DEREF(value);
32381 }
32382
32383 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32384
32385 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32386 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32387 zend_objects_store_del(obj);
32388 }
32389 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32390 if (IS_CV == IS_UNUSED) {
32391 zend_use_new_element_for_string();
32392 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32393 UNDEF_RESULT();
32394 } else {
32395 dim = EX_VAR(opline->op2.var);
32396 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32397 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32398 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32399 }
32400 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32401 if (Z_ISREF_P(orig_object_ptr)
32402 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32403 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32404 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32405 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32406 UNDEF_RESULT();
32407 } else {
32408 HashTable *ht = zend_new_array(8);
32409 uint8_t old_type = Z_TYPE_P(object_ptr);
32410
32411 ZVAL_ARR(object_ptr, ht);
32412 if (UNEXPECTED(old_type == IS_FALSE)) {
32413 GC_ADDREF(ht);
32414 zend_false_to_array_deprecated();
32415 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32416 zend_array_destroy(ht);
32417 goto assign_dim_error;
32418 }
32419 }
32420 goto try_assign_dim_array;
32421 }
32422 } else {
32423 zend_use_scalar_as_array();
32424 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32425assign_dim_error:
32426 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32427 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32428 ZVAL_NULL(EX_VAR(opline->result.var));
32429 }
32430 }
32431 }
32432 if (IS_CV != IS_UNUSED) {
32433
32434 }
32435 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32436 /* assign_dim has two opcodes! */
32437 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32438}
32439
32440static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32441{
32442 USE_OPLINE
32443 zval *object_ptr, *orig_object_ptr;
32444 zval *value;
32445 zval *variable_ptr;
32446 zval *dim;
32447 zend_refcounted *garbage = NULL;
32448
32449 SAVE_OPLINE();
32450 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32451
32452 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32453try_assign_dim_array:
32454 SEPARATE_ARRAY(object_ptr);
32455 if (IS_CV == IS_UNUSED) {
32456 value = EX_VAR((opline+1)->op1.var);
32457 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32458 HashTable *ht = Z_ARRVAL_P(object_ptr);
32459 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32460 GC_ADDREF(ht);
32461 }
32462 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32463 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32464 zend_array_destroy(ht);
32465 goto assign_dim_error;
32466 }
32467 }
32468 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
32469 ZVAL_DEREF(value);
32470 }
32471 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32472 if (UNEXPECTED(value == NULL)) {
32473 zend_cannot_add_element();
32474 goto assign_dim_error;
32475 } else if (IS_CV == IS_CV) {
32476 if (Z_REFCOUNTED_P(value)) {
32477 Z_ADDREF_P(value);
32478 }
32479 } else if (IS_CV == IS_VAR) {
32480 zval *free_op_data = EX_VAR((opline+1)->op1.var);
32481 if (Z_ISREF_P(free_op_data)) {
32482 if (Z_REFCOUNTED_P(value)) {
32483 Z_ADDREF_P(value);
32484 }
32485 zval_ptr_dtor_nogc(free_op_data);
32486 }
32487 } else if (IS_CV == IS_CONST) {
32488 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32489 Z_ADDREF_P(value);
32490 }
32491 }
32492 } else {
32493 dim = EX_VAR(opline->op2.var);
32494 if (IS_CV == IS_CONST) {
32495 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32496 } else {
32497 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32498 }
32499 if (UNEXPECTED(variable_ptr == NULL)) {
32500 goto assign_dim_error;
32501 }
32502 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
32503 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32504 }
32505 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32506 ZVAL_COPY(EX_VAR(opline->result.var), value);
32507 }
32508 if (garbage) {
32509 GC_DTOR_NO_REF(garbage);
32510 }
32511 } else {
32512 if (EXPECTED(Z_ISREF_P(object_ptr))) {
32513 object_ptr = Z_REFVAL_P(object_ptr);
32514 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32515 goto try_assign_dim_array;
32516 }
32517 }
32518 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32519 zend_object *obj = Z_OBJ_P(object_ptr);
32520
32521 GC_ADDREF(obj);
32522 dim = EX_VAR(opline->op2.var);
32523 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32524 dim = ZVAL_UNDEFINED_OP2();
32525 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32526 dim++;
32527 }
32528
32529 value = EX_VAR((opline+1)->op1.var);
32530 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32531 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32532 } else if (IS_CV & (IS_CV|IS_VAR)) {
32533 ZVAL_DEREF(value);
32534 }
32535
32536 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32537
32538 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32539 zend_objects_store_del(obj);
32540 }
32541 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32542 if (IS_CV == IS_UNUSED) {
32543 zend_use_new_element_for_string();
32544
32545 UNDEF_RESULT();
32546 } else {
32547 dim = EX_VAR(opline->op2.var);
32548 value = EX_VAR((opline+1)->op1.var);
32549 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32550
32551 }
32552 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32553 if (Z_ISREF_P(orig_object_ptr)
32554 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32555 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32556 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32557
32558 UNDEF_RESULT();
32559 } else {
32560 HashTable *ht = zend_new_array(8);
32561 uint8_t old_type = Z_TYPE_P(object_ptr);
32562
32563 ZVAL_ARR(object_ptr, ht);
32564 if (UNEXPECTED(old_type == IS_FALSE)) {
32565 GC_ADDREF(ht);
32566 zend_false_to_array_deprecated();
32567 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32568 zend_array_destroy(ht);
32569 goto assign_dim_error;
32570 }
32571 }
32572 goto try_assign_dim_array;
32573 }
32574 } else {
32575 zend_use_scalar_as_array();
32576 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32577assign_dim_error:
32578
32579 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32580 ZVAL_NULL(EX_VAR(opline->result.var));
32581 }
32582 }
32583 }
32584 if (IS_CV != IS_UNUSED) {
32585
32586 }
32587 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32588 /* assign_dim has two opcodes! */
32589 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32590}
32591
32592static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32593{
32594 USE_OPLINE
32595 zval *value;
32596 zval *variable_ptr;
32597
32598 SAVE_OPLINE();
32599 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32600 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32601
32602 if (0 || UNEXPECTED(0)) {
32603 zend_refcounted *garbage = NULL;
32604
32605 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32606 if (UNEXPECTED(0)) {
32607 ZVAL_COPY(EX_VAR(opline->result.var), value);
32608 }
32609 if (garbage) {
32610 GC_DTOR_NO_REF(garbage);
32611 }
32612 } else {
32613 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32614 }
32615 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32616 /* zend_assign_to_variable() always takes care of op2, never free it! */
32617
32618 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32619}
32620
32621static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32622{
32623 USE_OPLINE
32624 zval *value;
32625 zval *variable_ptr;
32626
32627 SAVE_OPLINE();
32628 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32629 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32630
32631 if (0 || UNEXPECTED(1)) {
32632 zend_refcounted *garbage = NULL;
32633
32634 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32635 if (UNEXPECTED(1)) {
32636 ZVAL_COPY(EX_VAR(opline->result.var), value);
32637 }
32638 if (garbage) {
32639 GC_DTOR_NO_REF(garbage);
32640 }
32641 } else {
32642 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32643 }
32644 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32645 /* zend_assign_to_variable() always takes care of op2, never free it! */
32646
32647 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32648}
32649
32650static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32651{
32652 USE_OPLINE
32653 zval *variable_ptr;
32654 zval *value_ptr;
32655 zend_refcounted *garbage = NULL;
32656
32657 SAVE_OPLINE();
32658 value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
32659 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32660
32661 if (IS_VAR == IS_VAR &&
32662 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
32663
32664 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
32665 variable_ptr = &EG(uninitialized_zval);
32666 } else if (IS_CV == IS_VAR &&
32667 opline->extended_value == ZEND_RETURNS_FUNCTION &&
32668 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
32669
32670 variable_ptr = zend_wrong_assign_to_variable_reference(
32671 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
32672 } else {
32673 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
32674 }
32675
32676 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32677 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
32678 }
32679
32680 if (garbage) {
32681 GC_DTOR(garbage);
32682 }
32683
32684 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32685 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32686}
32687
32688static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32689{
32690 USE_OPLINE
32691 zval *property, *container, *value_ptr;
32692
32693 SAVE_OPLINE();
32694
32695 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32696 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32697
32698 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32699
32700 if (1) {
32701 if (IS_VAR == IS_UNUSED) {
32702 if (IS_CV == IS_CONST) {
32703 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32704 } else {
32705 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32706 }
32707 } else {
32708 if (IS_CV == IS_CONST) {
32709 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32710 } else {
32711 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32712 }
32713 }
32714 } else {
32715 zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32716 }
32717
32718 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32719
32720 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32721 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32722}
32723
32724/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
32725static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32726{
32727 USE_OPLINE
32728 zval *property, *container, *value_ptr;
32729
32730 SAVE_OPLINE();
32731
32732 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32733 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32734
32735 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
32736
32737 if (1) {
32738 if (IS_VAR == IS_UNUSED) {
32739 if (IS_CV == IS_CONST) {
32740 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32741 } else {
32742 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32743 }
32744 } else {
32745 if (IS_CV == IS_CONST) {
32746 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32747 } else {
32748 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32749 }
32750 }
32751 } else {
32752 zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32753 }
32754
32755 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32756
32757
32758 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32759}
32760
32761/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
32762static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32763{
32764 USE_OPLINE
32765 zval *function_name;
32766 zend_class_entry *ce;
32767 uint32_t call_info;
32768 zend_function *fbc;
32769 zend_execute_data *call;
32770
32771 SAVE_OPLINE();
32772
32773 if (IS_VAR == IS_CONST) {
32774 /* no function found. try a static method in class */
32775 ce = CACHED_PTR(opline->result.num);
32776 if (UNEXPECTED(ce == NULL)) {
32777 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);
32778 if (UNEXPECTED(ce == NULL)) {
32779
32780 HANDLE_EXCEPTION();
32781 }
32782 if (IS_CV != IS_CONST) {
32783 CACHE_PTR(opline->result.num, ce);
32784 }
32785 }
32786 } else if (IS_VAR == IS_UNUSED) {
32787 ce = zend_fetch_class(NULL, opline->op1.num);
32788 if (UNEXPECTED(ce == NULL)) {
32789
32790 HANDLE_EXCEPTION();
32791 }
32792 } else {
32793 ce = Z_CE_P(EX_VAR(opline->op1.var));
32794 }
32795
32796 if (IS_VAR == IS_CONST &&
32797 IS_CV == IS_CONST &&
32798 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
32799 /* nothing to do */
32800 } else if (IS_VAR != IS_CONST &&
32801 IS_CV == IS_CONST &&
32802 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
32803 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
32804 } else if (IS_CV != IS_UNUSED) {
32805 function_name = EX_VAR(opline->op2.var);
32806 if (IS_CV != IS_CONST) {
32807 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
32808 do {
32809 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
32810 function_name = Z_REFVAL_P(function_name);
32811 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
32812 break;
32813 }
32814 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
32815 ZVAL_UNDEFINED_OP2();
32816 if (UNEXPECTED(EG(exception) != NULL)) {
32817 HANDLE_EXCEPTION();
32818 }
32819 }
32820 zend_throw_error(NULL, "Method name must be a string");
32821
32822 HANDLE_EXCEPTION();
32823 } while (0);
32824 }
32825 }
32826
32827 if (ce->get_static_method) {
32828 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
32829 } else {
32830 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
32831 }
32832 if (UNEXPECTED(fbc == NULL)) {
32833 if (EXPECTED(!EG(exception))) {
32834 zend_undefined_method(ce, Z_STR_P(function_name));
32835 }
32836
32837 HANDLE_EXCEPTION();
32838 }
32839 if (IS_CV == IS_CONST &&
32840 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
32841 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
32842 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
32843 }
32844 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32845 init_func_run_time_cache(&fbc->op_array);
32846 }
32847 if (IS_CV != IS_CONST) {
32848
32849 }
32850 } else {
32851 if (UNEXPECTED(ce->constructor == NULL)) {
32852 zend_throw_error(NULL, "Cannot call constructor");
32853 HANDLE_EXCEPTION();
32854 }
32855 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
32856 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
32857 HANDLE_EXCEPTION();
32858 }
32859 fbc = ce->constructor;
32860 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32861 init_func_run_time_cache(&fbc->op_array);
32862 }
32863 }
32864
32865 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
32866 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
32867 ce = (zend_class_entry*)Z_OBJ(EX(This));
32868 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
32869 } else {
32870 zend_non_static_method_call(fbc);
32871 HANDLE_EXCEPTION();
32872 }
32873 } else {
32874 /* previous opcode is ZEND_FETCH_CLASS */
32875 if (IS_VAR == IS_UNUSED
32876 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
32877 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
32878 if (Z_TYPE(EX(This)) == IS_OBJECT) {
32879 ce = Z_OBJCE(EX(This));
32880 } else {
32881 ce = Z_CE(EX(This));
32882 }
32883 }
32884 call_info = ZEND_CALL_NESTED_FUNCTION;
32885 }
32886
32887 call = zend_vm_stack_push_call_frame(call_info,
32888 fbc, opline->extended_value, ce);
32889 call->prev_execute_data = EX(call);
32890 EX(call) = call;
32891
32892 ZEND_VM_NEXT_OPCODE();
32893}
32894
32895static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32896{
32897 USE_OPLINE
32898 zval *expr_ptr, new_expr;
32899
32900 SAVE_OPLINE();
32901 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
32902 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
32903 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32904 if (Z_ISREF_P(expr_ptr)) {
32905 Z_ADDREF_P(expr_ptr);
32906 } else {
32907 ZVAL_MAKE_REF_EX(expr_ptr, 2);
32908 }
32909 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32910 } else {
32911 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32912 if (IS_VAR == IS_TMP_VAR) {
32913 /* pass */
32914 } else if (IS_VAR == IS_CONST) {
32915 Z_TRY_ADDREF_P(expr_ptr);
32916 } else if (IS_VAR == IS_CV) {
32917 ZVAL_DEREF(expr_ptr);
32918 Z_TRY_ADDREF_P(expr_ptr);
32919 } else /* if (IS_VAR == IS_VAR) */ {
32920 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
32921 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
32922
32923 expr_ptr = Z_REFVAL_P(expr_ptr);
32924 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
32925 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
32926 expr_ptr = &new_expr;
32927 efree_size(ref, sizeof(zend_reference));
32928 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
32929 Z_ADDREF_P(expr_ptr);
32930 }
32931 }
32932 }
32933 }
32934
32935 if (IS_CV != IS_UNUSED) {
32936 zval *offset = EX_VAR(opline->op2.var);
32937 zend_string *str;
32938 zend_ulong hval;
32939
32940add_again:
32941 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
32942 str = Z_STR_P(offset);
32943 if (IS_CV != IS_CONST) {
32944 if (ZEND_HANDLE_NUMERIC(str, hval)) {
32945 goto num_index;
32946 }
32947 }
32948str_index:
32949 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
32950 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
32951 hval = Z_LVAL_P(offset);
32952num_index:
32953 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
32954 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
32955 offset = Z_REFVAL_P(offset);
32956 goto add_again;
32957 } else if (Z_TYPE_P(offset) == IS_NULL) {
32958 str = ZSTR_EMPTY_ALLOC();
32959 goto str_index;
32960 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
32961 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
32962 goto num_index;
32963 } else if (Z_TYPE_P(offset) == IS_FALSE) {
32964 hval = 0;
32965 goto num_index;
32966 } else if (Z_TYPE_P(offset) == IS_TRUE) {
32967 hval = 1;
32968 goto num_index;
32969 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
32970 zend_use_resource_as_offset(offset);
32971 hval = Z_RES_HANDLE_P(offset);
32972 goto num_index;
32973 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
32974 ZVAL_UNDEFINED_OP2();
32975 str = ZSTR_EMPTY_ALLOC();
32976 goto str_index;
32977 } else {
32978 zend_illegal_array_offset_access(offset);
32979 zval_ptr_dtor_nogc(expr_ptr);
32980 }
32981
32982 } else {
32983 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
32984 zend_cannot_add_element();
32985 zval_ptr_dtor_nogc(expr_ptr);
32986 }
32987 }
32988 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32989}
32990
32991static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32992{
32993 zval *array;
32994 uint32_t size;
32995 USE_OPLINE
32996
32997 SAVE_OPLINE();
32998 array = EX_VAR(opline->result.var);
32999 if (IS_VAR != IS_UNUSED) {
33000 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
33001 ZVAL_ARR(array, zend_new_array(size));
33002 /* Explicitly initialize array as not-packed if flag is set */
33003 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
33004 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
33005 }
33006 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33007 } else {
33008 ZVAL_ARR(array, zend_new_array(0));
33009 ZEND_VM_NEXT_OPCODE();
33010 }
33011}
33012
33013static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33014{
33015 USE_OPLINE
33016 zval *container;
33017 zval *offset;
33018 zend_ulong hval;
33019 zend_string *key;
33020
33021 SAVE_OPLINE();
33022 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33023 offset = EX_VAR(opline->op2.var);
33024
33025 do {
33026 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
33027 HashTable *ht;
33028
33029unset_dim_array:
33030 SEPARATE_ARRAY(container);
33031 ht = Z_ARRVAL_P(container);
33032offset_again:
33033 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
33034 key = Z_STR_P(offset);
33035 if (IS_CV != IS_CONST) {
33036 if (ZEND_HANDLE_NUMERIC(key, hval)) {
33037 goto num_index_dim;
33038 }
33039 }
33040str_index_dim:
33041 ZEND_ASSERT(ht != &EG(symbol_table));
33042 zend_hash_del(ht, key);
33043 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
33044 hval = Z_LVAL_P(offset);
33045num_index_dim:
33046 zend_hash_index_del(ht, hval);
33047 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
33048 offset = Z_REFVAL_P(offset);
33049 goto offset_again;
33050 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
33051 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
33052 goto num_index_dim;
33053 } else if (Z_TYPE_P(offset) == IS_NULL) {
33054 key = ZSTR_EMPTY_ALLOC();
33055 goto str_index_dim;
33056 } else if (Z_TYPE_P(offset) == IS_FALSE) {
33057 hval = 0;
33058 goto num_index_dim;
33059 } else if (Z_TYPE_P(offset) == IS_TRUE) {
33060 hval = 1;
33061 goto num_index_dim;
33062 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
33063 zend_use_resource_as_offset(offset);
33064 hval = Z_RES_HANDLE_P(offset);
33065 goto num_index_dim;
33066 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
33067 ZVAL_UNDEFINED_OP2();
33068 key = ZSTR_EMPTY_ALLOC();
33069 goto str_index_dim;
33070 } else {
33071 zend_illegal_array_offset_unset(offset);
33072 }
33073 break;
33074 } else if (Z_ISREF_P(container)) {
33075 container = Z_REFVAL_P(container);
33076 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
33077 goto unset_dim_array;
33078 }
33079 }
33080 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33081 container = ZVAL_UNDEFINED_OP1();
33082 }
33083 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
33084 offset = ZVAL_UNDEFINED_OP2();
33085 }
33086 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33087 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
33088 offset++;
33089 }
33090 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
33091 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
33092 zend_throw_error(NULL, "Cannot unset string offsets");
33093 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
33094 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
33095 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
33096 zend_false_to_array_deprecated();
33097 }
33098 } while (0);
33099
33100 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33101 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33102}
33103
33104static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33105{
33106 USE_OPLINE
33107 zval *container;
33108 zval *offset;
33109 zend_string *name, *tmp_name;
33110
33111 SAVE_OPLINE();
33112 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33113 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
33114
33115 do {
33116 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
33117 if (Z_ISREF_P(container)) {
33118 container = Z_REFVAL_P(container);
33119 if (Z_TYPE_P(container) != IS_OBJECT) {
33120 if (IS_VAR == IS_CV
33121 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33122 ZVAL_UNDEFINED_OP1();
33123 }
33124 break;
33125 }
33126 } else {
33127 break;
33128 }
33129 }
33130 if (IS_CV == IS_CONST) {
33131 name = Z_STR_P(offset);
33132 } else {
33133 name = zval_try_get_tmp_string(offset, &tmp_name);
33134 if (UNEXPECTED(!name)) {
33135 break;
33136 }
33137 }
33138 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
33139 if (IS_CV != IS_CONST) {
33140 zend_tmp_string_release(tmp_name);
33141 }
33142 } while (0);
33143
33144 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33145 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33146}
33147
33148static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33149{
33150 USE_OPLINE
33151
33152 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
33153
33154 SAVE_OPLINE();
33155 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
33156 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33157 }
33158
33159 /* Destroy the previously yielded value */
33160 zval_ptr_dtor(&generator->value);
33161
33162 /* Destroy the previously yielded key */
33163 zval_ptr_dtor(&generator->key);
33164
33165 /* Set the new yielded value */
33166 if (IS_VAR != IS_UNUSED) {
33167 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
33168 /* Constants and temporary variables aren't yieldable by reference,
33169 * but we still allow them with a notice. */
33170 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
33171 zval *value;
33172
33173 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
33174
33175 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33176 ZVAL_COPY_VALUE(&generator->value, value);
33177 if (IS_VAR == IS_CONST) {
33178 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
33179 Z_ADDREF(generator->value);
33180 }
33181 }
33182 } else {
33183 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33184
33185 /* If a function call result is yielded and the function did
33186 * not return by reference we throw a notice. */
33187 do {
33188 if (IS_VAR == IS_VAR) {
33189 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
33190 if (opline->extended_value == ZEND_RETURNS_FUNCTION
33191 && !Z_ISREF_P(value_ptr)) {
33192 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
33193 ZVAL_COPY(&generator->value, value_ptr);
33194 break;
33195 }
33196 }
33197 if (Z_ISREF_P(value_ptr)) {
33198 Z_ADDREF_P(value_ptr);
33199 } else {
33200 ZVAL_MAKE_REF_EX(value_ptr, 2);
33201 }
33202 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
33203 } while (0);
33204
33205 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33206 }
33207 } else {
33208 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33209
33210 /* Consts, temporary variables and references need copying */
33211 if (IS_VAR == IS_CONST) {
33212 ZVAL_COPY_VALUE(&generator->value, value);
33213 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
33214 Z_ADDREF(generator->value);
33215 }
33216 } else if (IS_VAR == IS_TMP_VAR) {
33217 ZVAL_COPY_VALUE(&generator->value, value);
33218 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
33219 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
33220 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33221 } else {
33222 ZVAL_COPY_VALUE(&generator->value, value);
33223 if (IS_VAR == IS_CV) {
33224 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
33225 }
33226 }
33227 }
33228 } else {
33229 /* If no value was specified yield null */
33230 ZVAL_NULL(&generator->value);
33231 }
33232
33233 /* Set the new yielded key */
33234 if (IS_CV != IS_UNUSED) {
33235 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
33236 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
33237 key = Z_REFVAL_P(key);
33238 }
33239 ZVAL_COPY(&generator->key, key);
33240
33241 if (Z_TYPE(generator->key) == IS_LONG
33242 && Z_LVAL(generator->key) > generator->largest_used_integer_key
33243 ) {
33244 generator->largest_used_integer_key = Z_LVAL(generator->key);
33245 }
33246 } else {
33247 /* If no key was specified we use auto-increment keys */
33248 generator->largest_used_integer_key++;
33249 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
33250 }
33251
33252 if (RETURN_VALUE_USED(opline)) {
33253 /* If the return value of yield is used set the send
33254 * target and initialize it to NULL */
33255 generator->send_target = EX_VAR(opline->result.var);
33256 ZVAL_NULL(generator->send_target);
33257 } else {
33258 generator->send_target = NULL;
33259 }
33260
33261 /* The GOTO VM uses a local opline variable. We need to set the opline
33262 * variable in execute_data so we don't resume at an old position. */
33263 SAVE_OPLINE();
33264
33265 ZEND_VM_RETURN();
33266}
33267
33268static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33269{
33270 USE_OPLINE
33271 zval *array;
33272 zval *value, *variable_ptr;
33273 uint32_t value_type;
33274 HashTable *fe_ht;
33275 HashPosition pos;
33276
33277 array = EX_VAR(opline->op1.var);
33278 SAVE_OPLINE();
33279 fe_ht = Z_ARRVAL_P(array);
33280 pos = Z_FE_POS_P(array);
33281 if (HT_IS_PACKED(fe_ht)) {
33282 value = fe_ht->arPacked + pos;
33283 while (1) {
33284 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33285 /* reached end of iteration */
33286 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33287 ZEND_VM_CONTINUE();
33288 }
33289 value_type = Z_TYPE_INFO_P(value);
33290 ZEND_ASSERT(value_type != IS_INDIRECT);
33291 if (EXPECTED(value_type != IS_UNDEF)) {
33292 break;
33293 }
33294 pos++;
33295 value++;
33296 }
33297 Z_FE_POS_P(array) = pos + 1;
33298 if (0) {
33299 ZVAL_LONG(EX_VAR(opline->result.var), pos);
33300 }
33301 } else {
33302 Bucket *p;
33303
33304 p = fe_ht->arData + pos;
33305 while (1) {
33306 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33307 /* reached end of iteration */
33308 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33309 ZEND_VM_CONTINUE();
33310 }
33311 pos++;
33312 value = &p->val;
33313 value_type = Z_TYPE_INFO_P(value);
33314 ZEND_ASSERT(value_type != IS_INDIRECT);
33315 if (EXPECTED(value_type != IS_UNDEF)) {
33316 break;
33317 }
33318 p++;
33319 }
33320 Z_FE_POS_P(array) = pos;
33321 if (0) {
33322 if (!p->key) {
33323 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
33324 } else {
33325 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
33326 }
33327 }
33328 }
33329
33330 variable_ptr = EX_VAR(opline->op2.var);
33331 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
33332 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33333}
33334
33335
33336static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33337{
33338 USE_OPLINE
33339 zval *array;
33340 zval *value, *variable_ptr;
33341 uint32_t value_type;
33342 HashTable *fe_ht;
33343 HashPosition pos;
33344
33345 array = EX_VAR(opline->op1.var);
33346 SAVE_OPLINE();
33347 fe_ht = Z_ARRVAL_P(array);
33348 pos = Z_FE_POS_P(array);
33349 if (HT_IS_PACKED(fe_ht)) {
33350 value = fe_ht->arPacked + pos;
33351 while (1) {
33352 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33353 /* reached end of iteration */
33354 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33355 ZEND_VM_CONTINUE();
33356 }
33357 value_type = Z_TYPE_INFO_P(value);
33358 ZEND_ASSERT(value_type != IS_INDIRECT);
33359 if (EXPECTED(value_type != IS_UNDEF)) {
33360 break;
33361 }
33362 pos++;
33363 value++;
33364 }
33365 Z_FE_POS_P(array) = pos + 1;
33366 if (1) {
33367 ZVAL_LONG(EX_VAR(opline->result.var), pos);
33368 }
33369 } else {
33370 Bucket *p;
33371
33372 p = fe_ht->arData + pos;
33373 while (1) {
33374 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33375 /* reached end of iteration */
33376 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33377 ZEND_VM_CONTINUE();
33378 }
33379 pos++;
33380 value = &p->val;
33381 value_type = Z_TYPE_INFO_P(value);
33382 ZEND_ASSERT(value_type != IS_INDIRECT);
33383 if (EXPECTED(value_type != IS_UNDEF)) {
33384 break;
33385 }
33386 p++;
33387 }
33388 Z_FE_POS_P(array) = pos;
33389 if (1) {
33390 if (!p->key) {
33391 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
33392 } else {
33393 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
33394 }
33395 }
33396 }
33397
33398 variable_ptr = EX_VAR(opline->op2.var);
33399 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
33400 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33401}
33402
33403
33404static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33405{
33406 USE_OPLINE
33407 zval *obj;
33408 zend_object *zobj;
33409 zend_class_entry *ce, *scope;
33410 zend_function *clone;
33411 zend_object_clone_obj_t clone_call;
33412
33413 SAVE_OPLINE();
33414 obj = &EX(This);
33415
33416 do {
33417 if (IS_UNUSED == IS_CONST ||
33418 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
33419 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
33420 obj = Z_REFVAL_P(obj);
33421 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
33422 break;
33423 }
33424 }
33425 ZVAL_UNDEF(EX_VAR(opline->result.var));
33426 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
33427 ZVAL_UNDEFINED_OP1();
33428 if (UNEXPECTED(EG(exception) != NULL)) {
33429 HANDLE_EXCEPTION();
33430 }
33431 }
33432 zend_throw_error(NULL, "__clone method called on non-object");
33433
33434 HANDLE_EXCEPTION();
33435 }
33436 } while (0);
33437
33438 zobj = Z_OBJ_P(obj);
33439 ce = zobj->ce;
33440 clone = ce->clone;
33441 clone_call = zobj->handlers->clone_obj;
33442 if (UNEXPECTED(clone_call == NULL)) {
33443 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
33444
33445 ZVAL_UNDEF(EX_VAR(opline->result.var));
33446 HANDLE_EXCEPTION();
33447 }
33448
33449 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
33450 scope = EX(func)->op_array.scope;
33451 if (clone->common.scope != scope) {
33452 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
33453 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
33454 zend_wrong_clone_call(clone, scope);
33455
33456 ZVAL_UNDEF(EX_VAR(opline->result.var));
33457 HANDLE_EXCEPTION();
33458 }
33459 }
33460 }
33461
33462 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
33463
33464 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33465}
33466
33467static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33468{
33469 uint32_t fetch_type;
33470 zend_class_entry *called_scope, *scope;
33471 USE_OPLINE
33472
33473 if (IS_UNUSED != IS_UNUSED) {
33474 SAVE_OPLINE();
33475 zval *op = NULL;
33476 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
33477 ZVAL_DEREF(op);
33478 if (Z_TYPE_P(op) != IS_OBJECT) {
33479 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
33480 ZVAL_UNDEF(EX_VAR(opline->result.var));
33481
33482 HANDLE_EXCEPTION();
33483 }
33484 }
33485
33486 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
33487
33488 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33489 }
33490
33491 fetch_type = opline->op1.num;
33492 scope = EX(func)->op_array.scope;
33493 if (UNEXPECTED(scope == NULL)) {
33494 SAVE_OPLINE();
33495 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
33496 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
33497 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
33498 ZVAL_UNDEF(EX_VAR(opline->result.var));
33499 HANDLE_EXCEPTION();
33500 }
33501
33502 switch (fetch_type) {
33503 case ZEND_FETCH_CLASS_SELF:
33504 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
33505 break;
33506 case ZEND_FETCH_CLASS_PARENT:
33507 if (UNEXPECTED(scope->parent == NULL)) {
33508 SAVE_OPLINE();
33509 zend_throw_error(NULL,
33510 "Cannot use \"parent\" when current class scope has no parent");
33511 ZVAL_UNDEF(EX_VAR(opline->result.var));
33512 HANDLE_EXCEPTION();
33513 }
33514 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
33515 break;
33516 case ZEND_FETCH_CLASS_STATIC:
33517 if (Z_TYPE(EX(This)) == IS_OBJECT) {
33518 called_scope = Z_OBJCE(EX(This));
33519 } else {
33520 called_scope = Z_CE(EX(This));
33521 }
33522 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
33523 break;
33524 EMPTY_SWITCH_DEFAULT_CASE()
33525 }
33526 ZEND_VM_NEXT_OPCODE();
33527}
33528
33529static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33530{
33531 USE_OPLINE
33532 zval *object;
33533 zval *property;
33534 zval *value;
33535 zval *zptr;
33536 void *_cache_slot[3] = {0};
33537 void **cache_slot;
33538 zend_property_info *prop_info;
33539 zend_object *zobj;
33540 zend_string *name, *tmp_name;
33541
33542 SAVE_OPLINE();
33543 object = &EX(This);
33544 property = RT_CONSTANT(opline, opline->op2);
33545
33546 do {
33547 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
33548
33549 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33550 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33551 object = Z_REFVAL_P(object);
33552 goto assign_op_object;
33553 }
33554 if (IS_UNUSED == IS_CV
33555 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33556 ZVAL_UNDEFINED_OP1();
33557 }
33558 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33559 break;
33560 }
33561
33562assign_op_object:
33563 /* here we are sure we are dealing with an object */
33564 zobj = Z_OBJ_P(object);
33565 if (IS_CONST == IS_CONST) {
33566 name = Z_STR_P(property);
33567 } else {
33568 name = zval_try_get_tmp_string(property, &tmp_name);
33569 if (UNEXPECTED(!name)) {
33570 UNDEF_RESULT();
33571 break;
33572 }
33573 }
33574 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
33575 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33576 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33577 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33578 ZVAL_NULL(EX_VAR(opline->result.var));
33579 }
33580 } else {
33581 zend_reference *ref;
33582
33583 do {
33584 if (UNEXPECTED(Z_ISREF_P(zptr))) {
33585 ref = Z_REF_P(zptr);
33586 zptr = Z_REFVAL_P(zptr);
33587 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
33588 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
33589 break;
33590 }
33591 }
33592
33593 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
33594 if (prop_info) {
33595 /* special case for typed properties */
33596 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
33597 } else {
33598 zend_binary_op(zptr, zptr, value OPLINE_CC);
33599 }
33600 } while (0);
33601
33602 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33603 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
33604 }
33605 }
33606 } else {
33607 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
33608 }
33609 if (IS_CONST != IS_CONST) {
33610 zend_tmp_string_release(tmp_name);
33611 }
33612 } while (0);
33613
33614 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
33615
33616
33617 /* assign_obj has two opcodes! */
33618 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33619}
33620
33621/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
33622static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33623{
33624 USE_OPLINE
33625 zval *object;
33626 zval *property;
33627 zval *zptr;
33628 void *_cache_slot[3] = {0};
33629 void **cache_slot;
33630 zend_property_info *prop_info;
33631 zend_object *zobj;
33632 zend_string *name, *tmp_name;
33633
33634 SAVE_OPLINE();
33635 object = &EX(This);
33636 property = RT_CONSTANT(opline, opline->op2);
33637
33638 do {
33639 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33640 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33641 object = Z_REFVAL_P(object);
33642 goto pre_incdec_object;
33643 }
33644 if (IS_UNUSED == IS_CV
33645 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33646 ZVAL_UNDEFINED_OP1();
33647 }
33648 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33649 break;
33650 }
33651
33652pre_incdec_object:
33653 /* here we are sure we are dealing with an object */
33654 zobj = Z_OBJ_P(object);
33655 if (IS_CONST == IS_CONST) {
33656 name = Z_STR_P(property);
33657 } else {
33658 name = zval_try_get_tmp_string(property, &tmp_name);
33659 if (UNEXPECTED(!name)) {
33660 UNDEF_RESULT();
33661 break;
33662 }
33663 }
33664 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
33665 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33666 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33667 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33668 ZVAL_NULL(EX_VAR(opline->result.var));
33669 }
33670 } else {
33671 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
33672 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
33673 }
33674 } else {
33675 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
33676 }
33677 if (IS_CONST != IS_CONST) {
33678 zend_tmp_string_release(tmp_name);
33679 }
33680 } while (0);
33681
33682
33683 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33684}
33685
33686static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33687{
33688 USE_OPLINE
33689 zval *object;
33690 zval *property;
33691 zval *zptr;
33692 void *_cache_slot[3] = {0};
33693 void **cache_slot;
33694 zend_property_info *prop_info;
33695 zend_object *zobj;
33696 zend_string *name, *tmp_name;
33697
33698 SAVE_OPLINE();
33699 object = &EX(This);
33700 property = RT_CONSTANT(opline, opline->op2);
33701
33702 do {
33703 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33704 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33705 object = Z_REFVAL_P(object);
33706 goto post_incdec_object;
33707 }
33708 if (IS_UNUSED == IS_CV
33709 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33710 ZVAL_UNDEFINED_OP1();
33711 }
33712 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33713 break;
33714 }
33715
33716post_incdec_object:
33717 /* here we are sure we are dealing with an object */
33718 zobj = Z_OBJ_P(object);
33719 if (IS_CONST == IS_CONST) {
33720 name = Z_STR_P(property);
33721 } else {
33722 name = zval_try_get_tmp_string(property, &tmp_name);
33723 if (UNEXPECTED(!name)) {
33724 ZVAL_UNDEF(EX_VAR(opline->result.var));
33725 break;
33726 }
33727 }
33728 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
33729 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33730 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33731 ZVAL_NULL(EX_VAR(opline->result.var));
33732 } else {
33733 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
33734 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
33735 }
33736 } else {
33737 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
33738 }
33739 if (IS_CONST != IS_CONST) {
33740 zend_tmp_string_release(tmp_name);
33741 }
33742 } while (0);
33743
33744
33745 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33746}
33747
33748static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33749{
33750 USE_OPLINE
33751 zval *container;
33752 void **cache_slot = NULL;
33753
33754 SAVE_OPLINE();
33755 container = &EX(This);
33756
33757 if (IS_UNUSED == IS_CONST ||
33758 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
33759 do {
33760 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
33761 container = Z_REFVAL_P(container);
33762 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33763 break;
33764 }
33765 }
33766 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33767 ZVAL_UNDEFINED_OP1();
33768 }
33769 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
33770 ZVAL_NULL(EX_VAR(opline->result.var));
33771 goto fetch_obj_r_finish;
33772 } while (0);
33773 }
33774
33775 /* here we are sure we are dealing with an object */
33776 do {
33777 zend_object *zobj = Z_OBJ_P(container);
33778 zend_string *name, *tmp_name;
33779 zval *retval;
33780
33781 if (IS_CONST == IS_CONST) {
33782 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
33783
33784 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
33785 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33786
33787 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33788fetch_obj_r_simple:
33789 retval = OBJ_PROP(zobj, prop_offset);
33790 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
33791 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33792 goto fetch_obj_r_copy;
33793 } else {
33794fetch_obj_r_fast_copy:
33795 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33796 ZEND_VM_NEXT_OPCODE();
33797 }
33798 }
33799 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
33800 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
33801 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
33802 prop_offset = prop_info->offset;
33803 goto fetch_obj_r_simple;
33804 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
33805 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
33806 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
33807 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
33808
33809 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
33810 if (IS_UNUSED & IS_CV) {
33811 GC_ADDREF(zobj);
33812 }
33813 if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
33814 call_info |= ZEND_CALL_RELEASE_THIS;
33815 }
33816 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
33817 call->prev_execute_data = execute_data;
33818 call->call = NULL;
33819 call->return_value = EX_VAR(opline->result.var);
33820 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
33821
33822 execute_data = call;
33823 EG(current_execute_data) = execute_data;
33824 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
33825
33826#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
33827 opline = hook->op_array.opcodes;
33828#else
33829 EX(opline) = hook->op_array.opcodes;
33830#endif
33831 LOAD_OPLINE_EX();
33832
33833
33834 ZEND_VM_ENTER_EX();
33835 }
33836 /* Fall through to read_property for hooks. */
33837 } else if (EXPECTED(zobj->properties != NULL)) {
33838 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
33839 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33840 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
33841 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
33842
33843 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
33844 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
33845
33846 if (EXPECTED(p->key == name) ||
33847 (EXPECTED(p->h == ZSTR_H(name)) &&
33848 EXPECTED(p->key != NULL) &&
33849 EXPECTED(zend_string_equal_content(p->key, name)))) {
33850 retval = &p->val;
33851 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33852 goto fetch_obj_r_copy;
33853 } else {
33854 goto fetch_obj_r_fast_copy;
33855 }
33856 }
33857 }
33858 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
33859 }
33860 retval = zend_hash_find_known_hash(zobj->properties, name);
33861 if (EXPECTED(retval)) {
33862 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
33863 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
33864 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33865 goto fetch_obj_r_copy;
33866 } else {
33867 goto fetch_obj_r_fast_copy;
33868 }
33869 }
33870 }
33871 }
33872 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33873 } else {
33874 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33875 if (UNEXPECTED(!name)) {
33876 ZVAL_UNDEF(EX_VAR(opline->result.var));
33877 break;
33878 }
33879 }
33880
33881#if ZEND_DEBUG
33882 /* For non-standard object handlers, verify a declared property type in debug builds.
33883 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
33884 zend_property_info *prop_info = NULL;
33885 if (zobj->handlers->read_property != zend_std_read_property) {
33886 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
33887 }
33888#endif
33889 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
33890#if ZEND_DEBUG
33891 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
33892 && ZEND_TYPE_IS_SET(prop_info->type)) {
33893 ZVAL_OPT_DEREF(retval);
33894 zend_verify_property_type(prop_info, retval, /* strict */ true);
33895 }
33896#endif
33897
33898 if (IS_CONST != IS_CONST) {
33899 zend_tmp_string_release(tmp_name);
33900 }
33901
33902 if (retval != EX_VAR(opline->result.var)) {
33903fetch_obj_r_copy:
33904 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33905 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
33906 zend_unwrap_reference(retval);
33907 }
33908 } while (0);
33909
33910fetch_obj_r_finish:
33911
33912
33913 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33914}
33915
33916static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33917{
33918 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33919}
33920
33921static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33922{
33923 USE_OPLINE
33924 zval *property, *container, *result;
33925
33926 SAVE_OPLINE();
33927
33928 container = &EX(This);
33929 property = RT_CONSTANT(opline, opline->op2);
33930 result = EX_VAR(opline->result.var);
33931 zend_fetch_property_address(
33932 result, container, IS_UNUSED, property, IS_CONST,
33933 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
33934 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
33935
33936 if (IS_UNUSED == IS_VAR) {
33937 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
33938 }
33939 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33940}
33941
33942static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33943{
33944 USE_OPLINE
33945 zval *property, *container, *result;
33946
33947 SAVE_OPLINE();
33948 container = &EX(This);
33949 property = RT_CONSTANT(opline, opline->op2);
33950 result = EX_VAR(opline->result.var);
33951 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);
33952
33953 if (IS_UNUSED == IS_VAR) {
33954 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
33955 }
33956 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33957}
33958
33959static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33960{
33961 USE_OPLINE
33962 zval *container;
33963 void **cache_slot = NULL;
33964
33965 SAVE_OPLINE();
33966 container = &EX(This);
33967
33968 if (IS_UNUSED == IS_CONST ||
33969 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
33970 do {
33971 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
33972 container = Z_REFVAL_P(container);
33973 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33974 break;
33975 }
33976 }
33977 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
33978 ZVAL_UNDEFINED_OP2();
33979 }
33980 ZVAL_NULL(EX_VAR(opline->result.var));
33981 goto fetch_obj_is_finish;
33982 } while (0);
33983 }
33984
33985 /* here we are sure we are dealing with an object */
33986 do {
33987 zend_object *zobj = Z_OBJ_P(container);
33988 zend_string *name, *tmp_name;
33989 zval *retval;
33990
33991 if (IS_CONST == IS_CONST) {
33992 cache_slot = CACHE_ADDR(opline->extended_value);
33993
33994 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
33995 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33996
33997 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33998fetch_obj_is_simple:
33999 retval = OBJ_PROP(zobj, prop_offset);
34000 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
34001 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
34002 goto fetch_obj_is_copy;
34003 } else {
34004fetch_obj_is_fast_copy:
34005 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
34006 ZEND_VM_NEXT_OPCODE();
34007 }
34008 }
34009 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
34010 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
34011 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
34012 prop_offset = prop_info->offset;
34013 goto fetch_obj_is_simple;
34014 }
34015 /* Fall through to read_property for hooks. */
34016 } else if (EXPECTED(zobj->properties != NULL)) {
34017 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
34018 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34019 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
34020 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
34021
34022 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
34023 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
34024
34025 if (EXPECTED(p->key == name) ||
34026 (EXPECTED(p->h == ZSTR_H(name)) &&
34027 EXPECTED(p->key != NULL) &&
34028 EXPECTED(zend_string_equal_content(p->key, name)))) {
34029 retval = &p->val;
34030 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
34031 goto fetch_obj_is_copy;
34032 } else {
34033 goto fetch_obj_is_fast_copy;
34034 }
34035 }
34036 }
34037 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
34038 }
34039 retval = zend_hash_find_known_hash(zobj->properties, name);
34040 if (EXPECTED(retval)) {
34041 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
34042 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
34043 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
34044 goto fetch_obj_is_copy;
34045 } else {
34046 goto fetch_obj_is_fast_copy;
34047 }
34048 }
34049 }
34050 }
34051 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34052 } else {
34053 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34054 if (UNEXPECTED(!name)) {
34055 ZVAL_UNDEF(EX_VAR(opline->result.var));
34056 break;
34057 }
34058 }
34059
34060 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
34061
34062 if (IS_CONST != IS_CONST) {
34063 zend_tmp_string_release(tmp_name);
34064 }
34065
34066 if (retval != EX_VAR(opline->result.var)) {
34067fetch_obj_is_copy:
34068 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
34069 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
34070 zend_unwrap_reference(retval);
34071 }
34072 } while (0);
34073
34074fetch_obj_is_finish:
34075
34076
34077 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34078}
34079
34080static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34081{
34082#if 0
34083 USE_OPLINE
34084#endif
34085
34086 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
34087 /* Behave like FETCH_OBJ_W */
34088 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
34089 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34090 }
34091 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34092 } else {
34093 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34094 }
34095}
34096
34097static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34098{
34099 USE_OPLINE
34100 zval *container, *property, *result;
34101
34102 SAVE_OPLINE();
34103 container = &EX(This);
34104 property = RT_CONSTANT(opline, opline->op2);
34105 result = EX_VAR(opline->result.var);
34106 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);
34107
34108 if (IS_UNUSED == IS_VAR) {
34109 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
34110 }
34111 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34112}
34113
34114static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34115{
34116 USE_OPLINE
34117 zval *object, *value, tmp;
34118 zend_object *zobj;
34119 zend_string *name, *tmp_name;
34120 zend_refcounted *garbage = NULL;
34121
34122 SAVE_OPLINE();
34123 object = &EX(This);
34124 value = RT_CONSTANT((opline+1), (opline+1)->op1);
34125
34126 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34127 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34128 object = Z_REFVAL_P(object);
34129 goto assign_object;
34130 }
34131 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34132 value = &EG(uninitialized_zval);
34133 goto free_and_exit_assign_obj;
34134 }
34135
34136assign_object:
34137 zobj = Z_OBJ_P(object);
34138 if (IS_CONST == IS_CONST) {
34139 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34140 void **cache_slot = CACHE_ADDR(opline->extended_value);
34141 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34142 zval *property_val;
34143 zend_property_info *prop_info;
34144
34145 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34146 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34147
34148assign_obj_simple:
34149 property_val = OBJ_PROP(zobj, prop_offset);
34150 if (Z_TYPE_P(property_val) != IS_UNDEF) {
34151 if (prop_info != NULL) {
34152 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34153 goto free_and_exit_assign_obj;
34154 } else {
34155fast_assign_obj:
34156 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
34157 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34158 ZVAL_COPY(EX_VAR(opline->result.var), value);
34159 }
34160 goto exit_assign_obj;
34161 }
34162 }
34163 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34164 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34165 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34166 zobj = zend_lazy_object_init(zobj);
34167 if (!zobj) {
34168 value = &EG(uninitialized_zval);
34169 goto free_and_exit_assign_obj;
34170 }
34171 }
34172 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34173 rebuild_object_properties_internal(zobj);
34174 }
34175 if (EXPECTED(zobj->properties != NULL)) {
34176 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34177 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34178 GC_DELREF(zobj->properties);
34179 }
34180 zobj->properties = zend_array_dup(zobj->properties);
34181 }
34182 property_val = zend_hash_find_known_hash(zobj->properties, name);
34183 if (property_val) {
34184 goto fast_assign_obj;
34185 }
34186 }
34187
34188 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34189 if (IS_CONST == IS_CONST) {
34190 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34191 Z_ADDREF_P(value);
34192 }
34193 } else if (IS_CONST != IS_TMP_VAR) {
34194 if (Z_ISREF_P(value)) {
34195 if (IS_CONST == IS_VAR) {
34196 zend_reference *ref = Z_REF_P(value);
34197 if (GC_DELREF(ref) == 0) {
34198 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34199 efree_size(ref, sizeof(zend_reference));
34200 value = &tmp;
34201 } else {
34202 value = Z_REFVAL_P(value);
34203 Z_TRY_ADDREF_P(value);
34204 }
34205 } else {
34206 value = Z_REFVAL_P(value);
34207 Z_TRY_ADDREF_P(value);
34208 }
34209 } else if (IS_CONST == IS_CV) {
34210 Z_TRY_ADDREF_P(value);
34211 }
34212 }
34213 zend_hash_add_new(zobj->properties, name, value);
34214 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34215 ZVAL_COPY(EX_VAR(opline->result.var), value);
34216 }
34217 goto exit_assign_obj;
34218 }
34219 } else {
34220 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34221 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34222 prop_info = CACHED_PTR_EX(cache_slot + 2);
34223 prop_offset = prop_info->offset;
34224 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34225 prop_info = NULL;
34226 }
34227 goto assign_obj_simple;
34228 }
34229 /* Fall through to write_property for hooks. */
34230 }
34231 }
34232 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34233 } else {
34234 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34235 if (UNEXPECTED(!name)) {
34236
34237 UNDEF_RESULT();
34238 goto exit_assign_obj;
34239 }
34240 }
34241
34242 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
34243 ZVAL_DEREF(value);
34244 }
34245
34246 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34247
34248 if (IS_CONST != IS_CONST) {
34249 zend_tmp_string_release(tmp_name);
34250 }
34251
34252free_and_exit_assign_obj:
34253 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34254 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34255 }
34256
34257exit_assign_obj:
34258 if (garbage) {
34259 GC_DTOR_NO_REF(garbage);
34260 }
34261
34262
34263 /* assign_obj has two opcodes! */
34264 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34265}
34266
34267/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34268static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34269{
34270 USE_OPLINE
34271 zval *object, *value, tmp;
34272 zend_object *zobj;
34273 zend_string *name, *tmp_name;
34274 zend_refcounted *garbage = NULL;
34275
34276 SAVE_OPLINE();
34277 object = &EX(This);
34278 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
34279
34280 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34281 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34282 object = Z_REFVAL_P(object);
34283 goto assign_object;
34284 }
34285 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34286 value = &EG(uninitialized_zval);
34287 goto free_and_exit_assign_obj;
34288 }
34289
34290assign_object:
34291 zobj = Z_OBJ_P(object);
34292 if (IS_CONST == IS_CONST) {
34293 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34294 void **cache_slot = CACHE_ADDR(opline->extended_value);
34295 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34296 zval *property_val;
34297 zend_property_info *prop_info;
34298
34299 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34300 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34301
34302assign_obj_simple:
34303 property_val = OBJ_PROP(zobj, prop_offset);
34304 if (Z_TYPE_P(property_val) != IS_UNDEF) {
34305 if (prop_info != NULL) {
34306 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34307 goto free_and_exit_assign_obj;
34308 } else {
34309fast_assign_obj:
34310 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
34311 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34312 ZVAL_COPY(EX_VAR(opline->result.var), value);
34313 }
34314 goto exit_assign_obj;
34315 }
34316 }
34317 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34318 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34319 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34320 zobj = zend_lazy_object_init(zobj);
34321 if (!zobj) {
34322 value = &EG(uninitialized_zval);
34323 goto free_and_exit_assign_obj;
34324 }
34325 }
34326 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34327 rebuild_object_properties_internal(zobj);
34328 }
34329 if (EXPECTED(zobj->properties != NULL)) {
34330 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34331 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34332 GC_DELREF(zobj->properties);
34333 }
34334 zobj->properties = zend_array_dup(zobj->properties);
34335 }
34336 property_val = zend_hash_find_known_hash(zobj->properties, name);
34337 if (property_val) {
34338 goto fast_assign_obj;
34339 }
34340 }
34341
34342 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34343 if (IS_TMP_VAR == IS_CONST) {
34344 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34345 Z_ADDREF_P(value);
34346 }
34347 } else if (IS_TMP_VAR != IS_TMP_VAR) {
34348 if (Z_ISREF_P(value)) {
34349 if (IS_TMP_VAR == IS_VAR) {
34350 zend_reference *ref = Z_REF_P(value);
34351 if (GC_DELREF(ref) == 0) {
34352 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34353 efree_size(ref, sizeof(zend_reference));
34354 value = &tmp;
34355 } else {
34356 value = Z_REFVAL_P(value);
34357 Z_TRY_ADDREF_P(value);
34358 }
34359 } else {
34360 value = Z_REFVAL_P(value);
34361 Z_TRY_ADDREF_P(value);
34362 }
34363 } else if (IS_TMP_VAR == IS_CV) {
34364 Z_TRY_ADDREF_P(value);
34365 }
34366 }
34367 zend_hash_add_new(zobj->properties, name, value);
34368 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34369 ZVAL_COPY(EX_VAR(opline->result.var), value);
34370 }
34371 goto exit_assign_obj;
34372 }
34373 } else {
34374 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34375 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34376 prop_info = CACHED_PTR_EX(cache_slot + 2);
34377 prop_offset = prop_info->offset;
34378 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34379 prop_info = NULL;
34380 }
34381 goto assign_obj_simple;
34382 }
34383 /* Fall through to write_property for hooks. */
34384 }
34385 }
34386 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34387 } else {
34388 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34389 if (UNEXPECTED(!name)) {
34390 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34391 UNDEF_RESULT();
34392 goto exit_assign_obj;
34393 }
34394 }
34395
34396 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
34397 ZVAL_DEREF(value);
34398 }
34399
34400 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34401
34402 if (IS_CONST != IS_CONST) {
34403 zend_tmp_string_release(tmp_name);
34404 }
34405
34406free_and_exit_assign_obj:
34407 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34408 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34409 }
34410 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34411exit_assign_obj:
34412 if (garbage) {
34413 GC_DTOR_NO_REF(garbage);
34414 }
34415
34416
34417 /* assign_obj has two opcodes! */
34418 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34419}
34420
34421/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34422static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34423{
34424 USE_OPLINE
34425 zval *object, *value, tmp;
34426 zend_object *zobj;
34427 zend_string *name, *tmp_name;
34428 zend_refcounted *garbage = NULL;
34429
34430 SAVE_OPLINE();
34431 object = &EX(This);
34432 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
34433
34434 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34435 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34436 object = Z_REFVAL_P(object);
34437 goto assign_object;
34438 }
34439 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34440 value = &EG(uninitialized_zval);
34441 goto free_and_exit_assign_obj;
34442 }
34443
34444assign_object:
34445 zobj = Z_OBJ_P(object);
34446 if (IS_CONST == IS_CONST) {
34447 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34448 void **cache_slot = CACHE_ADDR(opline->extended_value);
34449 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34450 zval *property_val;
34451 zend_property_info *prop_info;
34452
34453 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34454 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34455
34456assign_obj_simple:
34457 property_val = OBJ_PROP(zobj, prop_offset);
34458 if (Z_TYPE_P(property_val) != IS_UNDEF) {
34459 if (prop_info != NULL) {
34460 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34461 goto free_and_exit_assign_obj;
34462 } else {
34463fast_assign_obj:
34464 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
34465 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34466 ZVAL_COPY(EX_VAR(opline->result.var), value);
34467 }
34468 goto exit_assign_obj;
34469 }
34470 }
34471 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34472 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34473 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34474 zobj = zend_lazy_object_init(zobj);
34475 if (!zobj) {
34476 value = &EG(uninitialized_zval);
34477 goto free_and_exit_assign_obj;
34478 }
34479 }
34480 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34481 rebuild_object_properties_internal(zobj);
34482 }
34483 if (EXPECTED(zobj->properties != NULL)) {
34484 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34485 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34486 GC_DELREF(zobj->properties);
34487 }
34488 zobj->properties = zend_array_dup(zobj->properties);
34489 }
34490 property_val = zend_hash_find_known_hash(zobj->properties, name);
34491 if (property_val) {
34492 goto fast_assign_obj;
34493 }
34494 }
34495
34496 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34497 if (IS_VAR == IS_CONST) {
34498 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34499 Z_ADDREF_P(value);
34500 }
34501 } else if (IS_VAR != IS_TMP_VAR) {
34502 if (Z_ISREF_P(value)) {
34503 if (IS_VAR == IS_VAR) {
34504 zend_reference *ref = Z_REF_P(value);
34505 if (GC_DELREF(ref) == 0) {
34506 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34507 efree_size(ref, sizeof(zend_reference));
34508 value = &tmp;
34509 } else {
34510 value = Z_REFVAL_P(value);
34511 Z_TRY_ADDREF_P(value);
34512 }
34513 } else {
34514 value = Z_REFVAL_P(value);
34515 Z_TRY_ADDREF_P(value);
34516 }
34517 } else if (IS_VAR == IS_CV) {
34518 Z_TRY_ADDREF_P(value);
34519 }
34520 }
34521 zend_hash_add_new(zobj->properties, name, value);
34522 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34523 ZVAL_COPY(EX_VAR(opline->result.var), value);
34524 }
34525 goto exit_assign_obj;
34526 }
34527 } else {
34528 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34529 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34530 prop_info = CACHED_PTR_EX(cache_slot + 2);
34531 prop_offset = prop_info->offset;
34532 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34533 prop_info = NULL;
34534 }
34535 goto assign_obj_simple;
34536 }
34537 /* Fall through to write_property for hooks. */
34538 }
34539 }
34540 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34541 } else {
34542 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34543 if (UNEXPECTED(!name)) {
34544 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34545 UNDEF_RESULT();
34546 goto exit_assign_obj;
34547 }
34548 }
34549
34550 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
34551 ZVAL_DEREF(value);
34552 }
34553
34554 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34555
34556 if (IS_CONST != IS_CONST) {
34557 zend_tmp_string_release(tmp_name);
34558 }
34559
34560free_and_exit_assign_obj:
34561 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34562 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34563 }
34564 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34565exit_assign_obj:
34566 if (garbage) {
34567 GC_DTOR_NO_REF(garbage);
34568 }
34569
34570
34571 /* assign_obj has two opcodes! */
34572 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34573}
34574
34575/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34576static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34577{
34578 USE_OPLINE
34579 zval *object, *value, tmp;
34580 zend_object *zobj;
34581 zend_string *name, *tmp_name;
34582 zend_refcounted *garbage = NULL;
34583
34584 SAVE_OPLINE();
34585 object = &EX(This);
34586 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
34587
34588 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34589 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34590 object = Z_REFVAL_P(object);
34591 goto assign_object;
34592 }
34593 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34594 value = &EG(uninitialized_zval);
34595 goto free_and_exit_assign_obj;
34596 }
34597
34598assign_object:
34599 zobj = Z_OBJ_P(object);
34600 if (IS_CONST == IS_CONST) {
34601 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34602 void **cache_slot = CACHE_ADDR(opline->extended_value);
34603 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34604 zval *property_val;
34605 zend_property_info *prop_info;
34606
34607 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34608 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34609
34610assign_obj_simple:
34611 property_val = OBJ_PROP(zobj, prop_offset);
34612 if (Z_TYPE_P(property_val) != IS_UNDEF) {
34613 if (prop_info != NULL) {
34614 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34615 goto free_and_exit_assign_obj;
34616 } else {
34617fast_assign_obj:
34618 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
34619 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34620 ZVAL_COPY(EX_VAR(opline->result.var), value);
34621 }
34622 goto exit_assign_obj;
34623 }
34624 }
34625 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34626 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34627 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34628 zobj = zend_lazy_object_init(zobj);
34629 if (!zobj) {
34630 value = &EG(uninitialized_zval);
34631 goto free_and_exit_assign_obj;
34632 }
34633 }
34634 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34635 rebuild_object_properties_internal(zobj);
34636 }
34637 if (EXPECTED(zobj->properties != NULL)) {
34638 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34639 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34640 GC_DELREF(zobj->properties);
34641 }
34642 zobj->properties = zend_array_dup(zobj->properties);
34643 }
34644 property_val = zend_hash_find_known_hash(zobj->properties, name);
34645 if (property_val) {
34646 goto fast_assign_obj;
34647 }
34648 }
34649
34650 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34651 if (IS_CV == IS_CONST) {
34652 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34653 Z_ADDREF_P(value);
34654 }
34655 } else if (IS_CV != IS_TMP_VAR) {
34656 if (Z_ISREF_P(value)) {
34657 if (IS_CV == IS_VAR) {
34658 zend_reference *ref = Z_REF_P(value);
34659 if (GC_DELREF(ref) == 0) {
34660 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34661 efree_size(ref, sizeof(zend_reference));
34662 value = &tmp;
34663 } else {
34664 value = Z_REFVAL_P(value);
34665 Z_TRY_ADDREF_P(value);
34666 }
34667 } else {
34668 value = Z_REFVAL_P(value);
34669 Z_TRY_ADDREF_P(value);
34670 }
34671 } else if (IS_CV == IS_CV) {
34672 Z_TRY_ADDREF_P(value);
34673 }
34674 }
34675 zend_hash_add_new(zobj->properties, name, value);
34676 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34677 ZVAL_COPY(EX_VAR(opline->result.var), value);
34678 }
34679 goto exit_assign_obj;
34680 }
34681 } else {
34682 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34683 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34684 prop_info = CACHED_PTR_EX(cache_slot + 2);
34685 prop_offset = prop_info->offset;
34686 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
34687 prop_info = NULL;
34688 }
34689 goto assign_obj_simple;
34690 }
34691 /* Fall through to write_property for hooks. */
34692 }
34693 }
34694 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34695 } else {
34696 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34697 if (UNEXPECTED(!name)) {
34698
34699 UNDEF_RESULT();
34700 goto exit_assign_obj;
34701 }
34702 }
34703
34704 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
34705 ZVAL_DEREF(value);
34706 }
34707
34708 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34709
34710 if (IS_CONST != IS_CONST) {
34711 zend_tmp_string_release(tmp_name);
34712 }
34713
34714free_and_exit_assign_obj:
34715 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34716 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34717 }
34718
34719exit_assign_obj:
34720 if (garbage) {
34721 GC_DTOR_NO_REF(garbage);
34722 }
34723
34724
34725 /* assign_obj has two opcodes! */
34726 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34727}
34728
34729/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34730static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34731{
34732 USE_OPLINE
34733 zval *property, *container, *value_ptr;
34734
34735 SAVE_OPLINE();
34736
34737 container = &EX(This);
34738 property = RT_CONSTANT(opline, opline->op2);
34739
34740 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
34741
34742 if (1) {
34743 if (IS_UNUSED == IS_UNUSED) {
34744 if (IS_CONST == IS_CONST) {
34745 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34746 } else {
34747 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34748 }
34749 } else {
34750 if (IS_CONST == IS_CONST) {
34751 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34752 } else {
34753 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34754 }
34755 }
34756 } else {
34757 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34758 }
34759
34760
34761 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34762 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34763}
34764
34765/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34766static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34767{
34768 USE_OPLINE
34769 zval *property, *container, *value_ptr;
34770
34771 SAVE_OPLINE();
34772
34773 container = &EX(This);
34774 property = RT_CONSTANT(opline, opline->op2);
34775
34776 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
34777
34778 if (1) {
34779 if (IS_UNUSED == IS_UNUSED) {
34780 if (IS_CONST == IS_CONST) {
34781 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34782 } else {
34783 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34784 }
34785 } else {
34786 if (IS_CONST == IS_CONST) {
34787 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34788 } else {
34789 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34790 }
34791 }
34792 } else {
34793 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34794 }
34795
34796
34797
34798 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34799}
34800
34801/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
34802static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34803{
34804 USE_OPLINE
34805 zend_string **rope;
34806 zval *var;
34807
34808 /* Compiler allocates the necessary number of zval slots to keep the rope */
34809 rope = (zend_string**)EX_VAR(opline->result.var);
34810 if (IS_CONST == IS_CONST) {
34811 var = RT_CONSTANT(opline, opline->op2);
34812 rope[0] = Z_STR_P(var);
34813 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
34814 Z_ADDREF_P(var);
34815 }
34816 } else {
34817 var = RT_CONSTANT(opline, opline->op2);
34818 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
34819 if (IS_CONST == IS_CV) {
34820 rope[0] = zend_string_copy(Z_STR_P(var));
34821 } else {
34822 rope[0] = Z_STR_P(var);
34823 }
34824 } else {
34825 SAVE_OPLINE();
34826 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
34827 ZVAL_UNDEFINED_OP2();
34828 }
34829 rope[0] = zval_get_string_func(var);
34830
34831 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34832 }
34833 }
34834 ZEND_VM_NEXT_OPCODE();
34835}
34836
34837static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34838{
34839 zval *class_name;
34840 USE_OPLINE
34841
34842 SAVE_OPLINE();
34843 if (IS_CONST == IS_UNUSED) {
34844 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
34845 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34846 } else if (IS_CONST == IS_CONST) {
34847 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
34848
34849 if (UNEXPECTED(ce == NULL)) {
34850 class_name = RT_CONSTANT(opline, opline->op2);
34851 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
34852 CACHE_PTR(opline->extended_value, ce);
34853 }
34854 Z_CE_P(EX_VAR(opline->result.var)) = ce;
34855 } else {
34856 class_name = RT_CONSTANT(opline, opline->op2);
34857try_class_name:
34858 if (Z_TYPE_P(class_name) == IS_OBJECT) {
34859 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
34860 } else if (Z_TYPE_P(class_name) == IS_STRING) {
34861 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
34862 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
34863 class_name = Z_REFVAL_P(class_name);
34864 goto try_class_name;
34865 } else {
34866 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
34867 ZVAL_UNDEFINED_OP2();
34868 if (UNEXPECTED(EG(exception) != NULL)) {
34869 HANDLE_EXCEPTION();
34870 }
34871 }
34872 zend_throw_error(NULL, "Class name must be a valid object or a string");
34873 }
34874 }
34875
34876 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34877}
34878
34879static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34880{
34881 USE_OPLINE
34882 zval *function_name;
34883 zval *object;
34884 zend_function *fbc;
34885 zend_class_entry *called_scope;
34886 zend_object *obj;
34887 zend_execute_data *call;
34888 uint32_t call_info;
34889
34890 SAVE_OPLINE();
34891
34892 object = &EX(This);
34893
34894 if (IS_CONST != IS_CONST) {
34895 function_name = RT_CONSTANT(opline, opline->op2);
34896 }
34897
34898 if (IS_CONST != IS_CONST &&
34899 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
34900 do {
34901 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
34902 function_name = Z_REFVAL_P(function_name);
34903 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
34904 break;
34905 }
34906 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
34907 ZVAL_UNDEFINED_OP2();
34908 if (UNEXPECTED(EG(exception) != NULL)) {
34909
34910 HANDLE_EXCEPTION();
34911 }
34912 }
34913 zend_throw_error(NULL, "Method name must be a string");
34914
34915
34916 HANDLE_EXCEPTION();
34917 } while (0);
34918 }
34919
34920 if (IS_UNUSED == IS_UNUSED) {
34921 obj = Z_OBJ_P(object);
34922 } else {
34923 do {
34924 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
34925 obj = Z_OBJ_P(object);
34926 } else {
34927 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
34928 zend_reference *ref = Z_REF_P(object);
34929
34930 object = &ref->val;
34931 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
34932 obj = Z_OBJ_P(object);
34933 if (IS_UNUSED & IS_VAR) {
34934 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
34935 efree_size(ref, sizeof(zend_reference));
34936 } else {
34937 Z_ADDREF_P(object);
34938 }
34939 }
34940 break;
34941 }
34942 }
34943 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
34944 object = ZVAL_UNDEFINED_OP1();
34945 if (UNEXPECTED(EG(exception) != NULL)) {
34946 if (IS_CONST != IS_CONST) {
34947
34948 }
34949 HANDLE_EXCEPTION();
34950 }
34951 }
34952 if (IS_CONST == IS_CONST) {
34953 function_name = RT_CONSTANT(opline, opline->op2);
34954 }
34955 zend_invalid_method_call(object, function_name);
34956
34957
34958 HANDLE_EXCEPTION();
34959 }
34960 } while (0);
34961 }
34962
34963 called_scope = obj->ce;
34964
34965 if (IS_CONST == IS_CONST &&
34966 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
34967 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
34968 } else {
34969 zend_object *orig_obj = obj;
34970
34971 if (IS_CONST == IS_CONST) {
34972 function_name = RT_CONSTANT(opline, opline->op2);
34973 }
34974
34975 /* First, locate the function. */
34976 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
34977 if (UNEXPECTED(fbc == NULL)) {
34978 if (EXPECTED(!EG(exception))) {
34979 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
34980 }
34981
34982 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
34983 zend_objects_store_del(orig_obj);
34984 }
34985 HANDLE_EXCEPTION();
34986 }
34987 if (IS_CONST == IS_CONST &&
34988 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
34989 EXPECTED(obj == orig_obj)) {
34990 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
34991 }
34992 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
34993 GC_ADDREF(obj); /* For $this pointer */
34994 if (GC_DELREF(orig_obj) == 0) {
34995 zend_objects_store_del(orig_obj);
34996 }
34997 }
34998 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
34999 init_func_run_time_cache(&fbc->op_array);
35000 }
35001 }
35002
35003 if (IS_CONST != IS_CONST) {
35004
35005 }
35006
35007 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
35008 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
35009 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
35010 zend_objects_store_del(obj);
35011 if (UNEXPECTED(EG(exception))) {
35012 HANDLE_EXCEPTION();
35013 }
35014 }
35015 /* call static method */
35016 obj = (zend_object*)called_scope;
35017 call_info = ZEND_CALL_NESTED_FUNCTION;
35018 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
35019 if (IS_UNUSED == IS_CV) {
35020 GC_ADDREF(obj); /* For $this pointer */
35021 }
35022 /* CV may be changed indirectly (e.g. when it's a reference) */
35023 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
35024 }
35025
35026 call = zend_vm_stack_push_call_frame(call_info,
35027 fbc, opline->extended_value, obj);
35028 call->prev_execute_data = EX(call);
35029 EX(call) = call;
35030
35031 ZEND_VM_NEXT_OPCODE();
35032}
35033
35034static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35035{
35036 USE_OPLINE
35037 zval *function_name;
35038 zend_class_entry *ce;
35039 uint32_t call_info;
35040 zend_function *fbc;
35041 zend_execute_data *call;
35042
35043 SAVE_OPLINE();
35044
35045 if (IS_UNUSED == IS_CONST) {
35046 /* no function found. try a static method in class */
35047 ce = CACHED_PTR(opline->result.num);
35048 if (UNEXPECTED(ce == NULL)) {
35049 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);
35050 if (UNEXPECTED(ce == NULL)) {
35051
35052 HANDLE_EXCEPTION();
35053 }
35054 if (IS_CONST != IS_CONST) {
35055 CACHE_PTR(opline->result.num, ce);
35056 }
35057 }
35058 } else if (IS_UNUSED == IS_UNUSED) {
35059 ce = zend_fetch_class(NULL, opline->op1.num);
35060 if (UNEXPECTED(ce == NULL)) {
35061
35062 HANDLE_EXCEPTION();
35063 }
35064 } else {
35065 ce = Z_CE_P(EX_VAR(opline->op1.var));
35066 }
35067
35068 if (IS_UNUSED == IS_CONST &&
35069 IS_CONST == IS_CONST &&
35070 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
35071 /* nothing to do */
35072 } else if (IS_UNUSED != IS_CONST &&
35073 IS_CONST == IS_CONST &&
35074 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
35075 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
35076 } else if (IS_CONST != IS_UNUSED) {
35077 function_name = RT_CONSTANT(opline, opline->op2);
35078 if (IS_CONST != IS_CONST) {
35079 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
35080 do {
35081 if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
35082 function_name = Z_REFVAL_P(function_name);
35083 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
35084 break;
35085 }
35086 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
35087 ZVAL_UNDEFINED_OP2();
35088 if (UNEXPECTED(EG(exception) != NULL)) {
35089 HANDLE_EXCEPTION();
35090 }
35091 }
35092 zend_throw_error(NULL, "Method name must be a string");
35093
35094 HANDLE_EXCEPTION();
35095 } while (0);
35096 }
35097 }
35098
35099 if (ce->get_static_method) {
35100 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
35101 } else {
35102 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
35103 }
35104 if (UNEXPECTED(fbc == NULL)) {
35105 if (EXPECTED(!EG(exception))) {
35106 zend_undefined_method(ce, Z_STR_P(function_name));
35107 }
35108
35109 HANDLE_EXCEPTION();
35110 }
35111 if (IS_CONST == IS_CONST &&
35112 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
35113 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
35114 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
35115 }
35116 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
35117 init_func_run_time_cache(&fbc->op_array);
35118 }
35119 if (IS_CONST != IS_CONST) {
35120
35121 }
35122 } else {
35123 if (UNEXPECTED(ce->constructor == NULL)) {
35124 zend_throw_error(NULL, "Cannot call constructor");
35125 HANDLE_EXCEPTION();
35126 }
35127 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
35128 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
35129 HANDLE_EXCEPTION();
35130 }
35131 fbc = ce->constructor;
35132 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
35133 init_func_run_time_cache(&fbc->op_array);
35134 }
35135 }
35136
35137 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
35138 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
35139 ce = (zend_class_entry*)Z_OBJ(EX(This));
35140 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
35141 } else {
35142 zend_non_static_method_call(fbc);
35143 HANDLE_EXCEPTION();
35144 }
35145 } else {
35146 /* previous opcode is ZEND_FETCH_CLASS */
35147 if (IS_UNUSED == IS_UNUSED
35148 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
35149 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
35150 if (Z_TYPE(EX(This)) == IS_OBJECT) {
35151 ce = Z_OBJCE(EX(This));
35152 } else {
35153 ce = Z_CE(EX(This));
35154 }
35155 }
35156 call_info = ZEND_CALL_NESTED_FUNCTION;
35157 }
35158
35159 call = zend_vm_stack_push_call_frame(call_info,
35160 fbc, opline->extended_value, ce);
35161 call->prev_execute_data = EX(call);
35162 EX(call) = call;
35163
35164 ZEND_VM_NEXT_OPCODE();
35165}
35166
35167static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35168{
35169 USE_OPLINE
35170 uint32_t arg_num;
35171
35172 if (IS_CONST == IS_CONST) {
35173 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
35174 arg_num = zend_get_arg_offset_by_name(
35175 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
35176 if (UNEXPECTED(arg_num == 0)) {
35177 /* Treat this as a by-value argument, and throw an error during SEND. */
35178 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35179 ZEND_VM_NEXT_OPCODE();
35180 }
35181 } else {
35182 arg_num = opline->op2.num;
35183 }
35184
35185 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
35186 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
35187 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35188 } else {
35189 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35190 }
35191 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
35192 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35193 } else {
35194 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35195 }
35196 ZEND_VM_NEXT_OPCODE();
35197}
35198
35199static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35200{
35201 USE_OPLINE
35202 zend_constant *c;
35203
35204 c = CACHED_PTR(opline->extended_value);
35205 if (EXPECTED(c != NULL) && EXPECTED(!IS_SPECIAL_CACHE_VAL(c))) {
35206 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), &c->value);
35207 ZEND_VM_NEXT_OPCODE();
35208 }
35209
35210 SAVE_OPLINE();
35211 zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num OPLINE_CC EXECUTE_DATA_CC);
35212 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35213}
35214
35215static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35216{
35217 zend_class_entry *ce, *scope;
35218 zend_class_constant *c;
35219 zval *value, *zv, *constant_zv;
35220 zend_string *constant_name;
35221 USE_OPLINE
35222
35223 SAVE_OPLINE();
35224
35225 do {
35226 if (IS_UNUSED == IS_CONST && IS_CONST == IS_CONST) {
35227 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
35228 value = CACHED_PTR(opline->extended_value + sizeof(void*));
35229 break;
35230 }
35231 }
35232 if (IS_UNUSED == IS_CONST) {
35233 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
35234 ce = CACHED_PTR(opline->extended_value);
35235 } else {
35236 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);
35237 if (UNEXPECTED(ce == NULL)) {
35238 ZVAL_UNDEF(EX_VAR(opline->result.var));
35239
35240 HANDLE_EXCEPTION();
35241 }
35242 CACHE_PTR(opline->extended_value, ce);
35243 }
35244 } else if (IS_UNUSED == IS_UNUSED) {
35245 ce = zend_fetch_class(NULL, opline->op1.num);
35246 if (UNEXPECTED(ce == NULL)) {
35247 ZVAL_UNDEF(EX_VAR(opline->result.var));
35248
35249 HANDLE_EXCEPTION();
35250 }
35251 } else {
35252 ce = Z_CE_P(EX_VAR(opline->op1.var));
35253 }
35254 if (IS_UNUSED != IS_CONST
35255 && IS_CONST == IS_CONST
35256 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
35257 value = CACHED_PTR(opline->extended_value + sizeof(void*));
35258 break;
35259 }
35260
35261 constant_zv = RT_CONSTANT(opline, opline->op2);
35262 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
35263 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
35264 ZVAL_UNDEF(EX_VAR(opline->result.var));
35265
35266 HANDLE_EXCEPTION();
35267 }
35268 constant_name = Z_STR_P(constant_zv);
35269 /* Magic 'class' for constant OP2 is caught at compile-time */
35270 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
35271 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
35272
35273 ZEND_VM_NEXT_OPCODE();
35274 }
35275 zv = IS_CONST == IS_CONST
35276 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
35277 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
35278
35279 if (EXPECTED(zv != NULL)) {
35280 c = Z_PTR_P(zv);
35281 scope = EX(func)->op_array.scope;
35282 if (!zend_verify_const_access(c, scope)) {
35283 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));
35284 ZVAL_UNDEF(EX_VAR(opline->result.var));
35285
35286 HANDLE_EXCEPTION();
35287 }
35288
35289 if (ce->ce_flags & ZEND_ACC_TRAIT) {
35290 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35291 ZVAL_UNDEF(EX_VAR(opline->result.var));
35292
35293 HANDLE_EXCEPTION();
35294 }
35295
35296 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
35297 if (UNEXPECTED(is_constant_deprecated)) {
35298 zend_deprecated_class_constant(c, constant_name);
35299
35300 if (EG(exception)) {
35301 ZVAL_UNDEF(EX_VAR(opline->result.var));
35302
35303 HANDLE_EXCEPTION();
35304 }
35305 }
35306
35307 value = &c->value;
35308 // Enums require loading of all class constants to build the backed enum table
35309 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)) {
35310 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
35311 ZVAL_UNDEF(EX_VAR(opline->result.var));
35312
35313 HANDLE_EXCEPTION();
35314 }
35315 }
35316 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
35317 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
35318 ZVAL_UNDEF(EX_VAR(opline->result.var));
35319
35320 HANDLE_EXCEPTION();
35321 }
35322 }
35323 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
35324 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
35325 }
35326 } else {
35327 zend_throw_error(NULL, "Undefined constant %s::%s",
35328 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35329 ZVAL_UNDEF(EX_VAR(opline->result.var));
35330
35331 HANDLE_EXCEPTION();
35332 }
35333 } while (0);
35334
35335 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
35336
35337 ZEND_VM_NEXT_OPCODE();
35338}
35339
35340static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35341{
35342 zval *array;
35343 uint32_t size;
35344 USE_OPLINE
35345
35346 SAVE_OPLINE();
35347 array = EX_VAR(opline->result.var);
35348 if (IS_UNUSED != IS_UNUSED) {
35349 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
35350 ZVAL_ARR(array, zend_new_array(size));
35351 /* Explicitly initialize array as not-packed if flag is set */
35352 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
35353 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
35354 }
35355 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35356 } else {
35357 ZVAL_ARR(array, zend_new_array(0));
35358 ZEND_VM_NEXT_OPCODE();
35359 }
35360}
35361
35362static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35363{
35364 USE_OPLINE
35365 zval *container;
35366 zval *offset;
35367 zend_string *name, *tmp_name;
35368
35369 SAVE_OPLINE();
35370 container = &EX(This);
35371 offset = RT_CONSTANT(opline, opline->op2);
35372
35373 do {
35374 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
35375 if (Z_ISREF_P(container)) {
35376 container = Z_REFVAL_P(container);
35377 if (Z_TYPE_P(container) != IS_OBJECT) {
35378 if (IS_UNUSED == IS_CV
35379 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
35380 ZVAL_UNDEFINED_OP1();
35381 }
35382 break;
35383 }
35384 } else {
35385 break;
35386 }
35387 }
35388 if (IS_CONST == IS_CONST) {
35389 name = Z_STR_P(offset);
35390 } else {
35391 name = zval_try_get_tmp_string(offset, &tmp_name);
35392 if (UNEXPECTED(!name)) {
35393 break;
35394 }
35395 }
35396 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
35397 if (IS_CONST != IS_CONST) {
35398 zend_tmp_string_release(tmp_name);
35399 }
35400 } while (0);
35401
35402
35403 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35404}
35405
35406static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35407{
35408 USE_OPLINE
35409 zval *container;
35410 int result;
35411 zval *offset;
35412 zend_string *name, *tmp_name;
35413
35414 SAVE_OPLINE();
35415 container = &EX(This);
35416 offset = RT_CONSTANT(opline, opline->op2);
35417
35418 if (IS_UNUSED == IS_CONST ||
35419 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
35420 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
35421 container = Z_REFVAL_P(container);
35422 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
35423 result = (opline->extended_value & ZEND_ISEMPTY);
35424 goto isset_object_finish;
35425 }
35426 } else {
35427 result = (opline->extended_value & ZEND_ISEMPTY);
35428 goto isset_object_finish;
35429 }
35430 }
35431
35432 if (IS_CONST == IS_CONST) {
35433 name = Z_STR_P(offset);
35434 } else {
35435 name = zval_try_get_tmp_string(offset, &tmp_name);
35436 if (UNEXPECTED(!name)) {
35437 result = 0;
35438 goto isset_object_finish;
35439 }
35440 }
35441
35442 result =
35443 (opline->extended_value & ZEND_ISEMPTY) ^
35444 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));
35445
35446 if (IS_CONST != IS_CONST) {
35447 zend_tmp_string_release(tmp_name);
35448 }
35449
35450isset_object_finish:
35451
35452
35453 ZEND_VM_SMART_BRANCH(result, 1);
35454}
35455
35456static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35457{
35458 USE_OPLINE
35459
35460 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
35461
35462 SAVE_OPLINE();
35463 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
35464 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35465 }
35466
35467 /* Destroy the previously yielded value */
35468 zval_ptr_dtor(&generator->value);
35469
35470 /* Destroy the previously yielded key */
35471 zval_ptr_dtor(&generator->key);
35472
35473 /* Set the new yielded value */
35474 if (IS_UNUSED != IS_UNUSED) {
35475 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
35476 /* Constants and temporary variables aren't yieldable by reference,
35477 * but we still allow them with a notice. */
35478 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
35479 zval *value;
35480
35481 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
35482
35483 value = NULL;
35484 ZVAL_COPY_VALUE(&generator->value, value);
35485 if (IS_UNUSED == IS_CONST) {
35486 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
35487 Z_ADDREF(generator->value);
35488 }
35489 }
35490 } else {
35491 zval *value_ptr = NULL;
35492
35493 /* If a function call result is yielded and the function did
35494 * not return by reference we throw a notice. */
35495 do {
35496 if (IS_UNUSED == IS_VAR) {
35497 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
35498 if (opline->extended_value == ZEND_RETURNS_FUNCTION
35499 && !Z_ISREF_P(value_ptr)) {
35500 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
35501 ZVAL_COPY(&generator->value, value_ptr);
35502 break;
35503 }
35504 }
35505 if (Z_ISREF_P(value_ptr)) {
35506 Z_ADDREF_P(value_ptr);
35507 } else {
35508 ZVAL_MAKE_REF_EX(value_ptr, 2);
35509 }
35510 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
35511 } while (0);
35512
35513 }
35514 } else {
35515 zval *value = NULL;
35516
35517 /* Consts, temporary variables and references need copying */
35518 if (IS_UNUSED == IS_CONST) {
35519 ZVAL_COPY_VALUE(&generator->value, value);
35520 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
35521 Z_ADDREF(generator->value);
35522 }
35523 } else if (IS_UNUSED == IS_TMP_VAR) {
35524 ZVAL_COPY_VALUE(&generator->value, value);
35525 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
35526 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
35527
35528 } else {
35529 ZVAL_COPY_VALUE(&generator->value, value);
35530 if (IS_UNUSED == IS_CV) {
35531 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
35532 }
35533 }
35534 }
35535 } else {
35536 /* If no value was specified yield null */
35537 ZVAL_NULL(&generator->value);
35538 }
35539
35540 /* Set the new yielded key */
35541 if (IS_CONST != IS_UNUSED) {
35542 zval *key = RT_CONSTANT(opline, opline->op2);
35543 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
35544 key = Z_REFVAL_P(key);
35545 }
35546 ZVAL_COPY(&generator->key, key);
35547
35548 if (Z_TYPE(generator->key) == IS_LONG
35549 && Z_LVAL(generator->key) > generator->largest_used_integer_key
35550 ) {
35551 generator->largest_used_integer_key = Z_LVAL(generator->key);
35552 }
35553 } else {
35554 /* If no key was specified we use auto-increment keys */
35555 generator->largest_used_integer_key++;
35556 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
35557 }
35558
35559 if (RETURN_VALUE_USED(opline)) {
35560 /* If the return value of yield is used set the send
35561 * target and initialize it to NULL */
35562 generator->send_target = EX_VAR(opline->result.var);
35563 ZVAL_NULL(generator->send_target);
35564 } else {
35565 generator->send_target = NULL;
35566 }
35567
35568 /* The GOTO VM uses a local opline variable. We need to set the opline
35569 * variable in execute_data so we don't resume at an old position. */
35570 SAVE_OPLINE();
35571
35572 ZEND_VM_RETURN();
35573}
35574
35575static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35576{
35577 zend_class_entry *ce, *scope;
35578 zend_class_constant *c;
35579 zval *value, *zv, *constant_zv;
35580 zend_string *constant_name;
35581 USE_OPLINE
35582
35583 SAVE_OPLINE();
35584
35585 do {
35586 if (IS_UNUSED == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
35587 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
35588 value = CACHED_PTR(opline->extended_value + sizeof(void*));
35589 break;
35590 }
35591 }
35592 if (IS_UNUSED == IS_CONST) {
35593 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
35594 ce = CACHED_PTR(opline->extended_value);
35595 } else {
35596 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);
35597 if (UNEXPECTED(ce == NULL)) {
35598 ZVAL_UNDEF(EX_VAR(opline->result.var));
35599 FREE_OP(opline->op2_type, opline->op2.var);
35600 HANDLE_EXCEPTION();
35601 }
35602 CACHE_PTR(opline->extended_value, ce);
35603 }
35604 } else if (IS_UNUSED == IS_UNUSED) {
35605 ce = zend_fetch_class(NULL, opline->op1.num);
35606 if (UNEXPECTED(ce == NULL)) {
35607 ZVAL_UNDEF(EX_VAR(opline->result.var));
35608 FREE_OP(opline->op2_type, opline->op2.var);
35609 HANDLE_EXCEPTION();
35610 }
35611 } else {
35612 ce = Z_CE_P(EX_VAR(opline->op1.var));
35613 }
35614 if (IS_UNUSED != IS_CONST
35615 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
35616 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
35617 value = CACHED_PTR(opline->extended_value + sizeof(void*));
35618 break;
35619 }
35620
35621 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
35622 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
35623 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
35624 ZVAL_UNDEF(EX_VAR(opline->result.var));
35625 FREE_OP(opline->op2_type, opline->op2.var);
35626 HANDLE_EXCEPTION();
35627 }
35628 constant_name = Z_STR_P(constant_zv);
35629 /* Magic 'class' for constant OP2 is caught at compile-time */
35630 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
35631 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
35632 FREE_OP(opline->op2_type, opline->op2.var);
35633 ZEND_VM_NEXT_OPCODE();
35634 }
35635 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
35636 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
35637 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
35638
35639 if (EXPECTED(zv != NULL)) {
35640 c = Z_PTR_P(zv);
35641 scope = EX(func)->op_array.scope;
35642 if (!zend_verify_const_access(c, scope)) {
35643 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));
35644 ZVAL_UNDEF(EX_VAR(opline->result.var));
35645 FREE_OP(opline->op2_type, opline->op2.var);
35646 HANDLE_EXCEPTION();
35647 }
35648
35649 if (ce->ce_flags & ZEND_ACC_TRAIT) {
35650 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35651 ZVAL_UNDEF(EX_VAR(opline->result.var));
35652 FREE_OP(opline->op2_type, opline->op2.var);
35653 HANDLE_EXCEPTION();
35654 }
35655
35656 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
35657 if (UNEXPECTED(is_constant_deprecated)) {
35658 zend_deprecated_class_constant(c, constant_name);
35659
35660 if (EG(exception)) {
35661 ZVAL_UNDEF(EX_VAR(opline->result.var));
35662 FREE_OP(opline->op2_type, opline->op2.var);
35663 HANDLE_EXCEPTION();
35664 }
35665 }
35666
35667 value = &c->value;
35668 // Enums require loading of all class constants to build the backed enum table
35669 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)) {
35670 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
35671 ZVAL_UNDEF(EX_VAR(opline->result.var));
35672 FREE_OP(opline->op2_type, opline->op2.var);
35673 HANDLE_EXCEPTION();
35674 }
35675 }
35676 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
35677 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
35678 ZVAL_UNDEF(EX_VAR(opline->result.var));
35679 FREE_OP(opline->op2_type, opline->op2.var);
35680 HANDLE_EXCEPTION();
35681 }
35682 }
35683 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
35684 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
35685 }
35686 } else {
35687 zend_throw_error(NULL, "Undefined constant %s::%s",
35688 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35689 ZVAL_UNDEF(EX_VAR(opline->result.var));
35690 FREE_OP(opline->op2_type, opline->op2.var);
35691 HANDLE_EXCEPTION();
35692 }
35693 } while (0);
35694
35695 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
35696
35697 FREE_OP(opline->op2_type, opline->op2.var);
35698 ZEND_VM_NEXT_OPCODE();
35699}
35700
35701static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35702{
35703 USE_OPLINE
35704 zval *object;
35705 zval *property;
35706 zval *value;
35707 zval *zptr;
35708 void *_cache_slot[3] = {0};
35709 void **cache_slot;
35710 zend_property_info *prop_info;
35711 zend_object *zobj;
35712 zend_string *name, *tmp_name;
35713
35714 SAVE_OPLINE();
35715 object = &EX(This);
35716 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35717
35718 do {
35719 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
35720
35721 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35722 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35723 object = Z_REFVAL_P(object);
35724 goto assign_op_object;
35725 }
35726 if (IS_UNUSED == IS_CV
35727 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35728 ZVAL_UNDEFINED_OP1();
35729 }
35730 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35731 break;
35732 }
35733
35734assign_op_object:
35735 /* here we are sure we are dealing with an object */
35736 zobj = Z_OBJ_P(object);
35737 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35738 name = Z_STR_P(property);
35739 } else {
35740 name = zval_try_get_tmp_string(property, &tmp_name);
35741 if (UNEXPECTED(!name)) {
35742 UNDEF_RESULT();
35743 break;
35744 }
35745 }
35746 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
35747 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35748 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35749 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35750 ZVAL_NULL(EX_VAR(opline->result.var));
35751 }
35752 } else {
35753 zend_reference *ref;
35754
35755 do {
35756 if (UNEXPECTED(Z_ISREF_P(zptr))) {
35757 ref = Z_REF_P(zptr);
35758 zptr = Z_REFVAL_P(zptr);
35759 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
35760 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
35761 break;
35762 }
35763 }
35764
35765 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
35766 if (prop_info) {
35767 /* special case for typed properties */
35768 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
35769 } else {
35770 zend_binary_op(zptr, zptr, value OPLINE_CC);
35771 }
35772 } while (0);
35773
35774 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35775 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
35776 }
35777 }
35778 } else {
35779 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
35780 }
35781 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35782 zend_tmp_string_release(tmp_name);
35783 }
35784 } while (0);
35785
35786 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
35787 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35788
35789 /* assign_obj has two opcodes! */
35790 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35791}
35792
35793/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
35794static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35795{
35796 USE_OPLINE
35797 zval *object;
35798 zval *property;
35799 zval *zptr;
35800 void *_cache_slot[3] = {0};
35801 void **cache_slot;
35802 zend_property_info *prop_info;
35803 zend_object *zobj;
35804 zend_string *name, *tmp_name;
35805
35806 SAVE_OPLINE();
35807 object = &EX(This);
35808 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35809
35810 do {
35811 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35812 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35813 object = Z_REFVAL_P(object);
35814 goto pre_incdec_object;
35815 }
35816 if (IS_UNUSED == IS_CV
35817 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35818 ZVAL_UNDEFINED_OP1();
35819 }
35820 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35821 break;
35822 }
35823
35824pre_incdec_object:
35825 /* here we are sure we are dealing with an object */
35826 zobj = Z_OBJ_P(object);
35827 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35828 name = Z_STR_P(property);
35829 } else {
35830 name = zval_try_get_tmp_string(property, &tmp_name);
35831 if (UNEXPECTED(!name)) {
35832 UNDEF_RESULT();
35833 break;
35834 }
35835 }
35836 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
35837 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35838 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35839 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35840 ZVAL_NULL(EX_VAR(opline->result.var));
35841 }
35842 } else {
35843 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
35844 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
35845 }
35846 } else {
35847 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
35848 }
35849 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35850 zend_tmp_string_release(tmp_name);
35851 }
35852 } while (0);
35853
35854 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35855
35856 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35857}
35858
35859static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35860{
35861 USE_OPLINE
35862 zval *object;
35863 zval *property;
35864 zval *zptr;
35865 void *_cache_slot[3] = {0};
35866 void **cache_slot;
35867 zend_property_info *prop_info;
35868 zend_object *zobj;
35869 zend_string *name, *tmp_name;
35870
35871 SAVE_OPLINE();
35872 object = &EX(This);
35873 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35874
35875 do {
35876 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35877 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35878 object = Z_REFVAL_P(object);
35879 goto post_incdec_object;
35880 }
35881 if (IS_UNUSED == IS_CV
35882 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35883 ZVAL_UNDEFINED_OP1();
35884 }
35885 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35886 break;
35887 }
35888
35889post_incdec_object:
35890 /* here we are sure we are dealing with an object */
35891 zobj = Z_OBJ_P(object);
35892 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35893 name = Z_STR_P(property);
35894 } else {
35895 name = zval_try_get_tmp_string(property, &tmp_name);
35896 if (UNEXPECTED(!name)) {
35897 ZVAL_UNDEF(EX_VAR(opline->result.var));
35898 break;
35899 }
35900 }
35901 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
35902 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35903 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35904 ZVAL_NULL(EX_VAR(opline->result.var));
35905 } else {
35906 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
35907 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
35908 }
35909 } else {
35910 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
35911 }
35912 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35913 zend_tmp_string_release(tmp_name);
35914 }
35915 } while (0);
35916
35917 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35918
35919 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35920}
35921
35922static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35923{
35924 USE_OPLINE
35925 zval *container;
35926 void **cache_slot = NULL;
35927
35928 SAVE_OPLINE();
35929 container = &EX(This);
35930
35931 if (IS_UNUSED == IS_CONST ||
35932 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
35933 do {
35934 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
35935 container = Z_REFVAL_P(container);
35936 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
35937 break;
35938 }
35939 }
35940 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
35941 ZVAL_UNDEFINED_OP1();
35942 }
35943 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35944 ZVAL_NULL(EX_VAR(opline->result.var));
35945 goto fetch_obj_r_finish;
35946 } while (0);
35947 }
35948
35949 /* here we are sure we are dealing with an object */
35950 do {
35951 zend_object *zobj = Z_OBJ_P(container);
35952 zend_string *name, *tmp_name;
35953 zval *retval;
35954
35955 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35956 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
35957
35958 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
35959 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35960
35961 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35962fetch_obj_r_simple:
35963 retval = OBJ_PROP(zobj, prop_offset);
35964 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
35965 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35966 goto fetch_obj_r_copy;
35967 } else {
35968fetch_obj_r_fast_copy:
35969 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
35970 ZEND_VM_NEXT_OPCODE();
35971 }
35972 }
35973 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
35974 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
35975 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
35976 prop_offset = prop_info->offset;
35977 goto fetch_obj_r_simple;
35978 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
35979 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
35980 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
35981 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
35982
35983 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
35984 if (IS_UNUSED & IS_CV) {
35985 GC_ADDREF(zobj);
35986 }
35987 if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
35988 call_info |= ZEND_CALL_RELEASE_THIS;
35989 }
35990 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
35991 call->prev_execute_data = execute_data;
35992 call->call = NULL;
35993 call->return_value = EX_VAR(opline->result.var);
35994 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
35995
35996 execute_data = call;
35997 EG(current_execute_data) = execute_data;
35998 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
35999
36000#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
36001 opline = hook->op_array.opcodes;
36002#else
36003 EX(opline) = hook->op_array.opcodes;
36004#endif
36005 LOAD_OPLINE_EX();
36006
36007
36008 ZEND_VM_ENTER_EX();
36009 }
36010 /* Fall through to read_property for hooks. */
36011 } else if (EXPECTED(zobj->properties != NULL)) {
36012 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
36013 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36014 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
36015 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
36016
36017 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
36018 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
36019
36020 if (EXPECTED(p->key == name) ||
36021 (EXPECTED(p->h == ZSTR_H(name)) &&
36022 EXPECTED(p->key != NULL) &&
36023 EXPECTED(zend_string_equal_content(p->key, name)))) {
36024 retval = &p->val;
36025 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36026 goto fetch_obj_r_copy;
36027 } else {
36028 goto fetch_obj_r_fast_copy;
36029 }
36030 }
36031 }
36032 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
36033 }
36034 retval = zend_hash_find_known_hash(zobj->properties, name);
36035 if (EXPECTED(retval)) {
36036 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
36037 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
36038 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36039 goto fetch_obj_r_copy;
36040 } else {
36041 goto fetch_obj_r_fast_copy;
36042 }
36043 }
36044 }
36045 }
36046 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36047 } else {
36048 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36049 if (UNEXPECTED(!name)) {
36050 ZVAL_UNDEF(EX_VAR(opline->result.var));
36051 break;
36052 }
36053 }
36054
36055#if ZEND_DEBUG
36056 /* For non-standard object handlers, verify a declared property type in debug builds.
36057 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
36058 zend_property_info *prop_info = NULL;
36059 if (zobj->handlers->read_property != zend_std_read_property) {
36060 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
36061 }
36062#endif
36063 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
36064#if ZEND_DEBUG
36065 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
36066 && ZEND_TYPE_IS_SET(prop_info->type)) {
36067 ZVAL_OPT_DEREF(retval);
36068 zend_verify_property_type(prop_info, retval, /* strict */ true);
36069 }
36070#endif
36071
36072 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36073 zend_tmp_string_release(tmp_name);
36074 }
36075
36076 if (retval != EX_VAR(opline->result.var)) {
36077fetch_obj_r_copy:
36078 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36079 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
36080 zend_unwrap_reference(retval);
36081 }
36082 } while (0);
36083
36084fetch_obj_r_finish:
36085 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36086
36087 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36088}
36089
36090static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36091{
36092 USE_OPLINE
36093 zval *property, *container, *result;
36094
36095 SAVE_OPLINE();
36096
36097 container = &EX(This);
36098 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36099 result = EX_VAR(opline->result.var);
36100 zend_fetch_property_address(
36101 result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR),
36102 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
36103 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
36104 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36105 if (IS_UNUSED == IS_VAR) {
36106 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36107 }
36108 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36109}
36110
36111static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36112{
36113 USE_OPLINE
36114 zval *property, *container, *result;
36115
36116 SAVE_OPLINE();
36117 container = &EX(This);
36118 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36119 result = EX_VAR(opline->result.var);
36120 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);
36121 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36122 if (IS_UNUSED == IS_VAR) {
36123 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36124 }
36125 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36126}
36127
36128static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36129{
36130 USE_OPLINE
36131 zval *container;
36132 void **cache_slot = NULL;
36133
36134 SAVE_OPLINE();
36135 container = &EX(This);
36136
36137 if (IS_UNUSED == IS_CONST ||
36138 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
36139 do {
36140 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
36141 container = Z_REFVAL_P(container);
36142 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
36143 break;
36144 }
36145 }
36146 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
36147 ZVAL_UNDEFINED_OP2();
36148 }
36149 ZVAL_NULL(EX_VAR(opline->result.var));
36150 goto fetch_obj_is_finish;
36151 } while (0);
36152 }
36153
36154 /* here we are sure we are dealing with an object */
36155 do {
36156 zend_object *zobj = Z_OBJ_P(container);
36157 zend_string *name, *tmp_name;
36158 zval *retval;
36159
36160 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36161 cache_slot = CACHE_ADDR(opline->extended_value);
36162
36163 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
36164 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36165
36166 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36167fetch_obj_is_simple:
36168 retval = OBJ_PROP(zobj, prop_offset);
36169 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
36170 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36171 goto fetch_obj_is_copy;
36172 } else {
36173fetch_obj_is_fast_copy:
36174 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36175 ZEND_VM_NEXT_OPCODE();
36176 }
36177 }
36178 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
36179 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
36180 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
36181 prop_offset = prop_info->offset;
36182 goto fetch_obj_is_simple;
36183 }
36184 /* Fall through to read_property for hooks. */
36185 } else if (EXPECTED(zobj->properties != NULL)) {
36186 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
36187 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36188 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
36189 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
36190
36191 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
36192 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
36193
36194 if (EXPECTED(p->key == name) ||
36195 (EXPECTED(p->h == ZSTR_H(name)) &&
36196 EXPECTED(p->key != NULL) &&
36197 EXPECTED(zend_string_equal_content(p->key, name)))) {
36198 retval = &p->val;
36199 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36200 goto fetch_obj_is_copy;
36201 } else {
36202 goto fetch_obj_is_fast_copy;
36203 }
36204 }
36205 }
36206 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
36207 }
36208 retval = zend_hash_find_known_hash(zobj->properties, name);
36209 if (EXPECTED(retval)) {
36210 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
36211 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
36212 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36213 goto fetch_obj_is_copy;
36214 } else {
36215 goto fetch_obj_is_fast_copy;
36216 }
36217 }
36218 }
36219 }
36220 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36221 } else {
36222 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36223 if (UNEXPECTED(!name)) {
36224 ZVAL_UNDEF(EX_VAR(opline->result.var));
36225 break;
36226 }
36227 }
36228
36229 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
36230
36231 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36232 zend_tmp_string_release(tmp_name);
36233 }
36234
36235 if (retval != EX_VAR(opline->result.var)) {
36236fetch_obj_is_copy:
36237 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36238 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
36239 zend_unwrap_reference(retval);
36240 }
36241 } while (0);
36242
36243fetch_obj_is_finish:
36244 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36245
36246 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36247}
36248
36249static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36250{
36251#if 0
36252 USE_OPLINE
36253#endif
36254
36255 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
36256 /* Behave like FETCH_OBJ_W */
36257 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
36258 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36259 }
36260 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36261 } else {
36262 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36263 }
36264}
36265
36266static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36267{
36268 USE_OPLINE
36269 zval *container, *property, *result;
36270
36271 SAVE_OPLINE();
36272 container = &EX(This);
36273 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36274 result = EX_VAR(opline->result.var);
36275 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);
36276 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36277 if (IS_UNUSED == IS_VAR) {
36278 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36279 }
36280 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36281}
36282
36283static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36284{
36285 USE_OPLINE
36286 zval *object, *value, tmp;
36287 zend_object *zobj;
36288 zend_string *name, *tmp_name;
36289 zend_refcounted *garbage = NULL;
36290
36291 SAVE_OPLINE();
36292 object = &EX(This);
36293 value = RT_CONSTANT((opline+1), (opline+1)->op1);
36294
36295 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36296 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36297 object = Z_REFVAL_P(object);
36298 goto assign_object;
36299 }
36300 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36301 value = &EG(uninitialized_zval);
36302 goto free_and_exit_assign_obj;
36303 }
36304
36305assign_object:
36306 zobj = Z_OBJ_P(object);
36307 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36308 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36309 void **cache_slot = CACHE_ADDR(opline->extended_value);
36310 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36311 zval *property_val;
36312 zend_property_info *prop_info;
36313
36314 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36315 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36316
36317assign_obj_simple:
36318 property_val = OBJ_PROP(zobj, prop_offset);
36319 if (Z_TYPE_P(property_val) != IS_UNDEF) {
36320 if (prop_info != NULL) {
36321 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36322 goto free_and_exit_assign_obj;
36323 } else {
36324fast_assign_obj:
36325 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
36326 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36327 ZVAL_COPY(EX_VAR(opline->result.var), value);
36328 }
36329 goto exit_assign_obj;
36330 }
36331 }
36332 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36333 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36334 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36335 zobj = zend_lazy_object_init(zobj);
36336 if (!zobj) {
36337 value = &EG(uninitialized_zval);
36338 goto free_and_exit_assign_obj;
36339 }
36340 }
36341 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36342 rebuild_object_properties_internal(zobj);
36343 }
36344 if (EXPECTED(zobj->properties != NULL)) {
36345 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36346 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36347 GC_DELREF(zobj->properties);
36348 }
36349 zobj->properties = zend_array_dup(zobj->properties);
36350 }
36351 property_val = zend_hash_find_known_hash(zobj->properties, name);
36352 if (property_val) {
36353 goto fast_assign_obj;
36354 }
36355 }
36356
36357 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36358 if (IS_CONST == IS_CONST) {
36359 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36360 Z_ADDREF_P(value);
36361 }
36362 } else if (IS_CONST != IS_TMP_VAR) {
36363 if (Z_ISREF_P(value)) {
36364 if (IS_CONST == IS_VAR) {
36365 zend_reference *ref = Z_REF_P(value);
36366 if (GC_DELREF(ref) == 0) {
36367 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36368 efree_size(ref, sizeof(zend_reference));
36369 value = &tmp;
36370 } else {
36371 value = Z_REFVAL_P(value);
36372 Z_TRY_ADDREF_P(value);
36373 }
36374 } else {
36375 value = Z_REFVAL_P(value);
36376 Z_TRY_ADDREF_P(value);
36377 }
36378 } else if (IS_CONST == IS_CV) {
36379 Z_TRY_ADDREF_P(value);
36380 }
36381 }
36382 zend_hash_add_new(zobj->properties, name, value);
36383 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36384 ZVAL_COPY(EX_VAR(opline->result.var), value);
36385 }
36386 goto exit_assign_obj;
36387 }
36388 } else {
36389 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36390 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36391 prop_info = CACHED_PTR_EX(cache_slot + 2);
36392 prop_offset = prop_info->offset;
36393 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36394 prop_info = NULL;
36395 }
36396 goto assign_obj_simple;
36397 }
36398 /* Fall through to write_property for hooks. */
36399 }
36400 }
36401 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36402 } else {
36403 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36404 if (UNEXPECTED(!name)) {
36405
36406 UNDEF_RESULT();
36407 goto exit_assign_obj;
36408 }
36409 }
36410
36411 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
36412 ZVAL_DEREF(value);
36413 }
36414
36415 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36416
36417 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36418 zend_tmp_string_release(tmp_name);
36419 }
36420
36421free_and_exit_assign_obj:
36422 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36423 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36424 }
36425
36426exit_assign_obj:
36427 if (garbage) {
36428 GC_DTOR_NO_REF(garbage);
36429 }
36430 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36431
36432 /* assign_obj has two opcodes! */
36433 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36434}
36435
36436/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36437static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36438{
36439 USE_OPLINE
36440 zval *object, *value, tmp;
36441 zend_object *zobj;
36442 zend_string *name, *tmp_name;
36443 zend_refcounted *garbage = NULL;
36444
36445 SAVE_OPLINE();
36446 object = &EX(This);
36447 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
36448
36449 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36450 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36451 object = Z_REFVAL_P(object);
36452 goto assign_object;
36453 }
36454 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36455 value = &EG(uninitialized_zval);
36456 goto free_and_exit_assign_obj;
36457 }
36458
36459assign_object:
36460 zobj = Z_OBJ_P(object);
36461 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36462 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36463 void **cache_slot = CACHE_ADDR(opline->extended_value);
36464 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36465 zval *property_val;
36466 zend_property_info *prop_info;
36467
36468 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36469 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36470
36471assign_obj_simple:
36472 property_val = OBJ_PROP(zobj, prop_offset);
36473 if (Z_TYPE_P(property_val) != IS_UNDEF) {
36474 if (prop_info != NULL) {
36475 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36476 goto free_and_exit_assign_obj;
36477 } else {
36478fast_assign_obj:
36479 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
36480 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36481 ZVAL_COPY(EX_VAR(opline->result.var), value);
36482 }
36483 goto exit_assign_obj;
36484 }
36485 }
36486 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36487 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36488 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36489 zobj = zend_lazy_object_init(zobj);
36490 if (!zobj) {
36491 value = &EG(uninitialized_zval);
36492 goto free_and_exit_assign_obj;
36493 }
36494 }
36495 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36496 rebuild_object_properties_internal(zobj);
36497 }
36498 if (EXPECTED(zobj->properties != NULL)) {
36499 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36500 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36501 GC_DELREF(zobj->properties);
36502 }
36503 zobj->properties = zend_array_dup(zobj->properties);
36504 }
36505 property_val = zend_hash_find_known_hash(zobj->properties, name);
36506 if (property_val) {
36507 goto fast_assign_obj;
36508 }
36509 }
36510
36511 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36512 if (IS_TMP_VAR == IS_CONST) {
36513 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36514 Z_ADDREF_P(value);
36515 }
36516 } else if (IS_TMP_VAR != IS_TMP_VAR) {
36517 if (Z_ISREF_P(value)) {
36518 if (IS_TMP_VAR == IS_VAR) {
36519 zend_reference *ref = Z_REF_P(value);
36520 if (GC_DELREF(ref) == 0) {
36521 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36522 efree_size(ref, sizeof(zend_reference));
36523 value = &tmp;
36524 } else {
36525 value = Z_REFVAL_P(value);
36526 Z_TRY_ADDREF_P(value);
36527 }
36528 } else {
36529 value = Z_REFVAL_P(value);
36530 Z_TRY_ADDREF_P(value);
36531 }
36532 } else if (IS_TMP_VAR == IS_CV) {
36533 Z_TRY_ADDREF_P(value);
36534 }
36535 }
36536 zend_hash_add_new(zobj->properties, name, value);
36537 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36538 ZVAL_COPY(EX_VAR(opline->result.var), value);
36539 }
36540 goto exit_assign_obj;
36541 }
36542 } else {
36543 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36544 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36545 prop_info = CACHED_PTR_EX(cache_slot + 2);
36546 prop_offset = prop_info->offset;
36547 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36548 prop_info = NULL;
36549 }
36550 goto assign_obj_simple;
36551 }
36552 /* Fall through to write_property for hooks. */
36553 }
36554 }
36555 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36556 } else {
36557 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36558 if (UNEXPECTED(!name)) {
36559 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36560 UNDEF_RESULT();
36561 goto exit_assign_obj;
36562 }
36563 }
36564
36565 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
36566 ZVAL_DEREF(value);
36567 }
36568
36569 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36570
36571 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36572 zend_tmp_string_release(tmp_name);
36573 }
36574
36575free_and_exit_assign_obj:
36576 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36577 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36578 }
36579 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36580exit_assign_obj:
36581 if (garbage) {
36582 GC_DTOR_NO_REF(garbage);
36583 }
36584 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36585
36586 /* assign_obj has two opcodes! */
36587 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36588}
36589
36590/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36591static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36592{
36593 USE_OPLINE
36594 zval *object, *value, tmp;
36595 zend_object *zobj;
36596 zend_string *name, *tmp_name;
36597 zend_refcounted *garbage = NULL;
36598
36599 SAVE_OPLINE();
36600 object = &EX(This);
36601 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
36602
36603 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36604 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36605 object = Z_REFVAL_P(object);
36606 goto assign_object;
36607 }
36608 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36609 value = &EG(uninitialized_zval);
36610 goto free_and_exit_assign_obj;
36611 }
36612
36613assign_object:
36614 zobj = Z_OBJ_P(object);
36615 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36616 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36617 void **cache_slot = CACHE_ADDR(opline->extended_value);
36618 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36619 zval *property_val;
36620 zend_property_info *prop_info;
36621
36622 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36623 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36624
36625assign_obj_simple:
36626 property_val = OBJ_PROP(zobj, prop_offset);
36627 if (Z_TYPE_P(property_val) != IS_UNDEF) {
36628 if (prop_info != NULL) {
36629 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36630 goto free_and_exit_assign_obj;
36631 } else {
36632fast_assign_obj:
36633 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
36634 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36635 ZVAL_COPY(EX_VAR(opline->result.var), value);
36636 }
36637 goto exit_assign_obj;
36638 }
36639 }
36640 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36641 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36642 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36643 zobj = zend_lazy_object_init(zobj);
36644 if (!zobj) {
36645 value = &EG(uninitialized_zval);
36646 goto free_and_exit_assign_obj;
36647 }
36648 }
36649 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36650 rebuild_object_properties_internal(zobj);
36651 }
36652 if (EXPECTED(zobj->properties != NULL)) {
36653 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36654 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36655 GC_DELREF(zobj->properties);
36656 }
36657 zobj->properties = zend_array_dup(zobj->properties);
36658 }
36659 property_val = zend_hash_find_known_hash(zobj->properties, name);
36660 if (property_val) {
36661 goto fast_assign_obj;
36662 }
36663 }
36664
36665 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36666 if (IS_VAR == IS_CONST) {
36667 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36668 Z_ADDREF_P(value);
36669 }
36670 } else if (IS_VAR != IS_TMP_VAR) {
36671 if (Z_ISREF_P(value)) {
36672 if (IS_VAR == IS_VAR) {
36673 zend_reference *ref = Z_REF_P(value);
36674 if (GC_DELREF(ref) == 0) {
36675 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36676 efree_size(ref, sizeof(zend_reference));
36677 value = &tmp;
36678 } else {
36679 value = Z_REFVAL_P(value);
36680 Z_TRY_ADDREF_P(value);
36681 }
36682 } else {
36683 value = Z_REFVAL_P(value);
36684 Z_TRY_ADDREF_P(value);
36685 }
36686 } else if (IS_VAR == IS_CV) {
36687 Z_TRY_ADDREF_P(value);
36688 }
36689 }
36690 zend_hash_add_new(zobj->properties, name, value);
36691 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36692 ZVAL_COPY(EX_VAR(opline->result.var), value);
36693 }
36694 goto exit_assign_obj;
36695 }
36696 } else {
36697 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36698 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36699 prop_info = CACHED_PTR_EX(cache_slot + 2);
36700 prop_offset = prop_info->offset;
36701 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36702 prop_info = NULL;
36703 }
36704 goto assign_obj_simple;
36705 }
36706 /* Fall through to write_property for hooks. */
36707 }
36708 }
36709 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36710 } else {
36711 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36712 if (UNEXPECTED(!name)) {
36713 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36714 UNDEF_RESULT();
36715 goto exit_assign_obj;
36716 }
36717 }
36718
36719 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
36720 ZVAL_DEREF(value);
36721 }
36722
36723 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36724
36725 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36726 zend_tmp_string_release(tmp_name);
36727 }
36728
36729free_and_exit_assign_obj:
36730 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36731 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36732 }
36733 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36734exit_assign_obj:
36735 if (garbage) {
36736 GC_DTOR_NO_REF(garbage);
36737 }
36738 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36739
36740 /* assign_obj has two opcodes! */
36741 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36742}
36743
36744/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36745static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36746{
36747 USE_OPLINE
36748 zval *object, *value, tmp;
36749 zend_object *zobj;
36750 zend_string *name, *tmp_name;
36751 zend_refcounted *garbage = NULL;
36752
36753 SAVE_OPLINE();
36754 object = &EX(This);
36755 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
36756
36757 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36758 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36759 object = Z_REFVAL_P(object);
36760 goto assign_object;
36761 }
36762 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36763 value = &EG(uninitialized_zval);
36764 goto free_and_exit_assign_obj;
36765 }
36766
36767assign_object:
36768 zobj = Z_OBJ_P(object);
36769 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36770 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36771 void **cache_slot = CACHE_ADDR(opline->extended_value);
36772 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36773 zval *property_val;
36774 zend_property_info *prop_info;
36775
36776 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36777 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36778
36779assign_obj_simple:
36780 property_val = OBJ_PROP(zobj, prop_offset);
36781 if (Z_TYPE_P(property_val) != IS_UNDEF) {
36782 if (prop_info != NULL) {
36783 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36784 goto free_and_exit_assign_obj;
36785 } else {
36786fast_assign_obj:
36787 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
36788 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36789 ZVAL_COPY(EX_VAR(opline->result.var), value);
36790 }
36791 goto exit_assign_obj;
36792 }
36793 }
36794 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36795 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36796 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36797 zobj = zend_lazy_object_init(zobj);
36798 if (!zobj) {
36799 value = &EG(uninitialized_zval);
36800 goto free_and_exit_assign_obj;
36801 }
36802 }
36803 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36804 rebuild_object_properties_internal(zobj);
36805 }
36806 if (EXPECTED(zobj->properties != NULL)) {
36807 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36808 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36809 GC_DELREF(zobj->properties);
36810 }
36811 zobj->properties = zend_array_dup(zobj->properties);
36812 }
36813 property_val = zend_hash_find_known_hash(zobj->properties, name);
36814 if (property_val) {
36815 goto fast_assign_obj;
36816 }
36817 }
36818
36819 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36820 if (IS_CV == IS_CONST) {
36821 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36822 Z_ADDREF_P(value);
36823 }
36824 } else if (IS_CV != IS_TMP_VAR) {
36825 if (Z_ISREF_P(value)) {
36826 if (IS_CV == IS_VAR) {
36827 zend_reference *ref = Z_REF_P(value);
36828 if (GC_DELREF(ref) == 0) {
36829 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36830 efree_size(ref, sizeof(zend_reference));
36831 value = &tmp;
36832 } else {
36833 value = Z_REFVAL_P(value);
36834 Z_TRY_ADDREF_P(value);
36835 }
36836 } else {
36837 value = Z_REFVAL_P(value);
36838 Z_TRY_ADDREF_P(value);
36839 }
36840 } else if (IS_CV == IS_CV) {
36841 Z_TRY_ADDREF_P(value);
36842 }
36843 }
36844 zend_hash_add_new(zobj->properties, name, value);
36845 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36846 ZVAL_COPY(EX_VAR(opline->result.var), value);
36847 }
36848 goto exit_assign_obj;
36849 }
36850 } else {
36851 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36852 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36853 prop_info = CACHED_PTR_EX(cache_slot + 2);
36854 prop_offset = prop_info->offset;
36855 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
36856 prop_info = NULL;
36857 }
36858 goto assign_obj_simple;
36859 }
36860 /* Fall through to write_property for hooks. */
36861 }
36862 }
36863 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36864 } else {
36865 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36866 if (UNEXPECTED(!name)) {
36867
36868 UNDEF_RESULT();
36869 goto exit_assign_obj;
36870 }
36871 }
36872
36873 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
36874 ZVAL_DEREF(value);
36875 }
36876
36877 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36878
36879 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36880 zend_tmp_string_release(tmp_name);
36881 }
36882
36883free_and_exit_assign_obj:
36884 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36885 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36886 }
36887
36888exit_assign_obj:
36889 if (garbage) {
36890 GC_DTOR_NO_REF(garbage);
36891 }
36892 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36893
36894 /* assign_obj has two opcodes! */
36895 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36896}
36897
36898/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36899static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36900{
36901 USE_OPLINE
36902 zval *property, *container, *value_ptr;
36903
36904 SAVE_OPLINE();
36905
36906 container = &EX(This);
36907 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36908
36909 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
36910
36911 if (1) {
36912 if (IS_UNUSED == IS_UNUSED) {
36913 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36914 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36915 } else {
36916 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36917 }
36918 } else {
36919 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36920 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36921 } else {
36922 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36923 }
36924 }
36925 } else {
36926 zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
36927 }
36928
36929 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36930 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36931 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36932}
36933
36934/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36935static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36936{
36937 USE_OPLINE
36938 zval *property, *container, *value_ptr;
36939
36940 SAVE_OPLINE();
36941
36942 container = &EX(This);
36943 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36944
36945 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
36946
36947 if (1) {
36948 if (IS_UNUSED == IS_UNUSED) {
36949 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36950 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36951 } else {
36952 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36953 }
36954 } else {
36955 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36956 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36957 } else {
36958 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36959 }
36960 }
36961 } else {
36962 zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
36963 }
36964
36965 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36966
36967 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36968}
36969
36970/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
36971static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36972{
36973 USE_OPLINE
36974 zend_string **rope;
36975 zval *var;
36976
36977 /* Compiler allocates the necessary number of zval slots to keep the rope */
36978 rope = (zend_string**)EX_VAR(opline->result.var);
36979 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36980 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36981 rope[0] = Z_STR_P(var);
36982 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
36983 Z_ADDREF_P(var);
36984 }
36985 } else {
36986 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36987 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
36988 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
36989 rope[0] = zend_string_copy(Z_STR_P(var));
36990 } else {
36991 rope[0] = Z_STR_P(var);
36992 }
36993 } else {
36994 SAVE_OPLINE();
36995 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
36996 ZVAL_UNDEFINED_OP2();
36997 }
36998 rope[0] = zval_get_string_func(var);
36999 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37000 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37001 }
37002 }
37003 ZEND_VM_NEXT_OPCODE();
37004}
37005
37006static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37007{
37008 zval *class_name;
37009 USE_OPLINE
37010
37011 SAVE_OPLINE();
37012 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
37013 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
37014 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37015 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37016 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
37017
37018 if (UNEXPECTED(ce == NULL)) {
37019 class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37020 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
37021 CACHE_PTR(opline->extended_value, ce);
37022 }
37023 Z_CE_P(EX_VAR(opline->result.var)) = ce;
37024 } else {
37025 class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37026try_class_name:
37027 if (Z_TYPE_P(class_name) == IS_OBJECT) {
37028 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
37029 } else if (Z_TYPE_P(class_name) == IS_STRING) {
37030 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
37031 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
37032 class_name = Z_REFVAL_P(class_name);
37033 goto try_class_name;
37034 } else {
37035 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
37036 ZVAL_UNDEFINED_OP2();
37037 if (UNEXPECTED(EG(exception) != NULL)) {
37038 HANDLE_EXCEPTION();
37039 }
37040 }
37041 zend_throw_error(NULL, "Class name must be a valid object or a string");
37042 }
37043 }
37044
37045 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37046 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37047}
37048
37049static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37050{
37051 USE_OPLINE
37052 zval *function_name;
37053 zval *object;
37054 zend_function *fbc;
37055 zend_class_entry *called_scope;
37056 zend_object *obj;
37057 zend_execute_data *call;
37058 uint32_t call_info;
37059
37060 SAVE_OPLINE();
37061
37062 object = &EX(This);
37063
37064 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37065 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37066 }
37067
37068 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
37069 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37070 do {
37071 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
37072 function_name = Z_REFVAL_P(function_name);
37073 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37074 break;
37075 }
37076 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37077 ZVAL_UNDEFINED_OP2();
37078 if (UNEXPECTED(EG(exception) != NULL)) {
37079
37080 HANDLE_EXCEPTION();
37081 }
37082 }
37083 zend_throw_error(NULL, "Method name must be a string");
37084 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37085
37086 HANDLE_EXCEPTION();
37087 } while (0);
37088 }
37089
37090 if (IS_UNUSED == IS_UNUSED) {
37091 obj = Z_OBJ_P(object);
37092 } else {
37093 do {
37094 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
37095 obj = Z_OBJ_P(object);
37096 } else {
37097 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
37098 zend_reference *ref = Z_REF_P(object);
37099
37100 object = &ref->val;
37101 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
37102 obj = Z_OBJ_P(object);
37103 if (IS_UNUSED & IS_VAR) {
37104 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
37105 efree_size(ref, sizeof(zend_reference));
37106 } else {
37107 Z_ADDREF_P(object);
37108 }
37109 }
37110 break;
37111 }
37112 }
37113 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
37114 object = ZVAL_UNDEFINED_OP1();
37115 if (UNEXPECTED(EG(exception) != NULL)) {
37116 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37117 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37118 }
37119 HANDLE_EXCEPTION();
37120 }
37121 }
37122 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37123 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37124 }
37125 zend_invalid_method_call(object, function_name);
37126 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37127
37128 HANDLE_EXCEPTION();
37129 }
37130 } while (0);
37131 }
37132
37133 called_scope = obj->ce;
37134
37135 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37136 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
37137 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37138 } else {
37139 zend_object *orig_obj = obj;
37140
37141 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37142 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37143 }
37144
37145 /* First, locate the function. */
37146 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));
37147 if (UNEXPECTED(fbc == NULL)) {
37148 if (EXPECTED(!EG(exception))) {
37149 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
37150 }
37151 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37152 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
37153 zend_objects_store_del(orig_obj);
37154 }
37155 HANDLE_EXCEPTION();
37156 }
37157 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37158 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37159 EXPECTED(obj == orig_obj)) {
37160 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
37161 }
37162 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
37163 GC_ADDREF(obj); /* For $this pointer */
37164 if (GC_DELREF(orig_obj) == 0) {
37165 zend_objects_store_del(orig_obj);
37166 }
37167 }
37168 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37169 init_func_run_time_cache(&fbc->op_array);
37170 }
37171 }
37172
37173 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37174 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37175 }
37176
37177 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37178 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
37179 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
37180 zend_objects_store_del(obj);
37181 if (UNEXPECTED(EG(exception))) {
37182 HANDLE_EXCEPTION();
37183 }
37184 }
37185 /* call static method */
37186 obj = (zend_object*)called_scope;
37187 call_info = ZEND_CALL_NESTED_FUNCTION;
37188 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
37189 if (IS_UNUSED == IS_CV) {
37190 GC_ADDREF(obj); /* For $this pointer */
37191 }
37192 /* CV may be changed indirectly (e.g. when it's a reference) */
37193 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
37194 }
37195
37196 call = zend_vm_stack_push_call_frame(call_info,
37197 fbc, opline->extended_value, obj);
37198 call->prev_execute_data = EX(call);
37199 EX(call) = call;
37200
37201 ZEND_VM_NEXT_OPCODE();
37202}
37203
37204static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37205{
37206 USE_OPLINE
37207 zval *function_name;
37208 zend_class_entry *ce;
37209 uint32_t call_info;
37210 zend_function *fbc;
37211 zend_execute_data *call;
37212
37213 SAVE_OPLINE();
37214
37215 if (IS_UNUSED == IS_CONST) {
37216 /* no function found. try a static method in class */
37217 ce = CACHED_PTR(opline->result.num);
37218 if (UNEXPECTED(ce == NULL)) {
37219 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);
37220 if (UNEXPECTED(ce == NULL)) {
37221 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37222 HANDLE_EXCEPTION();
37223 }
37224 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37225 CACHE_PTR(opline->result.num, ce);
37226 }
37227 }
37228 } else if (IS_UNUSED == IS_UNUSED) {
37229 ce = zend_fetch_class(NULL, opline->op1.num);
37230 if (UNEXPECTED(ce == NULL)) {
37231 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37232 HANDLE_EXCEPTION();
37233 }
37234 } else {
37235 ce = Z_CE_P(EX_VAR(opline->op1.var));
37236 }
37237
37238 if (IS_UNUSED == IS_CONST &&
37239 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
37240 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
37241 /* nothing to do */
37242 } else if (IS_UNUSED != IS_CONST &&
37243 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
37244 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
37245 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37246 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
37247 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37248 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37249 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37250 do {
37251 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
37252 function_name = Z_REFVAL_P(function_name);
37253 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37254 break;
37255 }
37256 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37257 ZVAL_UNDEFINED_OP2();
37258 if (UNEXPECTED(EG(exception) != NULL)) {
37259 HANDLE_EXCEPTION();
37260 }
37261 }
37262 zend_throw_error(NULL, "Method name must be a string");
37263 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37264 HANDLE_EXCEPTION();
37265 } while (0);
37266 }
37267 }
37268
37269 if (ce->get_static_method) {
37270 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
37271 } else {
37272 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));
37273 }
37274 if (UNEXPECTED(fbc == NULL)) {
37275 if (EXPECTED(!EG(exception))) {
37276 zend_undefined_method(ce, Z_STR_P(function_name));
37277 }
37278 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37279 HANDLE_EXCEPTION();
37280 }
37281 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37282 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37283 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
37284 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
37285 }
37286 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37287 init_func_run_time_cache(&fbc->op_array);
37288 }
37289 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37290 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37291 }
37292 } else {
37293 if (UNEXPECTED(ce->constructor == NULL)) {
37294 zend_throw_error(NULL, "Cannot call constructor");
37295 HANDLE_EXCEPTION();
37296 }
37297 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
37298 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
37299 HANDLE_EXCEPTION();
37300 }
37301 fbc = ce->constructor;
37302 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37303 init_func_run_time_cache(&fbc->op_array);
37304 }
37305 }
37306
37307 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
37308 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
37309 ce = (zend_class_entry*)Z_OBJ(EX(This));
37310 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37311 } else {
37312 zend_non_static_method_call(fbc);
37313 HANDLE_EXCEPTION();
37314 }
37315 } else {
37316 /* previous opcode is ZEND_FETCH_CLASS */
37317 if (IS_UNUSED == IS_UNUSED
37318 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
37319 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
37320 if (Z_TYPE(EX(This)) == IS_OBJECT) {
37321 ce = Z_OBJCE(EX(This));
37322 } else {
37323 ce = Z_CE(EX(This));
37324 }
37325 }
37326 call_info = ZEND_CALL_NESTED_FUNCTION;
37327 }
37328
37329 call = zend_vm_stack_push_call_frame(call_info,
37330 fbc, opline->extended_value, ce);
37331 call->prev_execute_data = EX(call);
37332 EX(call) = call;
37333
37334 ZEND_VM_NEXT_OPCODE();
37335}
37336
37337static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37338{
37339 zval *array;
37340 uint32_t size;
37341 USE_OPLINE
37342
37343 SAVE_OPLINE();
37344 array = EX_VAR(opline->result.var);
37345 if (IS_UNUSED != IS_UNUSED) {
37346 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
37347 ZVAL_ARR(array, zend_new_array(size));
37348 /* Explicitly initialize array as not-packed if flag is set */
37349 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
37350 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
37351 }
37352 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37353 } else {
37354 ZVAL_ARR(array, zend_new_array(0));
37355 ZEND_VM_NEXT_OPCODE();
37356 }
37357}
37358
37359static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37360{
37361 USE_OPLINE
37362 zval *container;
37363 zval *offset;
37364 zend_string *name, *tmp_name;
37365
37366 SAVE_OPLINE();
37367 container = &EX(This);
37368 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37369
37370 do {
37371 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
37372 if (Z_ISREF_P(container)) {
37373 container = Z_REFVAL_P(container);
37374 if (Z_TYPE_P(container) != IS_OBJECT) {
37375 if (IS_UNUSED == IS_CV
37376 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
37377 ZVAL_UNDEFINED_OP1();
37378 }
37379 break;
37380 }
37381 } else {
37382 break;
37383 }
37384 }
37385 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37386 name = Z_STR_P(offset);
37387 } else {
37388 name = zval_try_get_tmp_string(offset, &tmp_name);
37389 if (UNEXPECTED(!name)) {
37390 break;
37391 }
37392 }
37393 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));
37394 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37395 zend_tmp_string_release(tmp_name);
37396 }
37397 } while (0);
37398
37399 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37400
37401 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37402}
37403
37404static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37405{
37406 USE_OPLINE
37407 zval *container;
37408 int result;
37409 zval *offset;
37410 zend_string *name, *tmp_name;
37411
37412 SAVE_OPLINE();
37413 container = &EX(This);
37414 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37415
37416 if (IS_UNUSED == IS_CONST ||
37417 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
37418 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
37419 container = Z_REFVAL_P(container);
37420 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
37421 result = (opline->extended_value & ZEND_ISEMPTY);
37422 goto isset_object_finish;
37423 }
37424 } else {
37425 result = (opline->extended_value & ZEND_ISEMPTY);
37426 goto isset_object_finish;
37427 }
37428 }
37429
37430 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37431 name = Z_STR_P(offset);
37432 } else {
37433 name = zval_try_get_tmp_string(offset, &tmp_name);
37434 if (UNEXPECTED(!name)) {
37435 result = 0;
37436 goto isset_object_finish;
37437 }
37438 }
37439
37440 result =
37441 (opline->extended_value & ZEND_ISEMPTY) ^
37442 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));
37443
37444 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37445 zend_tmp_string_release(tmp_name);
37446 }
37447
37448isset_object_finish:
37449 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37450
37451 ZEND_VM_SMART_BRANCH(result, 1);
37452}
37453
37454static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37455{
37456 USE_OPLINE
37457
37458 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
37459
37460 SAVE_OPLINE();
37461 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
37462 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37463 }
37464
37465 /* Destroy the previously yielded value */
37466 zval_ptr_dtor(&generator->value);
37467
37468 /* Destroy the previously yielded key */
37469 zval_ptr_dtor(&generator->key);
37470
37471 /* Set the new yielded value */
37472 if (IS_UNUSED != IS_UNUSED) {
37473 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
37474 /* Constants and temporary variables aren't yieldable by reference,
37475 * but we still allow them with a notice. */
37476 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
37477 zval *value;
37478
37479 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37480
37481 value = NULL;
37482 ZVAL_COPY_VALUE(&generator->value, value);
37483 if (IS_UNUSED == IS_CONST) {
37484 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37485 Z_ADDREF(generator->value);
37486 }
37487 }
37488 } else {
37489 zval *value_ptr = NULL;
37490
37491 /* If a function call result is yielded and the function did
37492 * not return by reference we throw a notice. */
37493 do {
37494 if (IS_UNUSED == IS_VAR) {
37495 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
37496 if (opline->extended_value == ZEND_RETURNS_FUNCTION
37497 && !Z_ISREF_P(value_ptr)) {
37498 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37499 ZVAL_COPY(&generator->value, value_ptr);
37500 break;
37501 }
37502 }
37503 if (Z_ISREF_P(value_ptr)) {
37504 Z_ADDREF_P(value_ptr);
37505 } else {
37506 ZVAL_MAKE_REF_EX(value_ptr, 2);
37507 }
37508 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
37509 } while (0);
37510
37511 }
37512 } else {
37513 zval *value = NULL;
37514
37515 /* Consts, temporary variables and references need copying */
37516 if (IS_UNUSED == IS_CONST) {
37517 ZVAL_COPY_VALUE(&generator->value, value);
37518 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37519 Z_ADDREF(generator->value);
37520 }
37521 } else if (IS_UNUSED == IS_TMP_VAR) {
37522 ZVAL_COPY_VALUE(&generator->value, value);
37523 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
37524 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
37525
37526 } else {
37527 ZVAL_COPY_VALUE(&generator->value, value);
37528 if (IS_UNUSED == IS_CV) {
37529 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
37530 }
37531 }
37532 }
37533 } else {
37534 /* If no value was specified yield null */
37535 ZVAL_NULL(&generator->value);
37536 }
37537
37538 /* Set the new yielded key */
37539 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
37540 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37541 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
37542 key = Z_REFVAL_P(key);
37543 }
37544 ZVAL_COPY(&generator->key, key);
37545 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37546
37547 if (Z_TYPE(generator->key) == IS_LONG
37548 && Z_LVAL(generator->key) > generator->largest_used_integer_key
37549 ) {
37550 generator->largest_used_integer_key = Z_LVAL(generator->key);
37551 }
37552 } else {
37553 /* If no key was specified we use auto-increment keys */
37554 generator->largest_used_integer_key++;
37555 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
37556 }
37557
37558 if (RETURN_VALUE_USED(opline)) {
37559 /* If the return value of yield is used set the send
37560 * target and initialize it to NULL */
37561 generator->send_target = EX_VAR(opline->result.var);
37562 ZVAL_NULL(generator->send_target);
37563 } else {
37564 generator->send_target = NULL;
37565 }
37566
37567 /* The GOTO VM uses a local opline variable. We need to set the opline
37568 * variable in execute_data so we don't resume at an old position. */
37569 SAVE_OPLINE();
37570
37571 ZEND_VM_RETURN();
37572}
37573
37574static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37575{
37576 zval *class_name;
37577 USE_OPLINE
37578
37579 SAVE_OPLINE();
37580 if (IS_UNUSED == IS_UNUSED) {
37581 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
37582 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37583 } else if (IS_UNUSED == IS_CONST) {
37584 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
37585
37586 if (UNEXPECTED(ce == NULL)) {
37587 class_name = NULL;
37588 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
37589 CACHE_PTR(opline->extended_value, ce);
37590 }
37591 Z_CE_P(EX_VAR(opline->result.var)) = ce;
37592 } else {
37593 class_name = NULL;
37594try_class_name:
37595 if (Z_TYPE_P(class_name) == IS_OBJECT) {
37596 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
37597 } else if (Z_TYPE_P(class_name) == IS_STRING) {
37598 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
37599 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
37600 class_name = Z_REFVAL_P(class_name);
37601 goto try_class_name;
37602 } else {
37603 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
37604 ZVAL_UNDEFINED_OP2();
37605 if (UNEXPECTED(EG(exception) != NULL)) {
37606 HANDLE_EXCEPTION();
37607 }
37608 }
37609 zend_throw_error(NULL, "Class name must be a valid object or a string");
37610 }
37611 }
37612
37613 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37614}
37615
37616static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37617{
37618 USE_OPLINE
37619 zval *function_name;
37620 zend_class_entry *ce;
37621 uint32_t call_info;
37622 zend_function *fbc;
37623 zend_execute_data *call;
37624
37625 SAVE_OPLINE();
37626
37627 if (IS_UNUSED == IS_CONST) {
37628 /* no function found. try a static method in class */
37629 ce = CACHED_PTR(opline->result.num);
37630 if (UNEXPECTED(ce == NULL)) {
37631 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);
37632 if (UNEXPECTED(ce == NULL)) {
37633
37634 HANDLE_EXCEPTION();
37635 }
37636 if (IS_UNUSED != IS_CONST) {
37637 CACHE_PTR(opline->result.num, ce);
37638 }
37639 }
37640 } else if (IS_UNUSED == IS_UNUSED) {
37641 ce = zend_fetch_class(NULL, opline->op1.num);
37642 if (UNEXPECTED(ce == NULL)) {
37643
37644 HANDLE_EXCEPTION();
37645 }
37646 } else {
37647 ce = Z_CE_P(EX_VAR(opline->op1.var));
37648 }
37649
37650 if (IS_UNUSED == IS_CONST &&
37651 IS_UNUSED == IS_CONST &&
37652 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
37653 /* nothing to do */
37654 } else if (IS_UNUSED != IS_CONST &&
37655 IS_UNUSED == IS_CONST &&
37656 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
37657 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37658 } else if (IS_UNUSED != IS_UNUSED) {
37659 function_name = NULL;
37660 if (IS_UNUSED != IS_CONST) {
37661 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37662 do {
37663 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
37664 function_name = Z_REFVAL_P(function_name);
37665 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37666 break;
37667 }
37668 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37669 ZVAL_UNDEFINED_OP2();
37670 if (UNEXPECTED(EG(exception) != NULL)) {
37671 HANDLE_EXCEPTION();
37672 }
37673 }
37674 zend_throw_error(NULL, "Method name must be a string");
37675
37676 HANDLE_EXCEPTION();
37677 } while (0);
37678 }
37679 }
37680
37681 if (ce->get_static_method) {
37682 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
37683 } else {
37684 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
37685 }
37686 if (UNEXPECTED(fbc == NULL)) {
37687 if (EXPECTED(!EG(exception))) {
37688 zend_undefined_method(ce, Z_STR_P(function_name));
37689 }
37690
37691 HANDLE_EXCEPTION();
37692 }
37693 if (IS_UNUSED == IS_CONST &&
37694 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37695 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
37696 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
37697 }
37698 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37699 init_func_run_time_cache(&fbc->op_array);
37700 }
37701 if (IS_UNUSED != IS_CONST) {
37702
37703 }
37704 } else {
37705 if (UNEXPECTED(ce->constructor == NULL)) {
37706 zend_throw_error(NULL, "Cannot call constructor");
37707 HANDLE_EXCEPTION();
37708 }
37709 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
37710 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
37711 HANDLE_EXCEPTION();
37712 }
37713 fbc = ce->constructor;
37714 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37715 init_func_run_time_cache(&fbc->op_array);
37716 }
37717 }
37718
37719 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
37720 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
37721 ce = (zend_class_entry*)Z_OBJ(EX(This));
37722 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37723 } else {
37724 zend_non_static_method_call(fbc);
37725 HANDLE_EXCEPTION();
37726 }
37727 } else {
37728 /* previous opcode is ZEND_FETCH_CLASS */
37729 if (IS_UNUSED == IS_UNUSED
37730 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
37731 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
37732 if (Z_TYPE(EX(This)) == IS_OBJECT) {
37733 ce = Z_OBJCE(EX(This));
37734 } else {
37735 ce = Z_CE(EX(This));
37736 }
37737 }
37738 call_info = ZEND_CALL_NESTED_FUNCTION;
37739 }
37740
37741 call = zend_vm_stack_push_call_frame(call_info,
37742 fbc, opline->extended_value, ce);
37743 call->prev_execute_data = EX(call);
37744 EX(call) = call;
37745
37746 ZEND_VM_NEXT_OPCODE();
37747}
37748
37749static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37750{
37751 if (IS_UNUSED == IS_UNUSED) {
37752 SAVE_OPLINE();
37753 zend_verify_missing_return_type(EX(func));
37754 HANDLE_EXCEPTION();
37755 } else {
37756/* prevents "undefined variable opline" errors */
37757#if 0 || (IS_UNUSED != IS_UNUSED)
37758 USE_OPLINE
37759 zval *retval_ref, *retval_ptr;
37760 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
37761 retval_ref = retval_ptr = NULL;
37762
37763 if (IS_UNUSED == IS_CONST) {
37764 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
37765 retval_ref = retval_ptr = EX_VAR(opline->result.var);
37766 } else if (IS_UNUSED == IS_VAR) {
37767 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
37768 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
37769 }
37770 ZVAL_DEREF(retval_ptr);
37771 } else if (IS_UNUSED == IS_CV) {
37772 ZVAL_DEREF(retval_ptr);
37773 }
37774
37775 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
37776 ZEND_VM_NEXT_OPCODE();
37777 }
37778
37779 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
37780 SAVE_OPLINE();
37781 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
37782 if (UNEXPECTED(EG(exception))) {
37783 HANDLE_EXCEPTION();
37784 }
37785 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
37786 ZEND_VM_NEXT_OPCODE();
37787 }
37788 }
37789
37790 zend_reference *ref = NULL;
37791 void *cache_slot = CACHE_ADDR(opline->op2.num);
37792 if (UNEXPECTED(retval_ref != retval_ptr)) {
37793 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
37794 ref = Z_REF_P(retval_ref);
37795 } else {
37796 /* A cast might happen - unwrap the reference if this is a by-value return */
37797 if (Z_REFCOUNT_P(retval_ref) == 1) {
37798 ZVAL_UNREF(retval_ref);
37799 } else {
37800 Z_DELREF_P(retval_ref);
37801 ZVAL_COPY(retval_ref, retval_ptr);
37802 }
37803 retval_ptr = retval_ref;
37804 }
37805 }
37806
37807 SAVE_OPLINE();
37808 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
37809 zend_verify_return_error(EX(func), retval_ptr);
37810 HANDLE_EXCEPTION();
37811 }
37812 ZEND_VM_NEXT_OPCODE();
37813#endif
37814 }
37815}
37816
37817static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37818{
37819 SAVE_OPLINE();
37820 zend_verify_never_error(EX(func));
37821 HANDLE_EXCEPTION();
37822}
37823
37824static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37825{
37826 USE_OPLINE
37827 uint32_t arg_num;
37828
37829 if (IS_UNUSED == IS_CONST) {
37830 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
37831 arg_num = zend_get_arg_offset_by_name(
37832 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
37833 if (UNEXPECTED(arg_num == 0)) {
37834 /* Treat this as a by-value argument, and throw an error during SEND. */
37835 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37836 ZEND_VM_NEXT_OPCODE();
37837 }
37838 } else {
37839 arg_num = opline->op2.num;
37840 }
37841
37842 if (EXPECTED(0)) {
37843 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37844 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37845 } else {
37846 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37847 }
37848 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37849 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37850 } else {
37851 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37852 }
37853 ZEND_VM_NEXT_OPCODE();
37854}
37855
37856static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37857{
37858 USE_OPLINE
37859 uint32_t arg_num;
37860
37861 if (IS_UNUSED == IS_CONST) {
37862 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
37863 arg_num = zend_get_arg_offset_by_name(
37864 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
37865 if (UNEXPECTED(arg_num == 0)) {
37866 /* Treat this as a by-value argument, and throw an error during SEND. */
37867 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37868 ZEND_VM_NEXT_OPCODE();
37869 }
37870 } else {
37871 arg_num = opline->op2.num;
37872 }
37873
37874 if (EXPECTED(1)) {
37875 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37876 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37877 } else {
37878 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37879 }
37880 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37881 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37882 } else {
37883 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37884 }
37885 ZEND_VM_NEXT_OPCODE();
37886}
37887
37888static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37889{
37890 USE_OPLINE
37891
37892 zend_execute_data *call = execute_data->call;
37893 if (EXPECTED(!(ZEND_CALL_INFO(call) & ZEND_CALL_MAY_HAVE_UNDEF))) {
37894 ZEND_VM_NEXT_OPCODE();
37895 }
37896
37897 SAVE_OPLINE();
37898 zend_handle_undef_args(call);
37899 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37900}
37901
37902static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37903{
37904 USE_OPLINE
37905 zval *result;
37906 zend_function *constructor;
37907 zend_class_entry *ce;
37908 zend_execute_data *call;
37909
37910 SAVE_OPLINE();
37911 if (IS_UNUSED == IS_CONST) {
37912 ce = CACHED_PTR(opline->op2.num);
37913 if (UNEXPECTED(ce == NULL)) {
37914 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);
37915 if (UNEXPECTED(ce == NULL)) {
37916 ZVAL_UNDEF(EX_VAR(opline->result.var));
37917 HANDLE_EXCEPTION();
37918 }
37919 CACHE_PTR(opline->op2.num, ce);
37920 }
37921 } else if (IS_UNUSED == IS_UNUSED) {
37922 ce = zend_fetch_class(NULL, opline->op1.num);
37923 if (UNEXPECTED(ce == NULL)) {
37924 ZVAL_UNDEF(EX_VAR(opline->result.var));
37925 HANDLE_EXCEPTION();
37926 }
37927 } else {
37928 ce = Z_CE_P(EX_VAR(opline->op1.var));
37929 }
37930
37931 result = EX_VAR(opline->result.var);
37932 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
37933 ZVAL_UNDEF(result);
37934 HANDLE_EXCEPTION();
37935 }
37936
37937 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
37938 if (constructor == NULL) {
37939 if (UNEXPECTED(EG(exception))) {
37940 HANDLE_EXCEPTION();
37941 }
37942
37943 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
37944 * opcode is DO_FCALL in case EXT instructions are used. */
37945 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
37946 ZEND_VM_NEXT_OPCODE_EX(1, 2);
37947 }
37948
37949 /* Perform a dummy function call */
37950 call = zend_vm_stack_push_call_frame(
37951 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
37952 opline->extended_value, NULL);
37953 } else {
37954 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
37955 init_func_run_time_cache(&constructor->op_array);
37956 }
37957 /* We are not handling overloaded classes right now */
37958 call = zend_vm_stack_push_call_frame(
37959 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
37960 constructor,
37961 opline->extended_value,
37962 Z_OBJ_P(result));
37963 Z_ADDREF_P(result);
37964 }
37965
37966 call->prev_execute_data = EX(call);
37967 EX(call) = call;
37968 ZEND_VM_NEXT_OPCODE();
37969}
37970
37971static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37972{
37973 zval *array;
37974 uint32_t size;
37975 USE_OPLINE
37976
37977 SAVE_OPLINE();
37978 array = EX_VAR(opline->result.var);
37979 if (IS_UNUSED != IS_UNUSED) {
37980 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
37981 ZVAL_ARR(array, zend_new_array(size));
37982 /* Explicitly initialize array as not-packed if flag is set */
37983 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
37984 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
37985 }
37986 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37987 } else {
37988 ZVAL_ARR(array, zend_new_array(0));
37989 ZEND_VM_NEXT_OPCODE();
37990 }
37991}
37992
37993static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37994{
37995 USE_OPLINE
37996
37997 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
37998
37999 SAVE_OPLINE();
38000 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
38001 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38002 }
38003
38004 /* Destroy the previously yielded value */
38005 zval_ptr_dtor(&generator->value);
38006
38007 /* Destroy the previously yielded key */
38008 zval_ptr_dtor(&generator->key);
38009
38010 /* Set the new yielded value */
38011 if (IS_UNUSED != IS_UNUSED) {
38012 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
38013 /* Constants and temporary variables aren't yieldable by reference,
38014 * but we still allow them with a notice. */
38015 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
38016 zval *value;
38017
38018 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
38019
38020 value = NULL;
38021 ZVAL_COPY_VALUE(&generator->value, value);
38022 if (IS_UNUSED == IS_CONST) {
38023 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
38024 Z_ADDREF(generator->value);
38025 }
38026 }
38027 } else {
38028 zval *value_ptr = NULL;
38029
38030 /* If a function call result is yielded and the function did
38031 * not return by reference we throw a notice. */
38032 do {
38033 if (IS_UNUSED == IS_VAR) {
38034 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
38035 if (opline->extended_value == ZEND_RETURNS_FUNCTION
38036 && !Z_ISREF_P(value_ptr)) {
38037 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
38038 ZVAL_COPY(&generator->value, value_ptr);
38039 break;
38040 }
38041 }
38042 if (Z_ISREF_P(value_ptr)) {
38043 Z_ADDREF_P(value_ptr);
38044 } else {
38045 ZVAL_MAKE_REF_EX(value_ptr, 2);
38046 }
38047 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
38048 } while (0);
38049
38050 }
38051 } else {
38052 zval *value = NULL;
38053
38054 /* Consts, temporary variables and references need copying */
38055 if (IS_UNUSED == IS_CONST) {
38056 ZVAL_COPY_VALUE(&generator->value, value);
38057 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
38058 Z_ADDREF(generator->value);
38059 }
38060 } else if (IS_UNUSED == IS_TMP_VAR) {
38061 ZVAL_COPY_VALUE(&generator->value, value);
38062 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
38063 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
38064
38065 } else {
38066 ZVAL_COPY_VALUE(&generator->value, value);
38067 if (IS_UNUSED == IS_CV) {
38068 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
38069 }
38070 }
38071 }
38072 } else {
38073 /* If no value was specified yield null */
38074 ZVAL_NULL(&generator->value);
38075 }
38076
38077 /* Set the new yielded key */
38078 if (IS_UNUSED != IS_UNUSED) {
38079 zval *key = NULL;
38080 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
38081 key = Z_REFVAL_P(key);
38082 }
38083 ZVAL_COPY(&generator->key, key);
38084
38085 if (Z_TYPE(generator->key) == IS_LONG
38086 && Z_LVAL(generator->key) > generator->largest_used_integer_key
38087 ) {
38088 generator->largest_used_integer_key = Z_LVAL(generator->key);
38089 }
38090 } else {
38091 /* If no key was specified we use auto-increment keys */
38092 generator->largest_used_integer_key++;
38093 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
38094 }
38095
38096 if (RETURN_VALUE_USED(opline)) {
38097 /* If the return value of yield is used set the send
38098 * target and initialize it to NULL */
38099 generator->send_target = EX_VAR(opline->result.var);
38100 ZVAL_NULL(generator->send_target);
38101 } else {
38102 generator->send_target = NULL;
38103 }
38104
38105 /* The GOTO VM uses a local opline variable. We need to set the opline
38106 * variable in execute_data so we don't resume at an old position. */
38107 SAVE_OPLINE();
38108
38109 ZEND_VM_RETURN();
38110}
38111
38112static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38113{
38114 USE_OPLINE
38115
38116 if (EXPECTED(Z_TYPE(EX(This)) == IS_OBJECT)) {
38117 zval *result = EX_VAR(opline->result.var);
38118
38119 ZVAL_OBJ(result, Z_OBJ(EX(This)));
38120 Z_ADDREF_P(result);
38121 ZEND_VM_NEXT_OPCODE();
38122 } else {
38123 ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38124 }
38125}
38126
38127static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38128{
38129 USE_OPLINE
38130
38131 /* For symbol tables we need to deal with exactly the same problems as for property tables. */
38132 ZVAL_ARR(EX_VAR(opline->result.var),
38133 zend_proptable_to_symtable(&EG(symbol_table), /* always_duplicate */ 1));
38134 ZEND_VM_NEXT_OPCODE();
38135}
38136
38137static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38138{
38139 USE_OPLINE
38140
38141 ZVAL_BOOL(EX_VAR(opline->result.var),
38142 (opline->extended_value & ZEND_ISEMPTY) ^
38143 (Z_TYPE(EX(This)) == IS_OBJECT));
38144 ZEND_VM_NEXT_OPCODE();
38145}
38146
38147static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38148{
38149 USE_OPLINE
38150
38151 if (IS_UNUSED == IS_UNUSED) {
38152 SAVE_OPLINE();
38153 if (UNEXPECTED(!EX(func)->common.scope)) {
38154 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
38155 ZVAL_UNDEF(EX_VAR(opline->result.var));
38156 HANDLE_EXCEPTION();
38157 } else {
38158 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
38159 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
38160 if (UNEXPECTED(EG(exception))) {
38161 HANDLE_EXCEPTION();
38162 }
38163 ZEND_VM_NEXT_OPCODE();
38164 }
38165 } else {
38166 zval *op1;
38167
38168 SAVE_OPLINE();
38169 op1 = NULL;
38170 while (1) {
38171 if (Z_TYPE_P(op1) == IS_OBJECT) {
38172 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
38173 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
38174 op1 = Z_REFVAL_P(op1);
38175 continue;
38176 } else {
38177 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
38178 ZVAL_UNDEFINED_OP1();
38179 }
38180 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
38181 ZVAL_UNDEF(EX_VAR(opline->result.var));
38182 }
38183 break;
38184 }
38185
38186 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38187 }
38188}
38189
38190static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38191{
38192 USE_OPLINE
38193
38194 if (Z_TYPE(EX(This)) == IS_OBJECT) {
38195 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name);
38196 } else if (Z_CE(EX(This))) {
38197 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name);
38198 } else {
38199 ZEND_ASSERT(!EX(func)->common.scope);
38200 SAVE_OPLINE();
38201 zend_throw_error(NULL, "get_called_class() must be called from within a class");
38202 ZVAL_UNDEF(EX_VAR(opline->result.var));
38203 HANDLE_EXCEPTION();
38204 }
38205 ZEND_VM_NEXT_OPCODE();
38206}
38207
38208static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38209{
38210 USE_OPLINE
38211
38212 ZVAL_LONG(EX_VAR(opline->result.var), EX_NUM_ARGS());
38213 ZEND_VM_NEXT_OPCODE();
38214}
38215
38216static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38217{
38218 USE_OPLINE
38219 zend_array *ht;
38220 uint32_t arg_count, result_size, skip;
38221
38222 arg_count = EX_NUM_ARGS();
38223 if (IS_UNUSED == IS_CONST) {
38224 skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
38225 if (arg_count < skip) {
38226 result_size = 0;
38227 } else {
38228 result_size = arg_count - skip;
38229 }
38230 } else {
38231 skip = 0;
38232 result_size = arg_count;
38233 }
38234
38235 if (result_size) {
38236 SAVE_OPLINE();
38237 uint32_t first_extra_arg = EX(func)->op_array.num_args;
38238
38239 ht = zend_new_array(result_size);
38240 ZVAL_ARR(EX_VAR(opline->result.var), ht);
38241 zend_hash_real_init_packed(ht);
38242 ZEND_HASH_FILL_PACKED(ht) {
38243 zval *p, *q;
38244 uint32_t i = skip;
38245 p = EX_VAR_NUM(i);
38246 if (arg_count > first_extra_arg) {
38247 while (i < first_extra_arg) {
38248 q = p;
38249 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
38250 ZVAL_DEREF(q);
38251 if (Z_OPT_REFCOUNTED_P(q)) {
38252 Z_ADDREF_P(q);
38253 }
38254 ZEND_HASH_FILL_SET(q);
38255 } else {
38256 ZEND_HASH_FILL_SET_NULL();
38257 }
38258 ZEND_HASH_FILL_NEXT();
38259 p++;
38260 i++;
38261 }
38262 if (skip < first_extra_arg) {
38263 skip = 0;
38264 } else {
38265 skip -= first_extra_arg;
38266 }
38267 p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
38268 }
38269 while (i < arg_count) {
38270 q = p;
38271 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
38272 ZVAL_DEREF(q);
38273 if (Z_OPT_REFCOUNTED_P(q)) {
38274 Z_ADDREF_P(q);
38275 }
38276 ZEND_HASH_FILL_SET(q);
38277 } else {
38278 ZEND_HASH_FILL_SET_NULL();
38279 }
38280 ZEND_HASH_FILL_NEXT();
38281 p++;
38282 i++;
38283 }
38284 } ZEND_HASH_FILL_END();
38285 ht->nNumOfElements = result_size;
38286 } else {
38287 ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
38288 }
38289 ZEND_VM_NEXT_OPCODE();
38290}
38291
38292/* Contrary to what its name indicates, ZEND_COPY_TMP may receive and define references. */
38293static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38294{
38295 USE_OPLINE
38296 zend_execute_data *call = EX(call);
38297
38298 zend_closure_from_frame(EX_VAR(opline->result.var), call);
38299
38300 if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) {
38301 OBJ_RELEASE(Z_OBJ(call->This));
38302 }
38303
38304 EX(call) = call->prev_execute_data;
38305
38306 zend_vm_stack_free_call_frame(call);
38307
38308 ZEND_VM_NEXT_OPCODE();
38309}
38310
38311static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38312{
38313 USE_OPLINE
38314 SAVE_OPLINE();
38315
38316 zval *result = EX_VAR(opline->result.var);
38317 ZVAL_NULL(result);
38318
38319#if 0 || 0
38320 if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
38321 zend_frameless_observed_call(execute_data);
38322 } else
38323#endif
38324 {
38325 zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline);
38326 function(EX_VAR(opline->result.var));
38327 }
38328 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38329}
38330
38331static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38332{
38333 USE_OPLINE
38334 SAVE_OPLINE();
38335
38336 zval *result = EX_VAR(opline->result.var);
38337 ZVAL_NULL(result);
38338
38339#if 0 || 1
38340 if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
38341 zend_frameless_observed_call(execute_data);
38342 } else
38343#endif
38344 {
38345 zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline);
38346 function(EX_VAR(opline->result.var));
38347 }
38348 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38349}
38350
38351static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38352{
38353 USE_OPLINE
38354 zval *object;
38355 zval *property;
38356 zval *value;
38357 zval *zptr;
38358 void *_cache_slot[3] = {0};
38359 void **cache_slot;
38360 zend_property_info *prop_info;
38361 zend_object *zobj;
38362 zend_string *name, *tmp_name;
38363
38364 SAVE_OPLINE();
38365 object = &EX(This);
38366 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38367
38368 do {
38369 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
38370
38371 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38372 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38373 object = Z_REFVAL_P(object);
38374 goto assign_op_object;
38375 }
38376 if (IS_UNUSED == IS_CV
38377 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38378 ZVAL_UNDEFINED_OP1();
38379 }
38380 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38381 break;
38382 }
38383
38384assign_op_object:
38385 /* here we are sure we are dealing with an object */
38386 zobj = Z_OBJ_P(object);
38387 if (IS_CV == IS_CONST) {
38388 name = Z_STR_P(property);
38389 } else {
38390 name = zval_try_get_tmp_string(property, &tmp_name);
38391 if (UNEXPECTED(!name)) {
38392 UNDEF_RESULT();
38393 break;
38394 }
38395 }
38396 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
38397 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38398 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38399 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38400 ZVAL_NULL(EX_VAR(opline->result.var));
38401 }
38402 } else {
38403 zend_reference *ref;
38404
38405 do {
38406 if (UNEXPECTED(Z_ISREF_P(zptr))) {
38407 ref = Z_REF_P(zptr);
38408 zptr = Z_REFVAL_P(zptr);
38409 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
38410 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
38411 break;
38412 }
38413 }
38414
38415 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
38416 if (prop_info) {
38417 /* special case for typed properties */
38418 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
38419 } else {
38420 zend_binary_op(zptr, zptr, value OPLINE_CC);
38421 }
38422 } while (0);
38423
38424 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38425 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
38426 }
38427 }
38428 } else {
38429 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
38430 }
38431 if (IS_CV != IS_CONST) {
38432 zend_tmp_string_release(tmp_name);
38433 }
38434 } while (0);
38435
38436 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
38437
38438
38439 /* assign_obj has two opcodes! */
38440 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38441}
38442
38443/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
38444static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38445{
38446 USE_OPLINE
38447 zval *object;
38448 zval *property;
38449 zval *zptr;
38450 void *_cache_slot[3] = {0};
38451 void **cache_slot;
38452 zend_property_info *prop_info;
38453 zend_object *zobj;
38454 zend_string *name, *tmp_name;
38455
38456 SAVE_OPLINE();
38457 object = &EX(This);
38458 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38459
38460 do {
38461 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38462 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38463 object = Z_REFVAL_P(object);
38464 goto pre_incdec_object;
38465 }
38466 if (IS_UNUSED == IS_CV
38467 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38468 ZVAL_UNDEFINED_OP1();
38469 }
38470 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38471 break;
38472 }
38473
38474pre_incdec_object:
38475 /* here we are sure we are dealing with an object */
38476 zobj = Z_OBJ_P(object);
38477 if (IS_CV == IS_CONST) {
38478 name = Z_STR_P(property);
38479 } else {
38480 name = zval_try_get_tmp_string(property, &tmp_name);
38481 if (UNEXPECTED(!name)) {
38482 UNDEF_RESULT();
38483 break;
38484 }
38485 }
38486 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
38487 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38488 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38489 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38490 ZVAL_NULL(EX_VAR(opline->result.var));
38491 }
38492 } else {
38493 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
38494 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
38495 }
38496 } else {
38497 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
38498 }
38499 if (IS_CV != IS_CONST) {
38500 zend_tmp_string_release(tmp_name);
38501 }
38502 } while (0);
38503
38504
38505 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38506}
38507
38508static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38509{
38510 USE_OPLINE
38511 zval *object;
38512 zval *property;
38513 zval *zptr;
38514 void *_cache_slot[3] = {0};
38515 void **cache_slot;
38516 zend_property_info *prop_info;
38517 zend_object *zobj;
38518 zend_string *name, *tmp_name;
38519
38520 SAVE_OPLINE();
38521 object = &EX(This);
38522 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38523
38524 do {
38525 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38526 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38527 object = Z_REFVAL_P(object);
38528 goto post_incdec_object;
38529 }
38530 if (IS_UNUSED == IS_CV
38531 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38532 ZVAL_UNDEFINED_OP1();
38533 }
38534 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38535 break;
38536 }
38537
38538post_incdec_object:
38539 /* here we are sure we are dealing with an object */
38540 zobj = Z_OBJ_P(object);
38541 if (IS_CV == IS_CONST) {
38542 name = Z_STR_P(property);
38543 } else {
38544 name = zval_try_get_tmp_string(property, &tmp_name);
38545 if (UNEXPECTED(!name)) {
38546 ZVAL_UNDEF(EX_VAR(opline->result.var));
38547 break;
38548 }
38549 }
38550 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
38551 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38552 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38553 ZVAL_NULL(EX_VAR(opline->result.var));
38554 } else {
38555 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
38556 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
38557 }
38558 } else {
38559 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
38560 }
38561 if (IS_CV != IS_CONST) {
38562 zend_tmp_string_release(tmp_name);
38563 }
38564 } while (0);
38565
38566
38567 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38568}
38569
38570static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38571{
38572 USE_OPLINE
38573 zval *container;
38574 void **cache_slot = NULL;
38575
38576 SAVE_OPLINE();
38577 container = &EX(This);
38578
38579 if (IS_UNUSED == IS_CONST ||
38580 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
38581 do {
38582 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
38583 container = Z_REFVAL_P(container);
38584 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
38585 break;
38586 }
38587 }
38588 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
38589 ZVAL_UNDEFINED_OP1();
38590 }
38591 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38592 ZVAL_NULL(EX_VAR(opline->result.var));
38593 goto fetch_obj_r_finish;
38594 } while (0);
38595 }
38596
38597 /* here we are sure we are dealing with an object */
38598 do {
38599 zend_object *zobj = Z_OBJ_P(container);
38600 zend_string *name, *tmp_name;
38601 zval *retval;
38602
38603 if (IS_CV == IS_CONST) {
38604 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
38605
38606 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
38607 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38608
38609 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38610fetch_obj_r_simple:
38611 retval = OBJ_PROP(zobj, prop_offset);
38612 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
38613 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38614 goto fetch_obj_r_copy;
38615 } else {
38616fetch_obj_r_fast_copy:
38617 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38618 ZEND_VM_NEXT_OPCODE();
38619 }
38620 }
38621 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
38622 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
38623 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
38624 prop_offset = prop_info->offset;
38625 goto fetch_obj_r_simple;
38626 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
38627 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
38628 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
38629 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
38630
38631 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
38632 if (IS_UNUSED & IS_CV) {
38633 GC_ADDREF(zobj);
38634 }
38635 if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
38636 call_info |= ZEND_CALL_RELEASE_THIS;
38637 }
38638 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
38639 call->prev_execute_data = execute_data;
38640 call->call = NULL;
38641 call->return_value = EX_VAR(opline->result.var);
38642 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
38643
38644 execute_data = call;
38645 EG(current_execute_data) = execute_data;
38646 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
38647
38648#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
38649 opline = hook->op_array.opcodes;
38650#else
38651 EX(opline) = hook->op_array.opcodes;
38652#endif
38653 LOAD_OPLINE_EX();
38654
38655
38656 ZEND_VM_ENTER_EX();
38657 }
38658 /* Fall through to read_property for hooks. */
38659 } else if (EXPECTED(zobj->properties != NULL)) {
38660 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
38661 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38662 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
38663 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
38664
38665 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
38666 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
38667
38668 if (EXPECTED(p->key == name) ||
38669 (EXPECTED(p->h == ZSTR_H(name)) &&
38670 EXPECTED(p->key != NULL) &&
38671 EXPECTED(zend_string_equal_content(p->key, name)))) {
38672 retval = &p->val;
38673 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38674 goto fetch_obj_r_copy;
38675 } else {
38676 goto fetch_obj_r_fast_copy;
38677 }
38678 }
38679 }
38680 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
38681 }
38682 retval = zend_hash_find_known_hash(zobj->properties, name);
38683 if (EXPECTED(retval)) {
38684 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
38685 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
38686 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38687 goto fetch_obj_r_copy;
38688 } else {
38689 goto fetch_obj_r_fast_copy;
38690 }
38691 }
38692 }
38693 }
38694 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38695 } else {
38696 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38697 if (UNEXPECTED(!name)) {
38698 ZVAL_UNDEF(EX_VAR(opline->result.var));
38699 break;
38700 }
38701 }
38702
38703#if ZEND_DEBUG
38704 /* For non-standard object handlers, verify a declared property type in debug builds.
38705 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
38706 zend_property_info *prop_info = NULL;
38707 if (zobj->handlers->read_property != zend_std_read_property) {
38708 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
38709 }
38710#endif
38711 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
38712#if ZEND_DEBUG
38713 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
38714 && ZEND_TYPE_IS_SET(prop_info->type)) {
38715 ZVAL_OPT_DEREF(retval);
38716 zend_verify_property_type(prop_info, retval, /* strict */ true);
38717 }
38718#endif
38719
38720 if (IS_CV != IS_CONST) {
38721 zend_tmp_string_release(tmp_name);
38722 }
38723
38724 if (retval != EX_VAR(opline->result.var)) {
38725fetch_obj_r_copy:
38726 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38727 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
38728 zend_unwrap_reference(retval);
38729 }
38730 } while (0);
38731
38732fetch_obj_r_finish:
38733
38734
38735 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38736}
38737
38738static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38739{
38740 USE_OPLINE
38741 zval *property, *container, *result;
38742
38743 SAVE_OPLINE();
38744
38745 container = &EX(This);
38746 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38747 result = EX_VAR(opline->result.var);
38748 zend_fetch_property_address(
38749 result, container, IS_UNUSED, property, IS_CV,
38750 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
38751 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
38752
38753 if (IS_UNUSED == IS_VAR) {
38754 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
38755 }
38756 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38757}
38758
38759static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38760{
38761 USE_OPLINE
38762 zval *property, *container, *result;
38763
38764 SAVE_OPLINE();
38765 container = &EX(This);
38766 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38767 result = EX_VAR(opline->result.var);
38768 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);
38769
38770 if (IS_UNUSED == IS_VAR) {
38771 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
38772 }
38773 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38774}
38775
38776static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38777{
38778 USE_OPLINE
38779 zval *container;
38780 void **cache_slot = NULL;
38781
38782 SAVE_OPLINE();
38783 container = &EX(This);
38784
38785 if (IS_UNUSED == IS_CONST ||
38786 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
38787 do {
38788 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
38789 container = Z_REFVAL_P(container);
38790 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
38791 break;
38792 }
38793 }
38794 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
38795 ZVAL_UNDEFINED_OP2();
38796 }
38797 ZVAL_NULL(EX_VAR(opline->result.var));
38798 goto fetch_obj_is_finish;
38799 } while (0);
38800 }
38801
38802 /* here we are sure we are dealing with an object */
38803 do {
38804 zend_object *zobj = Z_OBJ_P(container);
38805 zend_string *name, *tmp_name;
38806 zval *retval;
38807
38808 if (IS_CV == IS_CONST) {
38809 cache_slot = CACHE_ADDR(opline->extended_value);
38810
38811 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
38812 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38813
38814 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38815fetch_obj_is_simple:
38816 retval = OBJ_PROP(zobj, prop_offset);
38817 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
38818 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38819 goto fetch_obj_is_copy;
38820 } else {
38821fetch_obj_is_fast_copy:
38822 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38823 ZEND_VM_NEXT_OPCODE();
38824 }
38825 }
38826 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
38827 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
38828 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
38829 prop_offset = prop_info->offset;
38830 goto fetch_obj_is_simple;
38831 }
38832 /* Fall through to read_property for hooks. */
38833 } else if (EXPECTED(zobj->properties != NULL)) {
38834 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
38835 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38836 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
38837 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
38838
38839 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
38840 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
38841
38842 if (EXPECTED(p->key == name) ||
38843 (EXPECTED(p->h == ZSTR_H(name)) &&
38844 EXPECTED(p->key != NULL) &&
38845 EXPECTED(zend_string_equal_content(p->key, name)))) {
38846 retval = &p->val;
38847 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38848 goto fetch_obj_is_copy;
38849 } else {
38850 goto fetch_obj_is_fast_copy;
38851 }
38852 }
38853 }
38854 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
38855 }
38856 retval = zend_hash_find_known_hash(zobj->properties, name);
38857 if (EXPECTED(retval)) {
38858 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
38859 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
38860 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38861 goto fetch_obj_is_copy;
38862 } else {
38863 goto fetch_obj_is_fast_copy;
38864 }
38865 }
38866 }
38867 }
38868 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38869 } else {
38870 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38871 if (UNEXPECTED(!name)) {
38872 ZVAL_UNDEF(EX_VAR(opline->result.var));
38873 break;
38874 }
38875 }
38876
38877 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
38878
38879 if (IS_CV != IS_CONST) {
38880 zend_tmp_string_release(tmp_name);
38881 }
38882
38883 if (retval != EX_VAR(opline->result.var)) {
38884fetch_obj_is_copy:
38885 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38886 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
38887 zend_unwrap_reference(retval);
38888 }
38889 } while (0);
38890
38891fetch_obj_is_finish:
38892
38893
38894 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38895}
38896
38897static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38898{
38899#if 0
38900 USE_OPLINE
38901#endif
38902
38903 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
38904 /* Behave like FETCH_OBJ_W */
38905 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
38906 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38907 }
38908 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38909 } else {
38910 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38911 }
38912}
38913
38914static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38915{
38916 USE_OPLINE
38917 zval *container, *property, *result;
38918
38919 SAVE_OPLINE();
38920 container = &EX(This);
38921 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38922 result = EX_VAR(opline->result.var);
38923 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);
38924
38925 if (IS_UNUSED == IS_VAR) {
38926 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
38927 }
38928 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38929}
38930
38931static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38932{
38933 USE_OPLINE
38934 zval *object, *value, tmp;
38935 zend_object *zobj;
38936 zend_string *name, *tmp_name;
38937 zend_refcounted *garbage = NULL;
38938
38939 SAVE_OPLINE();
38940 object = &EX(This);
38941 value = RT_CONSTANT((opline+1), (opline+1)->op1);
38942
38943 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38944 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38945 object = Z_REFVAL_P(object);
38946 goto assign_object;
38947 }
38948 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
38949 value = &EG(uninitialized_zval);
38950 goto free_and_exit_assign_obj;
38951 }
38952
38953assign_object:
38954 zobj = Z_OBJ_P(object);
38955 if (IS_CV == IS_CONST) {
38956 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
38957 void **cache_slot = CACHE_ADDR(opline->extended_value);
38958 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38959 zval *property_val;
38960 zend_property_info *prop_info;
38961
38962 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38963 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
38964
38965assign_obj_simple:
38966 property_val = OBJ_PROP(zobj, prop_offset);
38967 if (Z_TYPE_P(property_val) != IS_UNDEF) {
38968 if (prop_info != NULL) {
38969 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
38970 goto free_and_exit_assign_obj;
38971 } else {
38972fast_assign_obj:
38973 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
38974 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38975 ZVAL_COPY(EX_VAR(opline->result.var), value);
38976 }
38977 goto exit_assign_obj;
38978 }
38979 }
38980 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
38981 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38982 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
38983 zobj = zend_lazy_object_init(zobj);
38984 if (!zobj) {
38985 value = &EG(uninitialized_zval);
38986 goto free_and_exit_assign_obj;
38987 }
38988 }
38989 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
38990 rebuild_object_properties_internal(zobj);
38991 }
38992 if (EXPECTED(zobj->properties != NULL)) {
38993 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
38994 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
38995 GC_DELREF(zobj->properties);
38996 }
38997 zobj->properties = zend_array_dup(zobj->properties);
38998 }
38999 property_val = zend_hash_find_known_hash(zobj->properties, name);
39000 if (property_val) {
39001 goto fast_assign_obj;
39002 }
39003 }
39004
39005 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39006 if (IS_CONST == IS_CONST) {
39007 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39008 Z_ADDREF_P(value);
39009 }
39010 } else if (IS_CONST != IS_TMP_VAR) {
39011 if (Z_ISREF_P(value)) {
39012 if (IS_CONST == IS_VAR) {
39013 zend_reference *ref = Z_REF_P(value);
39014 if (GC_DELREF(ref) == 0) {
39015 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39016 efree_size(ref, sizeof(zend_reference));
39017 value = &tmp;
39018 } else {
39019 value = Z_REFVAL_P(value);
39020 Z_TRY_ADDREF_P(value);
39021 }
39022 } else {
39023 value = Z_REFVAL_P(value);
39024 Z_TRY_ADDREF_P(value);
39025 }
39026 } else if (IS_CONST == IS_CV) {
39027 Z_TRY_ADDREF_P(value);
39028 }
39029 }
39030 zend_hash_add_new(zobj->properties, name, value);
39031 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39032 ZVAL_COPY(EX_VAR(opline->result.var), value);
39033 }
39034 goto exit_assign_obj;
39035 }
39036 } else {
39037 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39038 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39039 prop_info = CACHED_PTR_EX(cache_slot + 2);
39040 prop_offset = prop_info->offset;
39041 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39042 prop_info = NULL;
39043 }
39044 goto assign_obj_simple;
39045 }
39046 /* Fall through to write_property for hooks. */
39047 }
39048 }
39049 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39050 } else {
39051 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39052 if (UNEXPECTED(!name)) {
39053
39054 UNDEF_RESULT();
39055 goto exit_assign_obj;
39056 }
39057 }
39058
39059 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
39060 ZVAL_DEREF(value);
39061 }
39062
39063 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39064
39065 if (IS_CV != IS_CONST) {
39066 zend_tmp_string_release(tmp_name);
39067 }
39068
39069free_and_exit_assign_obj:
39070 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39071 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39072 }
39073
39074exit_assign_obj:
39075 if (garbage) {
39076 GC_DTOR_NO_REF(garbage);
39077 }
39078
39079
39080 /* assign_obj has two opcodes! */
39081 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39082}
39083
39084/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39085static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39086{
39087 USE_OPLINE
39088 zval *object, *value, tmp;
39089 zend_object *zobj;
39090 zend_string *name, *tmp_name;
39091 zend_refcounted *garbage = NULL;
39092
39093 SAVE_OPLINE();
39094 object = &EX(This);
39095 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
39096
39097 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39098 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39099 object = Z_REFVAL_P(object);
39100 goto assign_object;
39101 }
39102 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
39103 value = &EG(uninitialized_zval);
39104 goto free_and_exit_assign_obj;
39105 }
39106
39107assign_object:
39108 zobj = Z_OBJ_P(object);
39109 if (IS_CV == IS_CONST) {
39110 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39111 void **cache_slot = CACHE_ADDR(opline->extended_value);
39112 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39113 zval *property_val;
39114 zend_property_info *prop_info;
39115
39116 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39117 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39118
39119assign_obj_simple:
39120 property_val = OBJ_PROP(zobj, prop_offset);
39121 if (Z_TYPE_P(property_val) != IS_UNDEF) {
39122 if (prop_info != NULL) {
39123 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39124 goto free_and_exit_assign_obj;
39125 } else {
39126fast_assign_obj:
39127 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
39128 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39129 ZVAL_COPY(EX_VAR(opline->result.var), value);
39130 }
39131 goto exit_assign_obj;
39132 }
39133 }
39134 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39135 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39136 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39137 zobj = zend_lazy_object_init(zobj);
39138 if (!zobj) {
39139 value = &EG(uninitialized_zval);
39140 goto free_and_exit_assign_obj;
39141 }
39142 }
39143 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39144 rebuild_object_properties_internal(zobj);
39145 }
39146 if (EXPECTED(zobj->properties != NULL)) {
39147 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39148 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39149 GC_DELREF(zobj->properties);
39150 }
39151 zobj->properties = zend_array_dup(zobj->properties);
39152 }
39153 property_val = zend_hash_find_known_hash(zobj->properties, name);
39154 if (property_val) {
39155 goto fast_assign_obj;
39156 }
39157 }
39158
39159 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39160 if (IS_TMP_VAR == IS_CONST) {
39161 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39162 Z_ADDREF_P(value);
39163 }
39164 } else if (IS_TMP_VAR != IS_TMP_VAR) {
39165 if (Z_ISREF_P(value)) {
39166 if (IS_TMP_VAR == IS_VAR) {
39167 zend_reference *ref = Z_REF_P(value);
39168 if (GC_DELREF(ref) == 0) {
39169 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39170 efree_size(ref, sizeof(zend_reference));
39171 value = &tmp;
39172 } else {
39173 value = Z_REFVAL_P(value);
39174 Z_TRY_ADDREF_P(value);
39175 }
39176 } else {
39177 value = Z_REFVAL_P(value);
39178 Z_TRY_ADDREF_P(value);
39179 }
39180 } else if (IS_TMP_VAR == IS_CV) {
39181 Z_TRY_ADDREF_P(value);
39182 }
39183 }
39184 zend_hash_add_new(zobj->properties, name, value);
39185 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39186 ZVAL_COPY(EX_VAR(opline->result.var), value);
39187 }
39188 goto exit_assign_obj;
39189 }
39190 } else {
39191 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39192 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39193 prop_info = CACHED_PTR_EX(cache_slot + 2);
39194 prop_offset = prop_info->offset;
39195 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39196 prop_info = NULL;
39197 }
39198 goto assign_obj_simple;
39199 }
39200 /* Fall through to write_property for hooks. */
39201 }
39202 }
39203 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39204 } else {
39205 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39206 if (UNEXPECTED(!name)) {
39207 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39208 UNDEF_RESULT();
39209 goto exit_assign_obj;
39210 }
39211 }
39212
39213 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
39214 ZVAL_DEREF(value);
39215 }
39216
39217 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39218
39219 if (IS_CV != IS_CONST) {
39220 zend_tmp_string_release(tmp_name);
39221 }
39222
39223free_and_exit_assign_obj:
39224 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39225 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39226 }
39227 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39228exit_assign_obj:
39229 if (garbage) {
39230 GC_DTOR_NO_REF(garbage);
39231 }
39232
39233
39234 /* assign_obj has two opcodes! */
39235 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39236}
39237
39238/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39239static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39240{
39241 USE_OPLINE
39242 zval *object, *value, tmp;
39243 zend_object *zobj;
39244 zend_string *name, *tmp_name;
39245 zend_refcounted *garbage = NULL;
39246
39247 SAVE_OPLINE();
39248 object = &EX(This);
39249 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
39250
39251 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39252 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39253 object = Z_REFVAL_P(object);
39254 goto assign_object;
39255 }
39256 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
39257 value = &EG(uninitialized_zval);
39258 goto free_and_exit_assign_obj;
39259 }
39260
39261assign_object:
39262 zobj = Z_OBJ_P(object);
39263 if (IS_CV == IS_CONST) {
39264 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39265 void **cache_slot = CACHE_ADDR(opline->extended_value);
39266 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39267 zval *property_val;
39268 zend_property_info *prop_info;
39269
39270 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39271 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39272
39273assign_obj_simple:
39274 property_val = OBJ_PROP(zobj, prop_offset);
39275 if (Z_TYPE_P(property_val) != IS_UNDEF) {
39276 if (prop_info != NULL) {
39277 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39278 goto free_and_exit_assign_obj;
39279 } else {
39280fast_assign_obj:
39281 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
39282 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39283 ZVAL_COPY(EX_VAR(opline->result.var), value);
39284 }
39285 goto exit_assign_obj;
39286 }
39287 }
39288 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39289 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39290 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39291 zobj = zend_lazy_object_init(zobj);
39292 if (!zobj) {
39293 value = &EG(uninitialized_zval);
39294 goto free_and_exit_assign_obj;
39295 }
39296 }
39297 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39298 rebuild_object_properties_internal(zobj);
39299 }
39300 if (EXPECTED(zobj->properties != NULL)) {
39301 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39302 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39303 GC_DELREF(zobj->properties);
39304 }
39305 zobj->properties = zend_array_dup(zobj->properties);
39306 }
39307 property_val = zend_hash_find_known_hash(zobj->properties, name);
39308 if (property_val) {
39309 goto fast_assign_obj;
39310 }
39311 }
39312
39313 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39314 if (IS_VAR == IS_CONST) {
39315 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39316 Z_ADDREF_P(value);
39317 }
39318 } else if (IS_VAR != IS_TMP_VAR) {
39319 if (Z_ISREF_P(value)) {
39320 if (IS_VAR == IS_VAR) {
39321 zend_reference *ref = Z_REF_P(value);
39322 if (GC_DELREF(ref) == 0) {
39323 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39324 efree_size(ref, sizeof(zend_reference));
39325 value = &tmp;
39326 } else {
39327 value = Z_REFVAL_P(value);
39328 Z_TRY_ADDREF_P(value);
39329 }
39330 } else {
39331 value = Z_REFVAL_P(value);
39332 Z_TRY_ADDREF_P(value);
39333 }
39334 } else if (IS_VAR == IS_CV) {
39335 Z_TRY_ADDREF_P(value);
39336 }
39337 }
39338 zend_hash_add_new(zobj->properties, name, value);
39339 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39340 ZVAL_COPY(EX_VAR(opline->result.var), value);
39341 }
39342 goto exit_assign_obj;
39343 }
39344 } else {
39345 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39346 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39347 prop_info = CACHED_PTR_EX(cache_slot + 2);
39348 prop_offset = prop_info->offset;
39349 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39350 prop_info = NULL;
39351 }
39352 goto assign_obj_simple;
39353 }
39354 /* Fall through to write_property for hooks. */
39355 }
39356 }
39357 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39358 } else {
39359 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39360 if (UNEXPECTED(!name)) {
39361 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39362 UNDEF_RESULT();
39363 goto exit_assign_obj;
39364 }
39365 }
39366
39367 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
39368 ZVAL_DEREF(value);
39369 }
39370
39371 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39372
39373 if (IS_CV != IS_CONST) {
39374 zend_tmp_string_release(tmp_name);
39375 }
39376
39377free_and_exit_assign_obj:
39378 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39379 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39380 }
39381 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39382exit_assign_obj:
39383 if (garbage) {
39384 GC_DTOR_NO_REF(garbage);
39385 }
39386
39387
39388 /* assign_obj has two opcodes! */
39389 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39390}
39391
39392/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39393static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39394{
39395 USE_OPLINE
39396 zval *object, *value, tmp;
39397 zend_object *zobj;
39398 zend_string *name, *tmp_name;
39399 zend_refcounted *garbage = NULL;
39400
39401 SAVE_OPLINE();
39402 object = &EX(This);
39403 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
39404
39405 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39406 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39407 object = Z_REFVAL_P(object);
39408 goto assign_object;
39409 }
39410 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
39411 value = &EG(uninitialized_zval);
39412 goto free_and_exit_assign_obj;
39413 }
39414
39415assign_object:
39416 zobj = Z_OBJ_P(object);
39417 if (IS_CV == IS_CONST) {
39418 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39419 void **cache_slot = CACHE_ADDR(opline->extended_value);
39420 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39421 zval *property_val;
39422 zend_property_info *prop_info;
39423
39424 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39425 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39426
39427assign_obj_simple:
39428 property_val = OBJ_PROP(zobj, prop_offset);
39429 if (Z_TYPE_P(property_val) != IS_UNDEF) {
39430 if (prop_info != NULL) {
39431 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39432 goto free_and_exit_assign_obj;
39433 } else {
39434fast_assign_obj:
39435 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
39436 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39437 ZVAL_COPY(EX_VAR(opline->result.var), value);
39438 }
39439 goto exit_assign_obj;
39440 }
39441 }
39442 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39443 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39444 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39445 zobj = zend_lazy_object_init(zobj);
39446 if (!zobj) {
39447 value = &EG(uninitialized_zval);
39448 goto free_and_exit_assign_obj;
39449 }
39450 }
39451 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39452 rebuild_object_properties_internal(zobj);
39453 }
39454 if (EXPECTED(zobj->properties != NULL)) {
39455 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39456 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39457 GC_DELREF(zobj->properties);
39458 }
39459 zobj->properties = zend_array_dup(zobj->properties);
39460 }
39461 property_val = zend_hash_find_known_hash(zobj->properties, name);
39462 if (property_val) {
39463 goto fast_assign_obj;
39464 }
39465 }
39466
39467 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39468 if (IS_CV == IS_CONST) {
39469 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39470 Z_ADDREF_P(value);
39471 }
39472 } else if (IS_CV != IS_TMP_VAR) {
39473 if (Z_ISREF_P(value)) {
39474 if (IS_CV == IS_VAR) {
39475 zend_reference *ref = Z_REF_P(value);
39476 if (GC_DELREF(ref) == 0) {
39477 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39478 efree_size(ref, sizeof(zend_reference));
39479 value = &tmp;
39480 } else {
39481 value = Z_REFVAL_P(value);
39482 Z_TRY_ADDREF_P(value);
39483 }
39484 } else {
39485 value = Z_REFVAL_P(value);
39486 Z_TRY_ADDREF_P(value);
39487 }
39488 } else if (IS_CV == IS_CV) {
39489 Z_TRY_ADDREF_P(value);
39490 }
39491 }
39492 zend_hash_add_new(zobj->properties, name, value);
39493 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39494 ZVAL_COPY(EX_VAR(opline->result.var), value);
39495 }
39496 goto exit_assign_obj;
39497 }
39498 } else {
39499 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39500 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39501 prop_info = CACHED_PTR_EX(cache_slot + 2);
39502 prop_offset = prop_info->offset;
39503 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
39504 prop_info = NULL;
39505 }
39506 goto assign_obj_simple;
39507 }
39508 /* Fall through to write_property for hooks. */
39509 }
39510 }
39511 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39512 } else {
39513 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39514 if (UNEXPECTED(!name)) {
39515
39516 UNDEF_RESULT();
39517 goto exit_assign_obj;
39518 }
39519 }
39520
39521 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
39522 ZVAL_DEREF(value);
39523 }
39524
39525 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39526
39527 if (IS_CV != IS_CONST) {
39528 zend_tmp_string_release(tmp_name);
39529 }
39530
39531free_and_exit_assign_obj:
39532 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39533 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39534 }
39535
39536exit_assign_obj:
39537 if (garbage) {
39538 GC_DTOR_NO_REF(garbage);
39539 }
39540
39541
39542 /* assign_obj has two opcodes! */
39543 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39544}
39545
39546/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39547static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39548{
39549 USE_OPLINE
39550 zval *property, *container, *value_ptr;
39551
39552 SAVE_OPLINE();
39553
39554 container = &EX(This);
39555 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39556
39557 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
39558
39559 if (1) {
39560 if (IS_UNUSED == IS_UNUSED) {
39561 if (IS_CV == IS_CONST) {
39562 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39563 } else {
39564 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39565 }
39566 } else {
39567 if (IS_CV == IS_CONST) {
39568 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39569 } else {
39570 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39571 }
39572 }
39573 } else {
39574 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39575 }
39576
39577
39578 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39579 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39580}
39581
39582/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39583static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39584{
39585 USE_OPLINE
39586 zval *property, *container, *value_ptr;
39587
39588 SAVE_OPLINE();
39589
39590 container = &EX(This);
39591 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39592
39593 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
39594
39595 if (1) {
39596 if (IS_UNUSED == IS_UNUSED) {
39597 if (IS_CV == IS_CONST) {
39598 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39599 } else {
39600 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39601 }
39602 } else {
39603 if (IS_CV == IS_CONST) {
39604 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39605 } else {
39606 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39607 }
39608 }
39609 } else {
39610 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39611 }
39612
39613
39614
39615 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39616}
39617
39618/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
39619static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39620{
39621 USE_OPLINE
39622 zend_string **rope;
39623 zval *var;
39624
39625 /* Compiler allocates the necessary number of zval slots to keep the rope */
39626 rope = (zend_string**)EX_VAR(opline->result.var);
39627 if (IS_CV == IS_CONST) {
39628 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39629 rope[0] = Z_STR_P(var);
39630 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
39631 Z_ADDREF_P(var);
39632 }
39633 } else {
39634 var = EX_VAR(opline->op2.var);
39635 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
39636 if (IS_CV == IS_CV) {
39637 rope[0] = zend_string_copy(Z_STR_P(var));
39638 } else {
39639 rope[0] = Z_STR_P(var);
39640 }
39641 } else {
39642 SAVE_OPLINE();
39643 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
39644 ZVAL_UNDEFINED_OP2();
39645 }
39646 rope[0] = zval_get_string_func(var);
39647
39648 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39649 }
39650 }
39651 ZEND_VM_NEXT_OPCODE();
39652}
39653
39654static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39655{
39656 zval *class_name;
39657 USE_OPLINE
39658
39659 SAVE_OPLINE();
39660 if (IS_CV == IS_UNUSED) {
39661 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
39662 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39663 } else if (IS_CV == IS_CONST) {
39664 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
39665
39666 if (UNEXPECTED(ce == NULL)) {
39667 class_name = EX_VAR(opline->op2.var);
39668 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
39669 CACHE_PTR(opline->extended_value, ce);
39670 }
39671 Z_CE_P(EX_VAR(opline->result.var)) = ce;
39672 } else {
39673 class_name = EX_VAR(opline->op2.var);
39674try_class_name:
39675 if (Z_TYPE_P(class_name) == IS_OBJECT) {
39676 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
39677 } else if (Z_TYPE_P(class_name) == IS_STRING) {
39678 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
39679 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
39680 class_name = Z_REFVAL_P(class_name);
39681 goto try_class_name;
39682 } else {
39683 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
39684 ZVAL_UNDEFINED_OP2();
39685 if (UNEXPECTED(EG(exception) != NULL)) {
39686 HANDLE_EXCEPTION();
39687 }
39688 }
39689 zend_throw_error(NULL, "Class name must be a valid object or a string");
39690 }
39691 }
39692
39693 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39694}
39695
39696static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39697{
39698 USE_OPLINE
39699 zval *function_name;
39700 zval *object;
39701 zend_function *fbc;
39702 zend_class_entry *called_scope;
39703 zend_object *obj;
39704 zend_execute_data *call;
39705 uint32_t call_info;
39706
39707 SAVE_OPLINE();
39708
39709 object = &EX(This);
39710
39711 if (IS_CV != IS_CONST) {
39712 function_name = EX_VAR(opline->op2.var);
39713 }
39714
39715 if (IS_CV != IS_CONST &&
39716 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
39717 do {
39718 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
39719 function_name = Z_REFVAL_P(function_name);
39720 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
39721 break;
39722 }
39723 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
39724 ZVAL_UNDEFINED_OP2();
39725 if (UNEXPECTED(EG(exception) != NULL)) {
39726
39727 HANDLE_EXCEPTION();
39728 }
39729 }
39730 zend_throw_error(NULL, "Method name must be a string");
39731
39732
39733 HANDLE_EXCEPTION();
39734 } while (0);
39735 }
39736
39737 if (IS_UNUSED == IS_UNUSED) {
39738 obj = Z_OBJ_P(object);
39739 } else {
39740 do {
39741 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
39742 obj = Z_OBJ_P(object);
39743 } else {
39744 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
39745 zend_reference *ref = Z_REF_P(object);
39746
39747 object = &ref->val;
39748 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
39749 obj = Z_OBJ_P(object);
39750 if (IS_UNUSED & IS_VAR) {
39751 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
39752 efree_size(ref, sizeof(zend_reference));
39753 } else {
39754 Z_ADDREF_P(object);
39755 }
39756 }
39757 break;
39758 }
39759 }
39760 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
39761 object = ZVAL_UNDEFINED_OP1();
39762 if (UNEXPECTED(EG(exception) != NULL)) {
39763 if (IS_CV != IS_CONST) {
39764
39765 }
39766 HANDLE_EXCEPTION();
39767 }
39768 }
39769 if (IS_CV == IS_CONST) {
39770 function_name = EX_VAR(opline->op2.var);
39771 }
39772 zend_invalid_method_call(object, function_name);
39773
39774
39775 HANDLE_EXCEPTION();
39776 }
39777 } while (0);
39778 }
39779
39780 called_scope = obj->ce;
39781
39782 if (IS_CV == IS_CONST &&
39783 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
39784 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
39785 } else {
39786 zend_object *orig_obj = obj;
39787
39788 if (IS_CV == IS_CONST) {
39789 function_name = EX_VAR(opline->op2.var);
39790 }
39791
39792 /* First, locate the function. */
39793 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
39794 if (UNEXPECTED(fbc == NULL)) {
39795 if (EXPECTED(!EG(exception))) {
39796 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
39797 }
39798
39799 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
39800 zend_objects_store_del(orig_obj);
39801 }
39802 HANDLE_EXCEPTION();
39803 }
39804 if (IS_CV == IS_CONST &&
39805 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
39806 EXPECTED(obj == orig_obj)) {
39807 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
39808 }
39809 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
39810 GC_ADDREF(obj); /* For $this pointer */
39811 if (GC_DELREF(orig_obj) == 0) {
39812 zend_objects_store_del(orig_obj);
39813 }
39814 }
39815 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
39816 init_func_run_time_cache(&fbc->op_array);
39817 }
39818 }
39819
39820 if (IS_CV != IS_CONST) {
39821
39822 }
39823
39824 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
39825 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
39826 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
39827 zend_objects_store_del(obj);
39828 if (UNEXPECTED(EG(exception))) {
39829 HANDLE_EXCEPTION();
39830 }
39831 }
39832 /* call static method */
39833 obj = (zend_object*)called_scope;
39834 call_info = ZEND_CALL_NESTED_FUNCTION;
39835 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
39836 if (IS_UNUSED == IS_CV) {
39837 GC_ADDREF(obj); /* For $this pointer */
39838 }
39839 /* CV may be changed indirectly (e.g. when it's a reference) */
39840 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
39841 }
39842
39843 call = zend_vm_stack_push_call_frame(call_info,
39844 fbc, opline->extended_value, obj);
39845 call->prev_execute_data = EX(call);
39846 EX(call) = call;
39847
39848 ZEND_VM_NEXT_OPCODE();
39849}
39850
39851static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39852{
39853 USE_OPLINE
39854 zval *function_name;
39855 zend_class_entry *ce;
39856 uint32_t call_info;
39857 zend_function *fbc;
39858 zend_execute_data *call;
39859
39860 SAVE_OPLINE();
39861
39862 if (IS_UNUSED == IS_CONST) {
39863 /* no function found. try a static method in class */
39864 ce = CACHED_PTR(opline->result.num);
39865 if (UNEXPECTED(ce == NULL)) {
39866 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);
39867 if (UNEXPECTED(ce == NULL)) {
39868
39869 HANDLE_EXCEPTION();
39870 }
39871 if (IS_CV != IS_CONST) {
39872 CACHE_PTR(opline->result.num, ce);
39873 }
39874 }
39875 } else if (IS_UNUSED == IS_UNUSED) {
39876 ce = zend_fetch_class(NULL, opline->op1.num);
39877 if (UNEXPECTED(ce == NULL)) {
39878
39879 HANDLE_EXCEPTION();
39880 }
39881 } else {
39882 ce = Z_CE_P(EX_VAR(opline->op1.var));
39883 }
39884
39885 if (IS_UNUSED == IS_CONST &&
39886 IS_CV == IS_CONST &&
39887 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
39888 /* nothing to do */
39889 } else if (IS_UNUSED != IS_CONST &&
39890 IS_CV == IS_CONST &&
39891 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
39892 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
39893 } else if (IS_CV != IS_UNUSED) {
39894 function_name = EX_VAR(opline->op2.var);
39895 if (IS_CV != IS_CONST) {
39896 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
39897 do {
39898 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
39899 function_name = Z_REFVAL_P(function_name);
39900 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
39901 break;
39902 }
39903 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
39904 ZVAL_UNDEFINED_OP2();
39905 if (UNEXPECTED(EG(exception) != NULL)) {
39906 HANDLE_EXCEPTION();
39907 }
39908 }
39909 zend_throw_error(NULL, "Method name must be a string");
39910
39911 HANDLE_EXCEPTION();
39912 } while (0);
39913 }
39914 }
39915
39916 if (ce->get_static_method) {
39917 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
39918 } else {
39919 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
39920 }
39921 if (UNEXPECTED(fbc == NULL)) {
39922 if (EXPECTED(!EG(exception))) {
39923 zend_undefined_method(ce, Z_STR_P(function_name));
39924 }
39925
39926 HANDLE_EXCEPTION();
39927 }
39928 if (IS_CV == IS_CONST &&
39929 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
39930 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
39931 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
39932 }
39933 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
39934 init_func_run_time_cache(&fbc->op_array);
39935 }
39936 if (IS_CV != IS_CONST) {
39937
39938 }
39939 } else {
39940 if (UNEXPECTED(ce->constructor == NULL)) {
39941 zend_throw_error(NULL, "Cannot call constructor");
39942 HANDLE_EXCEPTION();
39943 }
39944 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
39945 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
39946 HANDLE_EXCEPTION();
39947 }
39948 fbc = ce->constructor;
39949 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
39950 init_func_run_time_cache(&fbc->op_array);
39951 }
39952 }
39953
39954 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
39955 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
39956 ce = (zend_class_entry*)Z_OBJ(EX(This));
39957 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
39958 } else {
39959 zend_non_static_method_call(fbc);
39960 HANDLE_EXCEPTION();
39961 }
39962 } else {
39963 /* previous opcode is ZEND_FETCH_CLASS */
39964 if (IS_UNUSED == IS_UNUSED
39965 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
39966 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
39967 if (Z_TYPE(EX(This)) == IS_OBJECT) {
39968 ce = Z_OBJCE(EX(This));
39969 } else {
39970 ce = Z_CE(EX(This));
39971 }
39972 }
39973 call_info = ZEND_CALL_NESTED_FUNCTION;
39974 }
39975
39976 call = zend_vm_stack_push_call_frame(call_info,
39977 fbc, opline->extended_value, ce);
39978 call->prev_execute_data = EX(call);
39979 EX(call) = call;
39980
39981 ZEND_VM_NEXT_OPCODE();
39982}
39983
39984static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39985{
39986 zval *array;
39987 uint32_t size;
39988 USE_OPLINE
39989
39990 SAVE_OPLINE();
39991 array = EX_VAR(opline->result.var);
39992 if (IS_UNUSED != IS_UNUSED) {
39993 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
39994 ZVAL_ARR(array, zend_new_array(size));
39995 /* Explicitly initialize array as not-packed if flag is set */
39996 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
39997 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
39998 }
39999 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40000 } else {
40001 ZVAL_ARR(array, zend_new_array(0));
40002 ZEND_VM_NEXT_OPCODE();
40003 }
40004}
40005
40006static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40007{
40008 USE_OPLINE
40009 zval *container;
40010 zval *offset;
40011 zend_string *name, *tmp_name;
40012
40013 SAVE_OPLINE();
40014 container = &EX(This);
40015 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
40016
40017 do {
40018 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
40019 if (Z_ISREF_P(container)) {
40020 container = Z_REFVAL_P(container);
40021 if (Z_TYPE_P(container) != IS_OBJECT) {
40022 if (IS_UNUSED == IS_CV
40023 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
40024 ZVAL_UNDEFINED_OP1();
40025 }
40026 break;
40027 }
40028 } else {
40029 break;
40030 }
40031 }
40032 if (IS_CV == IS_CONST) {
40033 name = Z_STR_P(offset);
40034 } else {
40035 name = zval_try_get_tmp_string(offset, &tmp_name);
40036 if (UNEXPECTED(!name)) {
40037 break;
40038 }
40039 }
40040 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
40041 if (IS_CV != IS_CONST) {
40042 zend_tmp_string_release(tmp_name);
40043 }
40044 } while (0);
40045
40046
40047 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40048}
40049
40050static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40051{
40052 USE_OPLINE
40053 zval *container;
40054 int result;
40055 zval *offset;
40056 zend_string *name, *tmp_name;
40057
40058 SAVE_OPLINE();
40059 container = &EX(This);
40060 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
40061
40062 if (IS_UNUSED == IS_CONST ||
40063 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
40064 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
40065 container = Z_REFVAL_P(container);
40066 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
40067 result = (opline->extended_value & ZEND_ISEMPTY);
40068 goto isset_object_finish;
40069 }
40070 } else {
40071 result = (opline->extended_value & ZEND_ISEMPTY);
40072 goto isset_object_finish;
40073 }
40074 }
40075
40076 if (IS_CV == IS_CONST) {
40077 name = Z_STR_P(offset);
40078 } else {
40079 name = zval_try_get_tmp_string(offset, &tmp_name);
40080 if (UNEXPECTED(!name)) {
40081 result = 0;
40082 goto isset_object_finish;
40083 }
40084 }
40085
40086 result =
40087 (opline->extended_value & ZEND_ISEMPTY) ^
40088 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));
40089
40090 if (IS_CV != IS_CONST) {
40091 zend_tmp_string_release(tmp_name);
40092 }
40093
40094isset_object_finish:
40095
40096
40097 ZEND_VM_SMART_BRANCH(result, 1);
40098}
40099
40100static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40101{
40102 USE_OPLINE
40103
40104 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
40105
40106 SAVE_OPLINE();
40107 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
40108 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40109 }
40110
40111 /* Destroy the previously yielded value */
40112 zval_ptr_dtor(&generator->value);
40113
40114 /* Destroy the previously yielded key */
40115 zval_ptr_dtor(&generator->key);
40116
40117 /* Set the new yielded value */
40118 if (IS_UNUSED != IS_UNUSED) {
40119 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
40120 /* Constants and temporary variables aren't yieldable by reference,
40121 * but we still allow them with a notice. */
40122 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
40123 zval *value;
40124
40125 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
40126
40127 value = NULL;
40128 ZVAL_COPY_VALUE(&generator->value, value);
40129 if (IS_UNUSED == IS_CONST) {
40130 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
40131 Z_ADDREF(generator->value);
40132 }
40133 }
40134 } else {
40135 zval *value_ptr = NULL;
40136
40137 /* If a function call result is yielded and the function did
40138 * not return by reference we throw a notice. */
40139 do {
40140 if (IS_UNUSED == IS_VAR) {
40141 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
40142 if (opline->extended_value == ZEND_RETURNS_FUNCTION
40143 && !Z_ISREF_P(value_ptr)) {
40144 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
40145 ZVAL_COPY(&generator->value, value_ptr);
40146 break;
40147 }
40148 }
40149 if (Z_ISREF_P(value_ptr)) {
40150 Z_ADDREF_P(value_ptr);
40151 } else {
40152 ZVAL_MAKE_REF_EX(value_ptr, 2);
40153 }
40154 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
40155 } while (0);
40156
40157 }
40158 } else {
40159 zval *value = NULL;
40160
40161 /* Consts, temporary variables and references need copying */
40162 if (IS_UNUSED == IS_CONST) {
40163 ZVAL_COPY_VALUE(&generator->value, value);
40164 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
40165 Z_ADDREF(generator->value);
40166 }
40167 } else if (IS_UNUSED == IS_TMP_VAR) {
40168 ZVAL_COPY_VALUE(&generator->value, value);
40169 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
40170 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
40171
40172 } else {
40173 ZVAL_COPY_VALUE(&generator->value, value);
40174 if (IS_UNUSED == IS_CV) {
40175 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
40176 }
40177 }
40178 }
40179 } else {
40180 /* If no value was specified yield null */
40181 ZVAL_NULL(&generator->value);
40182 }
40183
40184 /* Set the new yielded key */
40185 if (IS_CV != IS_UNUSED) {
40186 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
40187 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
40188 key = Z_REFVAL_P(key);
40189 }
40190 ZVAL_COPY(&generator->key, key);
40191
40192 if (Z_TYPE(generator->key) == IS_LONG
40193 && Z_LVAL(generator->key) > generator->largest_used_integer_key
40194 ) {
40195 generator->largest_used_integer_key = Z_LVAL(generator->key);
40196 }
40197 } else {
40198 /* If no key was specified we use auto-increment keys */
40199 generator->largest_used_integer_key++;
40200 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
40201 }
40202
40203 if (RETURN_VALUE_USED(opline)) {
40204 /* If the return value of yield is used set the send
40205 * target and initialize it to NULL */
40206 generator->send_target = EX_VAR(opline->result.var);
40207 ZVAL_NULL(generator->send_target);
40208 } else {
40209 generator->send_target = NULL;
40210 }
40211
40212 /* The GOTO VM uses a local opline variable. We need to set the opline
40213 * variable in execute_data so we don't resume at an old position. */
40214 SAVE_OPLINE();
40215
40216 ZEND_VM_RETURN();
40217}
40218
40219static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40220{
40221 USE_OPLINE
40222 zval *val;
40223
40224 val = EX_VAR(opline->op1.var);
40225 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40226 ZVAL_FALSE(EX_VAR(opline->result.var));
40227 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40228 /* The result and op1 can be the same cv zval */
40229 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
40230 ZVAL_TRUE(EX_VAR(opline->result.var));
40231 if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
40232 SAVE_OPLINE();
40233 ZVAL_UNDEFINED_OP1();
40234 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40235 }
40236 } else {
40237 SAVE_OPLINE();
40238 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
40239
40240 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40241 }
40242 ZEND_VM_NEXT_OPCODE();
40243}
40244
40245static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40246{
40247 USE_OPLINE
40248 zval *var_ptr;
40249
40250 var_ptr = EX_VAR(opline->op1.var);
40251
40252 SAVE_OPLINE();
40253 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40254 ZVAL_UNDEFINED_OP1();
40255 ZVAL_NULL(var_ptr);
40256 }
40257
40258 do {
40259 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40260 zend_reference *ref = Z_REF_P(var_ptr);
40261 var_ptr = Z_REFVAL_P(var_ptr);
40262 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40263 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
40264 break;
40265 }
40266 }
40267 increment_function(var_ptr);
40268 } while (0);
40269
40270 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
40271 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40272 }
40273
40274 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40275}
40276
40277static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40278{
40279 USE_OPLINE
40280 zval *var_ptr;
40281
40282 var_ptr = EX_VAR(opline->op1.var);
40283
40284 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40285 fast_long_increment_function(var_ptr);
40286 if (UNEXPECTED(0)) {
40287 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40288 }
40289 ZEND_VM_NEXT_OPCODE();
40290 }
40291
40292 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40293}
40294
40295static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40296{
40297 USE_OPLINE
40298 zval *var_ptr;
40299
40300 var_ptr = EX_VAR(opline->op1.var);
40301
40302 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40303 fast_long_increment_function(var_ptr);
40304 if (UNEXPECTED(1)) {
40305 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40306 }
40307 ZEND_VM_NEXT_OPCODE();
40308 }
40309
40310 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40311}
40312
40313static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40314{
40315 USE_OPLINE
40316 zval *var_ptr;
40317
40318 var_ptr = EX_VAR(opline->op1.var);
40319
40320 SAVE_OPLINE();
40321 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40322 ZVAL_UNDEFINED_OP1();
40323 ZVAL_NULL(var_ptr);
40324 }
40325
40326 do {
40327 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40328 zend_reference *ref = Z_REF_P(var_ptr);
40329 var_ptr = Z_REFVAL_P(var_ptr);
40330
40331 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40332 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
40333 break;
40334 }
40335 }
40336 decrement_function(var_ptr);
40337 } while (0);
40338
40339 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
40340 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40341 }
40342
40343 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40344}
40345
40346static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40347{
40348 USE_OPLINE
40349 zval *var_ptr;
40350
40351 var_ptr = EX_VAR(opline->op1.var);
40352
40353 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40354 fast_long_decrement_function(var_ptr);
40355 if (UNEXPECTED(0)) {
40356 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40357 }
40358 ZEND_VM_NEXT_OPCODE();
40359 }
40360
40361 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40362}
40363
40364static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40365{
40366 USE_OPLINE
40367 zval *var_ptr;
40368
40369 var_ptr = EX_VAR(opline->op1.var);
40370
40371 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40372 fast_long_decrement_function(var_ptr);
40373 if (UNEXPECTED(1)) {
40374 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40375 }
40376 ZEND_VM_NEXT_OPCODE();
40377 }
40378
40379 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40380}
40381
40382static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40383{
40384 USE_OPLINE
40385 zval *var_ptr;
40386
40387 var_ptr = EX_VAR(opline->op1.var);
40388
40389 SAVE_OPLINE();
40390 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40391 ZVAL_UNDEFINED_OP1();
40392 ZVAL_NULL(var_ptr);
40393 }
40394
40395 do {
40396 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40397 zend_reference *ref = Z_REF_P(var_ptr);
40398 var_ptr = Z_REFVAL_P(var_ptr);
40399
40400 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40401 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
40402 break;
40403 }
40404 }
40405 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40406
40407 increment_function(var_ptr);
40408 } while (0);
40409
40410 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40411}
40412
40413static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40414{
40415 USE_OPLINE
40416 zval *var_ptr;
40417
40418 var_ptr = EX_VAR(opline->op1.var);
40419
40420 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40421 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40422 fast_long_increment_function(var_ptr);
40423 ZEND_VM_NEXT_OPCODE();
40424 }
40425
40426 ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40427}
40428
40429static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40430{
40431 USE_OPLINE
40432 zval *var_ptr;
40433
40434 var_ptr = EX_VAR(opline->op1.var);
40435
40436 SAVE_OPLINE();
40437 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40438 ZVAL_UNDEFINED_OP1();
40439 ZVAL_NULL(var_ptr);
40440 }
40441
40442 do {
40443 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40444 zend_reference *ref = Z_REF_P(var_ptr);
40445 var_ptr = Z_REFVAL_P(var_ptr);
40446
40447 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40448 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
40449 break;
40450 }
40451 }
40452 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40453
40454 decrement_function(var_ptr);
40455 } while (0);
40456
40457 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40458}
40459
40460static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40461{
40462 USE_OPLINE
40463 zval *var_ptr;
40464
40465 var_ptr = EX_VAR(opline->op1.var);
40466
40467 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40468 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40469 fast_long_decrement_function(var_ptr);
40470 ZEND_VM_NEXT_OPCODE();
40471 }
40472
40473 ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40474}
40475
40476static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40477{
40478 USE_OPLINE
40479 zval *z;
40480
40481 SAVE_OPLINE();
40482 z = EX_VAR(opline->op1.var);
40483
40484 if (Z_TYPE_P(z) == IS_STRING) {
40485 zend_string *str = Z_STR_P(z);
40486
40487 if (ZSTR_LEN(str) != 0) {
40488 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
40489 }
40490 } else {
40491 zend_string *str = zval_get_string_func(z);
40492
40493 if (ZSTR_LEN(str) != 0) {
40494 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
40495 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
40496 ZVAL_UNDEFINED_OP1();
40497 }
40498 zend_string_release_ex(str, 0);
40499 }
40500
40501 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40502}
40503
40504static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40505{
40506 USE_OPLINE
40507 zval *val;
40508 uint8_t op1_type;
40509
40510 val = EX_VAR(opline->op1.var);
40511
40512 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40513 ZEND_VM_NEXT_OPCODE();
40514 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40515 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40516 SAVE_OPLINE();
40517 ZVAL_UNDEFINED_OP1();
40518 if (UNEXPECTED(EG(exception))) {
40519 HANDLE_EXCEPTION();
40520 }
40521 }
40522 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40523 }
40524
40525 SAVE_OPLINE();
40526 op1_type = IS_CV;
40527 if (i_zend_is_true(val)) {
40528 opline++;
40529 } else {
40530 opline = OP_JMP_ADDR(opline, opline->op2);
40531 }
40532 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
40533 zval_ptr_dtor_nogc(val);
40534 }
40535 ZEND_VM_JMP(opline);
40536}
40537
40538static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40539{
40540 USE_OPLINE
40541 zval *val;
40542 uint8_t op1_type;
40543
40544 val = EX_VAR(opline->op1.var);
40545
40546 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40547 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40548 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40549 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40550 SAVE_OPLINE();
40551 ZVAL_UNDEFINED_OP1();
40552 if (UNEXPECTED(EG(exception))) {
40553 HANDLE_EXCEPTION();
40554 }
40555 }
40556 ZEND_VM_NEXT_OPCODE();
40557 }
40558
40559 SAVE_OPLINE();
40560 op1_type = IS_CV;
40561 if (i_zend_is_true(val)) {
40562 opline = OP_JMP_ADDR(opline, opline->op2);
40563 } else {
40564 opline++;
40565 }
40566 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
40567 zval_ptr_dtor_nogc(val);
40568 }
40569 ZEND_VM_JMP(opline);
40570}
40571
40572static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40573{
40574 USE_OPLINE
40575 zval *val;
40576 bool ret;
40577
40578 val = EX_VAR(opline->op1.var);
40579
40580 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40581 ZVAL_TRUE(EX_VAR(opline->result.var));
40582 ZEND_VM_NEXT_OPCODE();
40583 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40584 ZVAL_FALSE(EX_VAR(opline->result.var));
40585 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40586 SAVE_OPLINE();
40587 ZVAL_UNDEFINED_OP1();
40588 if (UNEXPECTED(EG(exception))) {
40589 HANDLE_EXCEPTION();
40590 }
40591 }
40592 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40593 }
40594
40595 SAVE_OPLINE();
40596 ret = i_zend_is_true(val);
40597
40598 if (ret) {
40599 ZVAL_TRUE(EX_VAR(opline->result.var));
40600 opline++;
40601 } else {
40602 ZVAL_FALSE(EX_VAR(opline->result.var));
40603 opline = OP_JMP_ADDR(opline, opline->op2);
40604 }
40605 ZEND_VM_JMP(opline);
40606}
40607
40608static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40609{
40610 USE_OPLINE
40611 zval *val;
40612 bool ret;
40613
40614 val = EX_VAR(opline->op1.var);
40615
40616 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40617 ZVAL_TRUE(EX_VAR(opline->result.var));
40618 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40619 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40620 ZVAL_FALSE(EX_VAR(opline->result.var));
40621 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40622 SAVE_OPLINE();
40623 ZVAL_UNDEFINED_OP1();
40624 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40625 } else {
40626 ZEND_VM_NEXT_OPCODE();
40627 }
40628 }
40629
40630 SAVE_OPLINE();
40631 ret = i_zend_is_true(val);
40632
40633 if (ret) {
40634 ZVAL_TRUE(EX_VAR(opline->result.var));
40635 opline = OP_JMP_ADDR(opline, opline->op2);
40636 } else {
40637 ZVAL_FALSE(EX_VAR(opline->result.var));
40638 opline++;
40639 }
40640 ZEND_VM_JMP(opline);
40641}
40642
40643static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40644{
40645 USE_OPLINE
40646 zval *retval_ptr;
40647 zval *return_value;
40648
40649 retval_ptr = EX_VAR(opline->op1.var);
40650 return_value = EX(return_value);
40651
40652 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
40653 SAVE_OPLINE();
40654 retval_ptr = ZVAL_UNDEFINED_OP1();
40655 if (return_value) {
40656 ZVAL_NULL(return_value);
40657 }
40658 } else if (!return_value) {
40659 if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
40660 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
40661 SAVE_OPLINE();
40662 rc_dtor_func(Z_COUNTED_P(retval_ptr));
40663 }
40664 }
40665 } else {
40666 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
40667 ZVAL_COPY_VALUE(return_value, retval_ptr);
40668 if (IS_CV == IS_CONST) {
40669 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
40670 Z_ADDREF_P(return_value);
40671 }
40672 }
40673 } else if (IS_CV == IS_CV) {
40674 do {
40675 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40676 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
40677 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
40678 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
40679 ZVAL_COPY_VALUE(return_value, retval_ptr);
40680 if (GC_MAY_LEAK(ref)) {
40681 SAVE_OPLINE();
40682 gc_possible_root(ref);
40683 }
40684 ZVAL_NULL(retval_ptr);
40685 break;
40686 } else {
40687 Z_ADDREF_P(retval_ptr);
40688 }
40689 } else {
40690 retval_ptr = Z_REFVAL_P(retval_ptr);
40691 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40692 Z_ADDREF_P(retval_ptr);
40693 }
40694 }
40695 }
40696 ZVAL_COPY_VALUE(return_value, retval_ptr);
40697 } while (0);
40698 } else /* if (IS_CV == IS_VAR) */ {
40699 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
40700 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
40701
40702 retval_ptr = Z_REFVAL_P(retval_ptr);
40703 ZVAL_COPY_VALUE(return_value, retval_ptr);
40704 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40705 efree_size(ref, sizeof(zend_reference));
40706 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40707 Z_ADDREF_P(retval_ptr);
40708 }
40709 } else {
40710 ZVAL_COPY_VALUE(return_value, retval_ptr);
40711 }
40712 }
40713 }
40714
40715
40716
40717 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40718}
40719
40720static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40721{
40722 USE_OPLINE
40723 zval *retval_ptr;
40724 zval *return_value;
40725
40726 SAVE_OPLINE();
40727
40728 return_value = EX(return_value);
40729
40730 do {
40731 if ((IS_CV & (IS_CONST|IS_TMP_VAR)) ||
40732 (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
40733 /* Not supposed to happen, but we'll allow it */
40734 zend_error(E_NOTICE, "Only variable references should be returned by reference");
40735
40736 retval_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40737 if (!return_value) {
40738
40739 } else {
40740 if (IS_CV == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
40741 ZVAL_COPY_VALUE(return_value, retval_ptr);
40742 break;
40743 }
40744
40745 ZVAL_NEW_REF(return_value, retval_ptr);
40746 if (IS_CV == IS_CONST) {
40747 Z_TRY_ADDREF_P(retval_ptr);
40748 }
40749 }
40750 break;
40751 }
40752
40753 retval_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
40754
40755 if (IS_CV == IS_VAR) {
40756 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
40757 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
40758 zend_error(E_NOTICE, "Only variable references should be returned by reference");
40759 if (return_value) {
40760 ZVAL_NEW_REF(return_value, retval_ptr);
40761 } else {
40762
40763 }
40764 break;
40765 }
40766 }
40767
40768 if (return_value) {
40769 if (Z_ISREF_P(retval_ptr)) {
40770 Z_ADDREF_P(retval_ptr);
40771 } else {
40772 ZVAL_MAKE_REF_EX(retval_ptr, 2);
40773 }
40774 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
40775 }
40776
40777 } while (0);
40778
40779
40780 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40781}
40782
40783static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40784{
40785 USE_OPLINE
40786 zval *retval;
40787
40788 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
40789
40790 SAVE_OPLINE();
40791 retval = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40792
40793 /* Copy return value into generator->retval */
40794 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
40795 ZVAL_COPY_VALUE(&generator->retval, retval);
40796 if (IS_CV == IS_CONST) {
40797 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
40798 Z_ADDREF(generator->retval);
40799 }
40800 }
40801 } else if (IS_CV == IS_CV) {
40802 ZVAL_COPY_DEREF(&generator->retval, retval);
40803 } else /* if (IS_CV == IS_VAR) */ {
40804 if (UNEXPECTED(Z_ISREF_P(retval))) {
40805 zend_refcounted *ref = Z_COUNTED_P(retval);
40806
40807 retval = Z_REFVAL_P(retval);
40808 ZVAL_COPY_VALUE(&generator->retval, retval);
40809 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40810 efree_size(ref, sizeof(zend_reference));
40811 } else if (Z_OPT_REFCOUNTED_P(retval)) {
40812 Z_ADDREF_P(retval);
40813 }
40814 } else {
40815 ZVAL_COPY_VALUE(&generator->retval, retval);
40816 }
40817 }
40818
40819 EG(current_execute_data) = EX(prev_execute_data);
40820
40821 /* Close the generator to free up resources */
40822 zend_generator_close(generator, 1);
40823
40824 /* Pass execution back to handling code */
40825 ZEND_VM_RETURN();
40826}
40827
40828static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40829{
40830 USE_OPLINE
40831 zval *value;
40832
40833 SAVE_OPLINE();
40834 value = EX_VAR(opline->op1.var);
40835
40836 do {
40837 if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
40838 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
40839 value = Z_REFVAL_P(value);
40840 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
40841 break;
40842 }
40843 }
40844 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
40845 ZVAL_UNDEFINED_OP1();
40846 if (UNEXPECTED(EG(exception) != NULL)) {
40847 HANDLE_EXCEPTION();
40848 }
40849 }
40850 zend_throw_error(NULL, "Can only throw objects");
40851
40852 HANDLE_EXCEPTION();
40853 }
40854 } while (0);
40855
40856 zend_exception_save();
40857 Z_TRY_ADDREF_P(value);
40858 zend_throw_exception_object(value);
40859 zend_exception_restore();
40860
40861 HANDLE_EXCEPTION();
40862}
40863
40864static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40865{
40866 USE_OPLINE
40867 zval *arg, *param;
40868
40869 SAVE_OPLINE();
40870
40871 arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40872 param = ZEND_CALL_VAR(EX(call), opline->result.var);
40873 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
40874 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
40875 Z_TRY_ADDREF_P(arg);
40876 ZVAL_NEW_REF(param, arg);
40877 } else {
40878 ZVAL_COPY(param, arg);
40879 }
40880
40881 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40882}
40883
40884static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40885{
40886 USE_OPLINE
40887 zval *val;
40888
40889 val = EX_VAR(opline->op1.var);
40890 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40891 ZVAL_TRUE(EX_VAR(opline->result.var));
40892 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40893 /* The result and op1 can be the same cv zval */
40894 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
40895 ZVAL_FALSE(EX_VAR(opline->result.var));
40896 if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
40897 SAVE_OPLINE();
40898 ZVAL_UNDEFINED_OP1();
40899 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40900 }
40901 } else {
40902 SAVE_OPLINE();
40903 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
40904
40905 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40906 }
40907 ZEND_VM_NEXT_OPCODE();
40908}
40909
40910static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40911{
40912 USE_OPLINE
40913 zval *obj;
40914 zend_object *zobj;
40915 zend_class_entry *ce, *scope;
40916 zend_function *clone;
40917 zend_object_clone_obj_t clone_call;
40918
40919 SAVE_OPLINE();
40920 obj = EX_VAR(opline->op1.var);
40921
40922 do {
40923 if (IS_CV == IS_CONST ||
40924 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
40925 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
40926 obj = Z_REFVAL_P(obj);
40927 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
40928 break;
40929 }
40930 }
40931 ZVAL_UNDEF(EX_VAR(opline->result.var));
40932 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
40933 ZVAL_UNDEFINED_OP1();
40934 if (UNEXPECTED(EG(exception) != NULL)) {
40935 HANDLE_EXCEPTION();
40936 }
40937 }
40938 zend_throw_error(NULL, "__clone method called on non-object");
40939
40940 HANDLE_EXCEPTION();
40941 }
40942 } while (0);
40943
40944 zobj = Z_OBJ_P(obj);
40945 ce = zobj->ce;
40946 clone = ce->clone;
40947 clone_call = zobj->handlers->clone_obj;
40948 if (UNEXPECTED(clone_call == NULL)) {
40949 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
40950
40951 ZVAL_UNDEF(EX_VAR(opline->result.var));
40952 HANDLE_EXCEPTION();
40953 }
40954
40955 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
40956 scope = EX(func)->op_array.scope;
40957 if (clone->common.scope != scope) {
40958 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
40959 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
40960 zend_wrong_clone_call(clone, scope);
40961
40962 ZVAL_UNDEF(EX_VAR(opline->result.var));
40963 HANDLE_EXCEPTION();
40964 }
40965 }
40966 }
40967
40968 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
40969
40970 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40971}
40972
40973static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40974{
40975 USE_OPLINE
40976 zval *expr;
40977 zval *result = EX_VAR(opline->result.var);
40978 HashTable *ht;
40979
40980 SAVE_OPLINE();
40981 expr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40982
40983 switch (opline->extended_value) {
40984 case IS_LONG:
40985 ZVAL_LONG(result, zval_get_long(expr));
40986 break;
40987 case IS_DOUBLE:
40988 ZVAL_DOUBLE(result, zval_get_double(expr));
40989 break;
40990 case IS_STRING:
40991 ZVAL_STR(result, zval_get_string(expr));
40992 break;
40993 default:
40994 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
40995 if (IS_CV & (IS_VAR|IS_CV)) {
40996 ZVAL_DEREF(expr);
40997 }
40998 /* If value is already of correct type, return it directly */
40999 if (Z_TYPE_P(expr) == opline->extended_value) {
41000 ZVAL_COPY_VALUE(result, expr);
41001 if (IS_CV == IS_CONST) {
41002 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
41003 } else if (IS_CV != IS_TMP_VAR) {
41004 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
41005 }
41006
41007 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41008 }
41009
41010 if (opline->extended_value == IS_ARRAY) {
41011 if (IS_CV == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
41012 if (Z_TYPE_P(expr) != IS_NULL) {
41013 ZVAL_ARR(result, zend_new_array(1));
41014 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
41015 if (IS_CV == IS_CONST) {
41016 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
41017 } else {
41018 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
41019 }
41020 } else {
41021 ZVAL_EMPTY_ARRAY(result);
41022 }
41023 } else if (ZEND_STD_BUILD_OBJECT_PROPERTIES_ARRAY_COMPATIBLE(expr)) {
41024 /* Optimized version without rebuilding properties HashTable */
41025 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
41026 } else {
41027 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
41028 if (obj_ht) {
41029 /* fast copy */
41030 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
41031 (Z_OBJCE_P(expr)->default_properties_count ||
41032 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
41033 GC_IS_RECURSIVE(obj_ht))));
41034 zend_release_properties(obj_ht);
41035 } else {
41036 ZVAL_EMPTY_ARRAY(result);
41037 }
41038 }
41039 } else {
41040 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
41041 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
41042 if (Z_TYPE_P(expr) == IS_ARRAY) {
41043 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
41044 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
41045 /* TODO: try not to duplicate immutable arrays as well ??? */
41046 ht = zend_array_dup(ht);
41047 }
41048 Z_OBJ_P(result)->properties = ht;
41049 } else if (Z_TYPE_P(expr) != IS_NULL) {
41050 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
41051 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
41052 if (IS_CV == IS_CONST) {
41053 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
41054 } else {
41055 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
41056 }
41057 }
41058 }
41059 }
41060
41061 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41062}
41063
41064static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41065{
41066 USE_OPLINE
41067 zend_op_array *new_op_array;
41068 zval *inc_filename;
41069
41070 SAVE_OPLINE();
41071 inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41072 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
41073 if (UNEXPECTED(EG(exception) != NULL)) {
41074
41075 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
41076 destroy_op_array(new_op_array);
41077 efree_size(new_op_array, sizeof(zend_op_array));
41078 }
41079 UNDEF_RESULT();
41080 HANDLE_EXCEPTION();
41081 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
41082 if (RETURN_VALUE_USED(opline)) {
41083 ZVAL_TRUE(EX_VAR(opline->result.var));
41084 }
41085 } else if (UNEXPECTED(new_op_array == NULL)) {
41086 if (RETURN_VALUE_USED(opline)) {
41087 ZVAL_FALSE(EX_VAR(opline->result.var));
41088 }
41089 } else if (new_op_array->last == 1
41090 && new_op_array->opcodes[0].opcode == ZEND_RETURN
41091 && new_op_array->opcodes[0].op1_type == IS_CONST
41092 && EXPECTED(zend_execute_ex == execute_ex)) {
41093 if (RETURN_VALUE_USED(opline)) {
41094 const zend_op *op = new_op_array->opcodes;
41095
41096 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
41097 }
41098 zend_destroy_static_vars(new_op_array);
41099 destroy_op_array(new_op_array);
41100 efree_size(new_op_array, sizeof(zend_op_array));
41101 } else {
41102 zval *return_value = NULL;
41103 zend_execute_data *call;
41104 if (RETURN_VALUE_USED(opline)) {
41105 return_value = EX_VAR(opline->result.var);
41106 }
41107
41108 new_op_array->scope = EX(func)->op_array.scope;
41109
41110 call = zend_vm_stack_push_call_frame(
41111 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
41112 (zend_function*)new_op_array, 0,
41113 Z_PTR(EX(This)));
41114
41115 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
41116 call->symbol_table = EX(symbol_table);
41117 } else {
41118 call->symbol_table = zend_rebuild_symbol_table();
41119 }
41120
41121 call->prev_execute_data = execute_data;
41122 i_init_code_execute_data(call, new_op_array, return_value);
41123
41124 if (EXPECTED(zend_execute_ex == execute_ex)) {
41125
41126 ZEND_VM_ENTER();
41127 } else {
41128 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
41129 zend_execute_ex(call);
41130 zend_vm_stack_free_call_frame(call);
41131 }
41132
41133 zend_destroy_static_vars(new_op_array);
41134 destroy_op_array(new_op_array);
41135 efree_size(new_op_array, sizeof(zend_op_array));
41136 if (UNEXPECTED(EG(exception) != NULL)) {
41137 zend_rethrow_exception(execute_data);
41138
41139 UNDEF_RESULT();
41140 HANDLE_EXCEPTION();
41141 }
41142 }
41143
41144 ZEND_VM_NEXT_OPCODE();
41145}
41146
41147static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41148{
41149 USE_OPLINE
41150 zval *array_ptr, *result;
41151
41152 SAVE_OPLINE();
41153
41154 array_ptr = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41155 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
41156 result = EX_VAR(opline->result.var);
41157 ZVAL_COPY_VALUE(result, array_ptr);
41158 if (IS_CV != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
41159 Z_ADDREF_P(array_ptr);
41160 }
41161 Z_FE_POS_P(result) = 0;
41162
41163 ZEND_VM_NEXT_OPCODE();
41164 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
41165 zend_object *zobj = Z_OBJ_P(array_ptr);
41166 if (!zobj->ce->get_iterator) {
41167 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
41168 zobj = zend_lazy_object_init(zobj);
41169 if (UNEXPECTED(EG(exception))) {
41170 UNDEF_RESULT();
41171
41172 HANDLE_EXCEPTION();
41173 }
41174 }
41175 HashTable *properties = zobj->properties;
41176 if (properties) {
41177 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
41178 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
41179 GC_DELREF(properties);
41180 }
41181 properties = zobj->properties = zend_array_dup(properties);
41182 }
41183 } else {
41184 properties = zobj->handlers->get_properties(zobj);
41185 }
41186
41187 result = EX_VAR(opline->result.var);
41188 ZVAL_COPY_VALUE(result, array_ptr);
41189 if (IS_CV != IS_TMP_VAR) {
41190 Z_ADDREF_P(array_ptr);
41191 }
41192
41193 if (zend_hash_num_elements(properties) == 0) {
41194 Z_FE_ITER_P(result) = (uint32_t) -1;
41195
41196 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41197 }
41198
41199 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
41200
41201 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41202 } else {
41203 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
41204
41205 if (UNEXPECTED(EG(exception))) {
41206 HANDLE_EXCEPTION();
41207 } else if (is_empty) {
41208 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41209 } else {
41210 ZEND_VM_NEXT_OPCODE();
41211 }
41212 }
41213 } else {
41214 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
41215 ZVAL_UNDEF(EX_VAR(opline->result.var));
41216 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
41217
41218 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41219 }
41220}
41221
41222static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41223{
41224 USE_OPLINE
41225 zval *array_ptr, *array_ref;
41226
41227 SAVE_OPLINE();
41228
41229 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41230 array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41231 if (Z_ISREF_P(array_ref)) {
41232 array_ptr = Z_REFVAL_P(array_ref);
41233 }
41234 } else {
41235 array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41236 }
41237
41238 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
41239 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41240 if (array_ptr == array_ref) {
41241 ZVAL_NEW_REF(array_ref, array_ref);
41242 array_ptr = Z_REFVAL_P(array_ref);
41243 }
41244 Z_ADDREF_P(array_ref);
41245 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
41246 } else {
41247 array_ref = EX_VAR(opline->result.var);
41248 ZVAL_NEW_REF(array_ref, array_ptr);
41249 array_ptr = Z_REFVAL_P(array_ref);
41250 }
41251 if (IS_CV == IS_CONST) {
41252 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
41253 } else {
41254 SEPARATE_ARRAY(array_ptr);
41255 }
41256 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
41257
41258 ZEND_VM_NEXT_OPCODE();
41259 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
41260 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
41261 zend_object *zobj = Z_OBJ_P(array_ptr);
41262 HashTable *properties;
41263 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
41264 zobj = zend_lazy_object_init(zobj);
41265 if (UNEXPECTED(EG(exception))) {
41266 UNDEF_RESULT();
41267
41268 HANDLE_EXCEPTION();
41269 }
41270 }
41271 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41272 if (array_ptr == array_ref) {
41273 ZVAL_NEW_REF(array_ref, array_ref);
41274 array_ptr = Z_REFVAL_P(array_ref);
41275 }
41276 Z_ADDREF_P(array_ref);
41277 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
41278 } else {
41279 array_ptr = EX_VAR(opline->result.var);
41280 ZVAL_COPY_VALUE(array_ptr, array_ref);
41281 }
41282 if (Z_OBJ_P(array_ptr)->properties
41283 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
41284 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
41285 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
41286 }
41287 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
41288 }
41289
41290 properties = Z_OBJPROP_P(array_ptr);
41291 if (zend_hash_num_elements(properties) == 0) {
41292 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
41293
41294 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41295 }
41296
41297 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
41298
41299 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41300 } else {
41301 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
41302
41303 if (UNEXPECTED(EG(exception))) {
41304 HANDLE_EXCEPTION();
41305 } else if (is_empty) {
41306 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41307 } else {
41308 ZEND_VM_NEXT_OPCODE();
41309 }
41310 }
41311 } else {
41312 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
41313 ZVAL_UNDEF(EX_VAR(opline->result.var));
41314 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
41315
41316 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41317 }
41318}
41319
41320static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41321{
41322 USE_OPLINE
41323 zval *value;
41324 zend_reference *ref = NULL;
41325 bool ret;
41326
41327 SAVE_OPLINE();
41328 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41329
41330 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && Z_ISREF_P(value)) {
41331 if (IS_CV == IS_VAR) {
41332 ref = Z_REF_P(value);
41333 }
41334 value = Z_REFVAL_P(value);
41335 }
41336
41337 ret = i_zend_is_true(value);
41338
41339 if (UNEXPECTED(EG(exception))) {
41340
41341 ZVAL_UNDEF(EX_VAR(opline->result.var));
41342 HANDLE_EXCEPTION();
41343 }
41344
41345 if (ret) {
41346 zval *result = EX_VAR(opline->result.var);
41347
41348 ZVAL_COPY_VALUE(result, value);
41349 if (IS_CV == IS_CONST) {
41350 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
41351 } else if (IS_CV == IS_CV) {
41352 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
41353 } else if (IS_CV == IS_VAR && ref) {
41354 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41355 efree_size(ref, sizeof(zend_reference));
41356 } else if (Z_OPT_REFCOUNTED_P(result)) {
41357 Z_ADDREF_P(result);
41358 }
41359 }
41360 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41361 }
41362
41363 ZEND_VM_NEXT_OPCODE();
41364}
41365
41366static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41367{
41368 USE_OPLINE
41369 zval *value;
41370 zend_reference *ref = NULL;
41371
41372 SAVE_OPLINE();
41373 value = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
41374
41375 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
41376 if (IS_CV & IS_VAR) {
41377 ref = Z_REF_P(value);
41378 }
41379 value = Z_REFVAL_P(value);
41380 }
41381
41382 if (Z_TYPE_P(value) > IS_NULL) {
41383 zval *result = EX_VAR(opline->result.var);
41384 ZVAL_COPY_VALUE(result, value);
41385 if (IS_CV == IS_CONST) {
41386 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
41387 } else if (IS_CV == IS_CV) {
41388 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
41389 } else if ((IS_CV & IS_VAR) && ref) {
41390 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41391 efree_size(ref, sizeof(zend_reference));
41392 } else if (Z_OPT_REFCOUNTED_P(result)) {
41393 Z_ADDREF_P(result);
41394 }
41395 }
41396 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41397 }
41398
41399 if ((IS_CV & IS_VAR) && ref) {
41400 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41401 efree_size(ref, sizeof(zend_reference));
41402 }
41403 }
41404 ZEND_VM_NEXT_OPCODE();
41405}
41406
41407static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41408{
41409 USE_OPLINE
41410 zval *val, *result;
41411
41412 val = EX_VAR(opline->op1.var);
41413
41414 if (Z_TYPE_P(val) > IS_NULL) {
41415 do {
41416 if ((IS_CV == IS_CV || IS_CV == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
41417 val = Z_REFVAL_P(val);
41418 if (Z_TYPE_P(val) <= IS_NULL) {
41419
41420 break;
41421 }
41422 }
41423 ZEND_VM_NEXT_OPCODE();
41424 } while (0);
41425 }
41426
41427 result = EX_VAR(opline->result.var);
41428 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
41429 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
41430 ZVAL_NULL(result);
41431 if (IS_CV == IS_CV
41432 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
41433 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
41434 ) {
41435 SAVE_OPLINE();
41436 ZVAL_UNDEFINED_OP1();
41437 if (UNEXPECTED(EG(exception) != NULL)) {
41438 HANDLE_EXCEPTION();
41439 }
41440 }
41441 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
41442 ZVAL_FALSE(result);
41443 } else {
41444 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
41445 ZVAL_TRUE(result);
41446 }
41447
41448 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41449}
41450
41451static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41452{
41453 USE_OPLINE
41454 zval *value;
41455 zval *result = EX_VAR(opline->result.var);
41456
41457 value = EX_VAR(opline->op1.var);
41458 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41459 SAVE_OPLINE();
41460 ZVAL_UNDEFINED_OP1();
41461 ZVAL_NULL(result);
41462 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41463 }
41464
41465 if (IS_CV == IS_CV) {
41466 ZVAL_COPY_DEREF(result, value);
41467 } else if (IS_CV == IS_VAR) {
41468 if (UNEXPECTED(Z_ISREF_P(value))) {
41469 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
41470 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
41471 efree_size(Z_REF_P(value), sizeof(zend_reference));
41472 } else if (Z_OPT_REFCOUNTED_P(result)) {
41473 Z_ADDREF_P(result);
41474 }
41475 } else {
41476 ZVAL_COPY_VALUE(result, value);
41477 }
41478 } else {
41479 ZVAL_COPY_VALUE(result, value);
41480 if (IS_CV == IS_CONST) {
41481 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
41482 Z_ADDREF_P(result);
41483 }
41484 }
41485 }
41486 ZEND_VM_NEXT_OPCODE();
41487}
41488
41489static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41490{
41491 USE_OPLINE
41492 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
41493 zval *val;
41494
41495 SAVE_OPLINE();
41496 val = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41497
41498 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
41499 zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
41500
41501 UNDEF_RESULT();
41502 HANDLE_EXCEPTION();
41503 }
41504
41505yield_from_try_again:
41506 if (Z_TYPE_P(val) == IS_ARRAY) {
41507 ZVAL_COPY_VALUE(&generator->values, val);
41508 if (Z_OPT_REFCOUNTED_P(val)) {
41509 Z_ADDREF_P(val);
41510 }
41511 Z_FE_POS(generator->values) = 0;
41512
41513 } else if (IS_CV != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
41514 zend_class_entry *ce = Z_OBJCE_P(val);
41515 if (ce == zend_ce_generator) {
41516 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
41517
41518 Z_ADDREF_P(val);
41519
41520 if (UNEXPECTED(new_gen->execute_data == NULL)) {
41521 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
41522 zval_ptr_dtor(val);
41523 UNDEF_RESULT();
41524 HANDLE_EXCEPTION();
41525 } else if (Z_ISUNDEF(new_gen->retval)) {
41526 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
41527 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
41528 zval_ptr_dtor(val);
41529 UNDEF_RESULT();
41530 HANDLE_EXCEPTION();
41531 } else {
41532 zend_generator_yield_from(generator, new_gen);
41533 }
41534 } else {
41535 if (RETURN_VALUE_USED(opline)) {
41536 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
41537 }
41538 ZEND_VM_NEXT_OPCODE();
41539 }
41540 } else {
41541 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
41542
41543 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
41544 if (!EG(exception)) {
41545 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
41546 }
41547 UNDEF_RESULT();
41548 HANDLE_EXCEPTION();
41549 }
41550
41551 iter->index = 0;
41552 if (iter->funcs->rewind) {
41553 iter->funcs->rewind(iter);
41554 if (UNEXPECTED(EG(exception) != NULL)) {
41555 OBJ_RELEASE(&iter->std);
41556 UNDEF_RESULT();
41557 HANDLE_EXCEPTION();
41558 }
41559 }
41560
41561 ZVAL_OBJ(&generator->values, &iter->std);
41562 }
41563 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
41564 val = Z_REFVAL_P(val);
41565 goto yield_from_try_again;
41566 } else {
41567 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
41568
41569 UNDEF_RESULT();
41570 HANDLE_EXCEPTION();
41571 }
41572
41573 /* This is the default return value
41574 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
41575 if (RETURN_VALUE_USED(opline)) {
41576 ZVAL_NULL(EX_VAR(opline->result.var));
41577 }
41578
41579 /* This generator has no send target (though the generator we delegate to might have one) */
41580 generator->send_target = NULL;
41581
41582 /* The GOTO VM uses a local opline variable. We need to set the opline
41583 * variable in execute_data so we don't resume at an old position. */
41584 SAVE_OPLINE();
41585
41586 ZEND_VM_RETURN();
41587}
41588
41589static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41590{
41591 USE_OPLINE
41592 zval *value;
41593
41594 value = EX_VAR(opline->op1.var);
41595 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
41596 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
41597 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41598 zval_ptr_dtor_str(value);
41599 }
41600 ZEND_VM_NEXT_OPCODE();
41601 } else {
41602 bool strict;
41603
41604 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
41605 value = Z_REFVAL_P(value);
41606 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
41607 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
41608
41609 ZEND_VM_NEXT_OPCODE();
41610 }
41611 }
41612
41613 SAVE_OPLINE();
41614 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41615 value = ZVAL_UNDEFINED_OP1();
41616 }
41617 strict = EX_USES_STRICT_TYPES();
41618 do {
41619 if (EXPECTED(!strict)) {
41620 zend_string *str;
41621 zval tmp;
41622
41623 if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
41624 zend_error(E_DEPRECATED,
41625 "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
41626 ZVAL_LONG(EX_VAR(opline->result.var), 0);
41627 if (UNEXPECTED(EG(exception))) {
41628 HANDLE_EXCEPTION();
41629 }
41630 break;
41631 }
41632
41633 ZVAL_COPY(&tmp, value);
41634 if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
41635 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
41636 zval_ptr_dtor(&tmp);
41637 break;
41638 }
41639 zval_ptr_dtor(&tmp);
41640 }
41641 if (!EG(exception)) {
41642 zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
41643 }
41644 ZVAL_UNDEF(EX_VAR(opline->result.var));
41645 } while (0);
41646 }
41647
41648 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41649}
41650
41651static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41652{
41653 USE_OPLINE
41654 zval *value;
41655 int result = 0;
41656
41657 value = EX_VAR(opline->op1.var);
41658 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
41659type_check_resource:
41660 if (opline->extended_value != MAY_BE_RESOURCE
41661 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
41662 result = 1;
41663 }
41664 } else if ((IS_CV & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
41665 value = Z_REFVAL_P(value);
41666 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
41667 goto type_check_resource;
41668 }
41669 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41670 result = ((1 << IS_NULL) & opline->extended_value) != 0;
41671 SAVE_OPLINE();
41672 ZVAL_UNDEFINED_OP1();
41673 if (UNEXPECTED(EG(exception))) {
41674 ZVAL_UNDEF(EX_VAR(opline->result.var));
41675 HANDLE_EXCEPTION();
41676 }
41677 }
41678 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41679 SAVE_OPLINE();
41680
41681 ZEND_VM_SMART_BRANCH(result, 1);
41682 } else {
41683 ZEND_VM_SMART_BRANCH(result, 0);
41684 }
41685}
41686
41687static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41688{
41689 uint32_t fetch_type;
41690 zend_class_entry *called_scope, *scope;
41691 USE_OPLINE
41692
41693 if (IS_CV != IS_UNUSED) {
41694 SAVE_OPLINE();
41695 zval *op = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41696 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
41697 ZVAL_DEREF(op);
41698 if (Z_TYPE_P(op) != IS_OBJECT) {
41699 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
41700 ZVAL_UNDEF(EX_VAR(opline->result.var));
41701
41702 HANDLE_EXCEPTION();
41703 }
41704 }
41705
41706 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
41707
41708 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41709 }
41710
41711 fetch_type = opline->op1.num;
41712 scope = EX(func)->op_array.scope;
41713 if (UNEXPECTED(scope == NULL)) {
41714 SAVE_OPLINE();
41715 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
41716 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
41717 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
41718 ZVAL_UNDEF(EX_VAR(opline->result.var));
41719 HANDLE_EXCEPTION();
41720 }
41721
41722 switch (fetch_type) {
41723 case ZEND_FETCH_CLASS_SELF:
41724 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
41725 break;
41726 case ZEND_FETCH_CLASS_PARENT:
41727 if (UNEXPECTED(scope->parent == NULL)) {
41728 SAVE_OPLINE();
41729 zend_throw_error(NULL,
41730 "Cannot use \"parent\" when current class scope has no parent");
41731 ZVAL_UNDEF(EX_VAR(opline->result.var));
41732 HANDLE_EXCEPTION();
41733 }
41734 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
41735 break;
41736 case ZEND_FETCH_CLASS_STATIC:
41737 if (Z_TYPE(EX(This)) == IS_OBJECT) {
41738 called_scope = Z_OBJCE(EX(This));
41739 } else {
41740 called_scope = Z_CE(EX(This));
41741 }
41742 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
41743 break;
41744 EMPTY_SWITCH_DEFAULT_CASE()
41745 }
41746 ZEND_VM_NEXT_OPCODE();
41747}
41748
41749static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41750{
41751 USE_OPLINE
41752 HashTable *ht;
41753 zval *value;
41754 zval *variable_ptr;
41755
41756 variable_ptr = EX_VAR(opline->op1.var);
41757
41758 SAVE_OPLINE();
41759
41760 ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
41761 if (!ht) {
41762 ht = zend_array_dup(EX(func)->op_array.static_variables);
41763 ZEND_MAP_PTR_SET(EX(func)->op_array.static_variables_ptr, ht);
41764 }
41765 ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
41766
41767 value = (zval*)((char*)ht->arData + (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT|ZEND_BIND_EXPLICIT)));
41768
41769 if (opline->extended_value & ZEND_BIND_REF) {
41770 if (UNEXPECTED(!Z_ISREF_P(value))) {
41771 zend_reference *ref = (zend_reference*)emalloc(sizeof(zend_reference));
41772 GC_SET_REFCOUNT(ref, 2);
41773 GC_TYPE_INFO(ref) = GC_REFERENCE;
41774 if (opline->op2_type == IS_UNUSED) {
41775 ZVAL_COPY_VALUE(&ref->val, value);
41776 } else {
41777 ZEND_ASSERT(!Z_REFCOUNTED_P(value));
41778 ZVAL_COPY(&ref->val, get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R));
41779 FREE_OP(opline->op2_type, opline->op2.var);
41780 }
41781 ref->sources.ptr = NULL;
41782 Z_REF_P(value) = ref;
41783 Z_TYPE_INFO_P(value) = IS_REFERENCE_EX;
41784 i_zval_ptr_dtor(variable_ptr);
41785 ZVAL_REF(variable_ptr, ref);
41786 } else {
41787 Z_ADDREF_P(value);
41788 i_zval_ptr_dtor(variable_ptr);
41789 ZVAL_REF(variable_ptr, Z_REF_P(value));
41790 if (opline->op2_type != IS_UNUSED) {
41791 FREE_OP(opline->op2_type, opline->op2.var);
41792 }
41793 }
41794 } else {
41795 i_zval_ptr_dtor(variable_ptr);
41796 ZVAL_COPY(variable_ptr, value);
41797 }
41798
41799 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41800}
41801
41802static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41803{
41804 USE_OPLINE
41805 HashTable *ht;
41806 zval *value;
41807 zval *variable_ptr;
41808
41809 variable_ptr = EX_VAR(opline->op1.var);
41810
41811 ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
41812 if (!ht) {
41813 ZEND_VM_NEXT_OPCODE();
41814 }
41815 ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
41816
41817 value = (zval*)((char*)ht->arData + opline->extended_value);
41818 if (Z_TYPE_P(value) == IS_NULL) {
41819 ZEND_VM_NEXT_OPCODE();
41820 } else {
41821 SAVE_OPLINE();
41822 zval_ptr_dtor(variable_ptr);
41823 ZEND_ASSERT(Z_TYPE_P(value) == IS_REFERENCE);
41824 Z_ADDREF_P(value);
41825 ZVAL_REF(variable_ptr, Z_REF_P(value));
41826 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 1);
41827 }
41828}
41829
41830static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41831{
41832 USE_OPLINE
41833 zval *var_ptr;
41834
41835 var_ptr = EX_VAR(opline->op1.var);
41836 Z_LVAL_P(var_ptr)++;
41837 if (UNEXPECTED(0)) {
41838 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41839 }
41840 ZEND_VM_NEXT_OPCODE();
41841}
41842
41843static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41844{
41845 USE_OPLINE
41846 zval *var_ptr;
41847
41848 var_ptr = EX_VAR(opline->op1.var);
41849 Z_LVAL_P(var_ptr)++;
41850 if (UNEXPECTED(1)) {
41851 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41852 }
41853 ZEND_VM_NEXT_OPCODE();
41854}
41855
41856static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41857{
41858 USE_OPLINE
41859 zval *var_ptr;
41860
41861 var_ptr = EX_VAR(opline->op1.var);
41862 fast_long_increment_function(var_ptr);
41863 if (UNEXPECTED(0)) {
41864 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41865 }
41866 ZEND_VM_NEXT_OPCODE();
41867}
41868
41869static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41870{
41871 USE_OPLINE
41872 zval *var_ptr;
41873
41874 var_ptr = EX_VAR(opline->op1.var);
41875 fast_long_increment_function(var_ptr);
41876 if (UNEXPECTED(1)) {
41877 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41878 }
41879 ZEND_VM_NEXT_OPCODE();
41880}
41881
41882static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41883{
41884 USE_OPLINE
41885 zval *var_ptr;
41886
41887 var_ptr = EX_VAR(opline->op1.var);
41888 Z_LVAL_P(var_ptr)--;
41889 if (UNEXPECTED(0)) {
41890 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41891 }
41892 ZEND_VM_NEXT_OPCODE();
41893}
41894
41895static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41896{
41897 USE_OPLINE
41898 zval *var_ptr;
41899
41900 var_ptr = EX_VAR(opline->op1.var);
41901 Z_LVAL_P(var_ptr)--;
41902 if (UNEXPECTED(1)) {
41903 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41904 }
41905 ZEND_VM_NEXT_OPCODE();
41906}
41907
41908static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41909{
41910 USE_OPLINE
41911 zval *var_ptr;
41912
41913 var_ptr = EX_VAR(opline->op1.var);
41914 fast_long_decrement_function(var_ptr);
41915 if (UNEXPECTED(0)) {
41916 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41917 }
41918 ZEND_VM_NEXT_OPCODE();
41919}
41920
41921static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41922{
41923 USE_OPLINE
41924 zval *var_ptr;
41925
41926 var_ptr = EX_VAR(opline->op1.var);
41927 fast_long_decrement_function(var_ptr);
41928 if (UNEXPECTED(1)) {
41929 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41930 }
41931 ZEND_VM_NEXT_OPCODE();
41932}
41933
41934static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41935{
41936 USE_OPLINE
41937 zval *var_ptr;
41938
41939 var_ptr = EX_VAR(opline->op1.var);
41940 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41941 Z_LVAL_P(var_ptr)++;
41942 ZEND_VM_NEXT_OPCODE();
41943}
41944
41945static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41946{
41947 USE_OPLINE
41948 zval *var_ptr;
41949
41950 var_ptr = EX_VAR(opline->op1.var);
41951 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41952 fast_long_increment_function(var_ptr);
41953 ZEND_VM_NEXT_OPCODE();
41954}
41955
41956static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41957{
41958 USE_OPLINE
41959 zval *var_ptr;
41960
41961 var_ptr = EX_VAR(opline->op1.var);
41962 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41963 Z_LVAL_P(var_ptr)--;
41964 ZEND_VM_NEXT_OPCODE();
41965}
41966
41967static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41968{
41969 USE_OPLINE
41970 zval *var_ptr;
41971
41972 var_ptr = EX_VAR(opline->op1.var);
41973 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41974 fast_long_decrement_function(var_ptr);
41975 ZEND_VM_NEXT_OPCODE();
41976}
41977
41978static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41979{
41980 USE_OPLINE
41981 zval *varptr, *arg;
41982
41983 varptr = EX_VAR(opline->op1.var);
41984 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
41985
41986 if (IS_CV == IS_CV) {
41987 ZVAL_COPY(arg, varptr);
41988 } else /* if (IS_CV == IS_VAR) */ {
41989 ZVAL_COPY_VALUE(arg, varptr);
41990 }
41991
41992 ZEND_VM_NEXT_OPCODE();
41993}
41994
41995static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41996{
41997 USE_OPLINE
41998 zval *op1, *op2;
41999
42000 SAVE_OPLINE();
42001 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42002 op2 = RT_CONSTANT(opline, opline->op2);
42003 div_function(EX_VAR(opline->result.var), op1, op2);
42004
42005
42006 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42007}
42008
42009static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42010{
42011 USE_OPLINE
42012 zval *op1, *op2;
42013
42014 SAVE_OPLINE();
42015 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42016 op2 = RT_CONSTANT(opline, opline->op2);
42017 pow_function(EX_VAR(opline->result.var), op1, op2);
42018
42019
42020 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42021}
42022
42023static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42024{
42025 USE_OPLINE
42026 zval *op1, *op2;
42027
42028 op1 = EX_VAR(opline->op1.var);
42029 op2 = RT_CONSTANT(opline, opline->op2);
42030
42031 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
42032 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
42033 zend_string *op1_str = Z_STR_P(op1);
42034 zend_string *op2_str = Z_STR_P(op2);
42035 zend_string *str;
42036 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
42037
42038 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
42039 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
42040 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
42041 } else {
42042 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
42043 }
42044 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42045 zend_string_release_ex(op1_str, 0);
42046 }
42047 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
42048 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
42049 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
42050 } else {
42051 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
42052 }
42053 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42054 zend_string_release_ex(op2_str, 0);
42055 }
42056 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
42057 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
42058 size_t len = ZSTR_LEN(op1_str);
42059
42060 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
42061 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
42062 }
42063 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
42064 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
42065 GC_ADD_FLAGS(str, flags);
42066 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
42067 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42068 zend_string_release_ex(op2_str, 0);
42069 }
42070 } else {
42071 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
42072 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
42073 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
42074 GC_ADD_FLAGS(str, flags);
42075 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
42076 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42077 zend_string_release_ex(op1_str, 0);
42078 }
42079 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42080 zend_string_release_ex(op2_str, 0);
42081 }
42082 }
42083 ZEND_VM_NEXT_OPCODE();
42084 } else {
42085 SAVE_OPLINE();
42086
42087 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
42088 op1 = ZVAL_UNDEFINED_OP1();
42089 }
42090 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
42091 op2 = ZVAL_UNDEFINED_OP2();
42092 }
42093 concat_function(EX_VAR(opline->result.var), op1, op2);
42094
42095
42096 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42097 }
42098}
42099
42100static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42101{
42102 USE_OPLINE
42103 zval *op1, *op2;
42104 bool result;
42105
42106 SAVE_OPLINE();
42107 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42108 op2 = RT_CONSTANT(opline, opline->op2);
42109 result = fast_is_identical_function(op1, op2);
42110
42111
42112 ZEND_VM_SMART_BRANCH(result, 1);
42113}
42114
42115static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42116{
42117 USE_OPLINE
42118 zval *op1, *op2;
42119 bool result;
42120
42121 SAVE_OPLINE();
42122 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42123 op2 = RT_CONSTANT(opline, opline->op2);
42124 result = fast_is_not_identical_function(op1, op2);
42125
42126
42127 ZEND_VM_SMART_BRANCH(result, 1);
42128}
42129
42130static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42131{
42132 USE_OPLINE
42133 zval *op1, *op2;
42134 double d1, d2;
42135
42136 op1 = EX_VAR(opline->op1.var);
42137 op2 = RT_CONSTANT(opline, opline->op2);
42138 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42139 /* pass */
42140 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42141 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42142 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42143is_equal_true:
42144 ZEND_VM_SMART_BRANCH_TRUE_NONE();
42145 } else {
42146is_equal_false:
42147 ZEND_VM_SMART_BRANCH_FALSE_NONE();
42148 }
42149 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42150 d1 = (double)Z_LVAL_P(op1);
42151 d2 = Z_DVAL_P(op2);
42152 goto is_equal_double;
42153 }
42154 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42155 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42156 d1 = Z_DVAL_P(op1);
42157 d2 = Z_DVAL_P(op2);
42158is_equal_double:
42159 if (d1 == d2) {
42160 goto is_equal_true;
42161 } else {
42162 goto is_equal_false;
42163 }
42164 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42165 d1 = Z_DVAL_P(op1);
42166 d2 = (double)Z_LVAL_P(op2);
42167 goto is_equal_double;
42168 }
42169 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42170 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42171 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42172 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42173 zval_ptr_dtor_str(op1);
42174 }
42175 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42176 zval_ptr_dtor_str(op2);
42177 }
42178 if (result) {
42179 goto is_equal_true;
42180 } else {
42181 goto is_equal_false;
42182 }
42183 }
42184 }
42185 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42186}
42187
42188static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42189{
42190 USE_OPLINE
42191 zval *op1, *op2;
42192 double d1, d2;
42193
42194 op1 = EX_VAR(opline->op1.var);
42195 op2 = RT_CONSTANT(opline, opline->op2);
42196 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42197 /* pass */
42198 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42199 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42200 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42201is_equal_true:
42202 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
42203 } else {
42204is_equal_false:
42205 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
42206 }
42207 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42208 d1 = (double)Z_LVAL_P(op1);
42209 d2 = Z_DVAL_P(op2);
42210 goto is_equal_double;
42211 }
42212 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42213 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42214 d1 = Z_DVAL_P(op1);
42215 d2 = Z_DVAL_P(op2);
42216is_equal_double:
42217 if (d1 == d2) {
42218 goto is_equal_true;
42219 } else {
42220 goto is_equal_false;
42221 }
42222 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42223 d1 = Z_DVAL_P(op1);
42224 d2 = (double)Z_LVAL_P(op2);
42225 goto is_equal_double;
42226 }
42227 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42228 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42229 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42230 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42231 zval_ptr_dtor_str(op1);
42232 }
42233 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42234 zval_ptr_dtor_str(op2);
42235 }
42236 if (result) {
42237 goto is_equal_true;
42238 } else {
42239 goto is_equal_false;
42240 }
42241 }
42242 }
42243 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42244}
42245
42246static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42247{
42248 USE_OPLINE
42249 zval *op1, *op2;
42250 double d1, d2;
42251
42252 op1 = EX_VAR(opline->op1.var);
42253 op2 = RT_CONSTANT(opline, opline->op2);
42254 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42255 /* pass */
42256 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42257 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42258 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42259is_equal_true:
42260 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
42261 } else {
42262is_equal_false:
42263 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
42264 }
42265 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42266 d1 = (double)Z_LVAL_P(op1);
42267 d2 = Z_DVAL_P(op2);
42268 goto is_equal_double;
42269 }
42270 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42271 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42272 d1 = Z_DVAL_P(op1);
42273 d2 = Z_DVAL_P(op2);
42274is_equal_double:
42275 if (d1 == d2) {
42276 goto is_equal_true;
42277 } else {
42278 goto is_equal_false;
42279 }
42280 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42281 d1 = Z_DVAL_P(op1);
42282 d2 = (double)Z_LVAL_P(op2);
42283 goto is_equal_double;
42284 }
42285 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42286 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42287 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42288 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42289 zval_ptr_dtor_str(op1);
42290 }
42291 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42292 zval_ptr_dtor_str(op2);
42293 }
42294 if (result) {
42295 goto is_equal_true;
42296 } else {
42297 goto is_equal_false;
42298 }
42299 }
42300 }
42301 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42302}
42303
42304static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42305{
42306 USE_OPLINE
42307 zval *op1, *op2;
42308 double d1, d2;
42309
42310 op1 = EX_VAR(opline->op1.var);
42311 op2 = RT_CONSTANT(opline, opline->op2);
42312 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42313 /* pass */
42314 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42315 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42316 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42317is_not_equal_true:
42318 ZEND_VM_SMART_BRANCH_TRUE_NONE();
42319 } else {
42320is_not_equal_false:
42321 ZEND_VM_SMART_BRANCH_FALSE_NONE();
42322 }
42323 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42324 d1 = (double)Z_LVAL_P(op1);
42325 d2 = Z_DVAL_P(op2);
42326 goto is_not_equal_double;
42327 }
42328 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42329 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42330 d1 = Z_DVAL_P(op1);
42331 d2 = Z_DVAL_P(op2);
42332is_not_equal_double:
42333 if (d1 != d2) {
42334 goto is_not_equal_true;
42335 } else {
42336 goto is_not_equal_false;
42337 }
42338 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42339 d1 = Z_DVAL_P(op1);
42340 d2 = (double)Z_LVAL_P(op2);
42341 goto is_not_equal_double;
42342 }
42343 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42344 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42345 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42346 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42347 zval_ptr_dtor_str(op1);
42348 }
42349 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42350 zval_ptr_dtor_str(op2);
42351 }
42352 if (!result) {
42353 goto is_not_equal_true;
42354 } else {
42355 goto is_not_equal_false;
42356 }
42357 }
42358 }
42359 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42360}
42361
42362static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42363{
42364 USE_OPLINE
42365 zval *op1, *op2;
42366 double d1, d2;
42367
42368 op1 = EX_VAR(opline->op1.var);
42369 op2 = RT_CONSTANT(opline, opline->op2);
42370 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42371 /* pass */
42372 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42373 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42374 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42375is_not_equal_true:
42376 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
42377 } else {
42378is_not_equal_false:
42379 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
42380 }
42381 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42382 d1 = (double)Z_LVAL_P(op1);
42383 d2 = Z_DVAL_P(op2);
42384 goto is_not_equal_double;
42385 }
42386 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42387 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42388 d1 = Z_DVAL_P(op1);
42389 d2 = Z_DVAL_P(op2);
42390is_not_equal_double:
42391 if (d1 != d2) {
42392 goto is_not_equal_true;
42393 } else {
42394 goto is_not_equal_false;
42395 }
42396 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42397 d1 = Z_DVAL_P(op1);
42398 d2 = (double)Z_LVAL_P(op2);
42399 goto is_not_equal_double;
42400 }
42401 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42402 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42403 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42404 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42405 zval_ptr_dtor_str(op1);
42406 }
42407 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42408 zval_ptr_dtor_str(op2);
42409 }
42410 if (!result) {
42411 goto is_not_equal_true;
42412 } else {
42413 goto is_not_equal_false;
42414 }
42415 }
42416 }
42417 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42418}
42419
42420static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42421{
42422 USE_OPLINE
42423 zval *op1, *op2;
42424 double d1, d2;
42425
42426 op1 = EX_VAR(opline->op1.var);
42427 op2 = RT_CONSTANT(opline, opline->op2);
42428 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42429 /* pass */
42430 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42431 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42432 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42433is_not_equal_true:
42434 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
42435 } else {
42436is_not_equal_false:
42437 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
42438 }
42439 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42440 d1 = (double)Z_LVAL_P(op1);
42441 d2 = Z_DVAL_P(op2);
42442 goto is_not_equal_double;
42443 }
42444 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42445 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42446 d1 = Z_DVAL_P(op1);
42447 d2 = Z_DVAL_P(op2);
42448is_not_equal_double:
42449 if (d1 != d2) {
42450 goto is_not_equal_true;
42451 } else {
42452 goto is_not_equal_false;
42453 }
42454 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42455 d1 = Z_DVAL_P(op1);
42456 d2 = (double)Z_LVAL_P(op2);
42457 goto is_not_equal_double;
42458 }
42459 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42460 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42461 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42462 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42463 zval_ptr_dtor_str(op1);
42464 }
42465 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42466 zval_ptr_dtor_str(op2);
42467 }
42468 if (!result) {
42469 goto is_not_equal_true;
42470 } else {
42471 goto is_not_equal_false;
42472 }
42473 }
42474 }
42475 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42476}
42477
42478static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42479{
42480 USE_OPLINE
42481 zval *op1, *op2;
42482
42483 SAVE_OPLINE();
42484 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42485 op2 = RT_CONSTANT(opline, opline->op2);
42486 compare_function(EX_VAR(opline->result.var), op1, op2);
42487
42488
42489 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42490}
42491
42492static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42493{
42494 USE_OPLINE
42495 zval *op1, *op2;
42496
42497 SAVE_OPLINE();
42498 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42499 op2 = RT_CONSTANT(opline, opline->op2);
42500 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
42501
42502
42503 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42504}
42505
42506static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42507{
42508 USE_OPLINE
42509 zval *object;
42510 zval *property;
42511 zval *value;
42512 zval *zptr;
42513 void *_cache_slot[3] = {0};
42514 void **cache_slot;
42515 zend_property_info *prop_info;
42516 zend_object *zobj;
42517 zend_string *name, *tmp_name;
42518
42519 SAVE_OPLINE();
42520 object = EX_VAR(opline->op1.var);
42521 property = RT_CONSTANT(opline, opline->op2);
42522
42523 do {
42524 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
42525
42526 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42527 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42528 object = Z_REFVAL_P(object);
42529 goto assign_op_object;
42530 }
42531 if (IS_CV == IS_CV
42532 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42533 ZVAL_UNDEFINED_OP1();
42534 }
42535 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42536 break;
42537 }
42538
42539assign_op_object:
42540 /* here we are sure we are dealing with an object */
42541 zobj = Z_OBJ_P(object);
42542 if (IS_CONST == IS_CONST) {
42543 name = Z_STR_P(property);
42544 } else {
42545 name = zval_try_get_tmp_string(property, &tmp_name);
42546 if (UNEXPECTED(!name)) {
42547 UNDEF_RESULT();
42548 break;
42549 }
42550 }
42551 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
42552 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42553 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42554 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42555 ZVAL_NULL(EX_VAR(opline->result.var));
42556 }
42557 } else {
42558 zend_reference *ref;
42559
42560 do {
42561 if (UNEXPECTED(Z_ISREF_P(zptr))) {
42562 ref = Z_REF_P(zptr);
42563 zptr = Z_REFVAL_P(zptr);
42564 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42565 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42566 break;
42567 }
42568 }
42569
42570 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
42571 if (prop_info) {
42572 /* special case for typed properties */
42573 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
42574 } else {
42575 zend_binary_op(zptr, zptr, value OPLINE_CC);
42576 }
42577 } while (0);
42578
42579 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42580 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
42581 }
42582 }
42583 } else {
42584 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
42585 }
42586 if (IS_CONST != IS_CONST) {
42587 zend_tmp_string_release(tmp_name);
42588 }
42589 } while (0);
42590
42591 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42592
42593
42594 /* assign_obj has two opcodes! */
42595 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42596}
42597
42598/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
42599static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42600{
42601 USE_OPLINE
42602 zval *var_ptr;
42603 zval *value, *container, *dim;
42604 HashTable *ht;
42605
42606 SAVE_OPLINE();
42607 container = EX_VAR(opline->op1.var);
42608
42609 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42610assign_dim_op_array:
42611 SEPARATE_ARRAY(container);
42612 ht = Z_ARRVAL_P(container);
42613assign_dim_op_new_array:
42614 dim = RT_CONSTANT(opline, opline->op2);
42615 if (IS_CONST == IS_UNUSED) {
42616 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
42617 if (UNEXPECTED(!var_ptr)) {
42618 zend_cannot_add_element();
42619 goto assign_dim_op_ret_null;
42620 }
42621 } else {
42622 if (IS_CONST == IS_CONST) {
42623 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
42624 } else {
42625 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
42626 }
42627 if (UNEXPECTED(!var_ptr)) {
42628 goto assign_dim_op_ret_null;
42629 }
42630 }
42631
42632 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
42633
42634 do {
42635 if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
42636 zend_reference *ref = Z_REF_P(var_ptr);
42637 var_ptr = Z_REFVAL_P(var_ptr);
42638 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42639 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42640 break;
42641 }
42642 }
42643 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
42644 } while (0);
42645
42646 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42647 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
42648 }
42649 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42650 } else {
42651 if (EXPECTED(Z_ISREF_P(container))) {
42652 container = Z_REFVAL_P(container);
42653 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42654 goto assign_dim_op_array;
42655 }
42656 }
42657
42658 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
42659 zend_object *obj = Z_OBJ_P(container);
42660
42661 dim = RT_CONSTANT(opline, opline->op2);
42662 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42663 dim++;
42664 }
42665 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
42666 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
42667 uint8_t old_type;
42668
42669 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
42670 ZVAL_UNDEFINED_OP1();
42671 }
42672 ht = zend_new_array(8);
42673 old_type = Z_TYPE_P(container);
42674 ZVAL_ARR(container, ht);
42675 if (UNEXPECTED(old_type == IS_FALSE)) {
42676 GC_ADDREF(ht);
42677 zend_false_to_array_deprecated();
42678 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
42679 zend_array_destroy(ht);
42680 goto assign_dim_op_ret_null;
42681 }
42682 }
42683 goto assign_dim_op_new_array;
42684 } else {
42685 dim = RT_CONSTANT(opline, opline->op2);
42686 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
42687assign_dim_op_ret_null:
42688 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42689 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42690 ZVAL_NULL(EX_VAR(opline->result.var));
42691 }
42692 }
42693 }
42694
42695
42696 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42697}
42698
42699static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42700{
42701 USE_OPLINE
42702 zval *var_ptr;
42703 zval *value;
42704
42705 SAVE_OPLINE();
42706 value = RT_CONSTANT(opline, opline->op2);
42707 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
42708
42709 do {
42710 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
42711 zend_reference *ref = Z_REF_P(var_ptr);
42712 var_ptr = Z_REFVAL_P(var_ptr);
42713 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42714 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42715 break;
42716 }
42717 }
42718 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
42719 } while (0);
42720
42721 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42722 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
42723 }
42724
42725
42726 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42727}
42728
42729static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42730{
42731 USE_OPLINE
42732 zval *object;
42733 zval *property;
42734 zval *zptr;
42735 void *_cache_slot[3] = {0};
42736 void **cache_slot;
42737 zend_property_info *prop_info;
42738 zend_object *zobj;
42739 zend_string *name, *tmp_name;
42740
42741 SAVE_OPLINE();
42742 object = EX_VAR(opline->op1.var);
42743 property = RT_CONSTANT(opline, opline->op2);
42744
42745 do {
42746 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42747 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42748 object = Z_REFVAL_P(object);
42749 goto pre_incdec_object;
42750 }
42751 if (IS_CV == IS_CV
42752 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42753 ZVAL_UNDEFINED_OP1();
42754 }
42755 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42756 break;
42757 }
42758
42759pre_incdec_object:
42760 /* here we are sure we are dealing with an object */
42761 zobj = Z_OBJ_P(object);
42762 if (IS_CONST == IS_CONST) {
42763 name = Z_STR_P(property);
42764 } else {
42765 name = zval_try_get_tmp_string(property, &tmp_name);
42766 if (UNEXPECTED(!name)) {
42767 UNDEF_RESULT();
42768 break;
42769 }
42770 }
42771 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
42772 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42773 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42774 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42775 ZVAL_NULL(EX_VAR(opline->result.var));
42776 }
42777 } else {
42778 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
42779 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
42780 }
42781 } else {
42782 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
42783 }
42784 if (IS_CONST != IS_CONST) {
42785 zend_tmp_string_release(tmp_name);
42786 }
42787 } while (0);
42788
42789
42790 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42791}
42792
42793static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42794{
42795 USE_OPLINE
42796 zval *object;
42797 zval *property;
42798 zval *zptr;
42799 void *_cache_slot[3] = {0};
42800 void **cache_slot;
42801 zend_property_info *prop_info;
42802 zend_object *zobj;
42803 zend_string *name, *tmp_name;
42804
42805 SAVE_OPLINE();
42806 object = EX_VAR(opline->op1.var);
42807 property = RT_CONSTANT(opline, opline->op2);
42808
42809 do {
42810 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42811 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42812 object = Z_REFVAL_P(object);
42813 goto post_incdec_object;
42814 }
42815 if (IS_CV == IS_CV
42816 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42817 ZVAL_UNDEFINED_OP1();
42818 }
42819 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42820 break;
42821 }
42822
42823post_incdec_object:
42824 /* here we are sure we are dealing with an object */
42825 zobj = Z_OBJ_P(object);
42826 if (IS_CONST == IS_CONST) {
42827 name = Z_STR_P(property);
42828 } else {
42829 name = zval_try_get_tmp_string(property, &tmp_name);
42830 if (UNEXPECTED(!name)) {
42831 ZVAL_UNDEF(EX_VAR(opline->result.var));
42832 break;
42833 }
42834 }
42835 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
42836 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42837 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42838 ZVAL_NULL(EX_VAR(opline->result.var));
42839 } else {
42840 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
42841 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
42842 }
42843 } else {
42844 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
42845 }
42846 if (IS_CONST != IS_CONST) {
42847 zend_tmp_string_release(tmp_name);
42848 }
42849 } while (0);
42850
42851
42852 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42853}
42854
42855static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42856{
42857 USE_OPLINE
42858 zval *container, *dim, *value;
42859
42860 SAVE_OPLINE();
42861 container = EX_VAR(opline->op1.var);
42862 dim = RT_CONSTANT(opline, opline->op2);
42863 if (IS_CV != IS_CONST) {
42864 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42865fetch_dim_r_array:
42866 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
42867 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42868 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
42869 container = Z_REFVAL_P(container);
42870 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42871 goto fetch_dim_r_array;
42872 } else {
42873 goto fetch_dim_r_slow;
42874 }
42875 } else {
42876fetch_dim_r_slow:
42877 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42878 dim++;
42879 }
42880 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
42881 }
42882 } else {
42883 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42884 }
42885
42886
42887 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42888}
42889
42890static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42891{
42892 USE_OPLINE
42893 zval *container;
42894
42895 SAVE_OPLINE();
42896 container = EX_VAR(opline->op1.var);
42897 zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42898
42899 if (IS_CV == IS_VAR) {
42900 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42901 }
42902 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42903}
42904
42905static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42906{
42907 USE_OPLINE
42908 zval *container;
42909
42910 SAVE_OPLINE();
42911 container = EX_VAR(opline->op1.var);
42912 zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42913
42914 if (IS_CV == IS_VAR) {
42915 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42916 }
42917 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42918}
42919
42920static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42921{
42922 USE_OPLINE
42923 zval *container;
42924
42925 SAVE_OPLINE();
42926 container = EX_VAR(opline->op1.var);
42927 zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42928
42929
42930 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42931}
42932
42933static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42934{
42935#if 0
42936 USE_OPLINE
42937#endif
42938
42939 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
42940 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
42941 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42942 }
42943 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42944 } else {
42945 if (IS_CONST == IS_UNUSED) {
42946 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42947 }
42948 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42949 }
42950}
42951
42952static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42953{
42954 USE_OPLINE
42955 zval *container;
42956
42957 SAVE_OPLINE();
42958 container = EX_VAR(opline->op1.var);
42959 zend_fetch_dimension_address_UNSET(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42960
42961 if (IS_CV == IS_VAR) {
42962 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42963 }
42964 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42965}
42966
42967static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42968{
42969 USE_OPLINE
42970 zval *container;
42971 void **cache_slot = NULL;
42972
42973 SAVE_OPLINE();
42974 container = EX_VAR(opline->op1.var);
42975
42976 if (IS_CV == IS_CONST ||
42977 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
42978 do {
42979 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
42980 container = Z_REFVAL_P(container);
42981 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
42982 break;
42983 }
42984 }
42985 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
42986 ZVAL_UNDEFINED_OP1();
42987 }
42988 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
42989 ZVAL_NULL(EX_VAR(opline->result.var));
42990 goto fetch_obj_r_finish;
42991 } while (0);
42992 }
42993
42994 /* here we are sure we are dealing with an object */
42995 do {
42996 zend_object *zobj = Z_OBJ_P(container);
42997 zend_string *name, *tmp_name;
42998 zval *retval;
42999
43000 if (IS_CONST == IS_CONST) {
43001 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
43002
43003 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
43004 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43005
43006 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43007fetch_obj_r_simple:
43008 retval = OBJ_PROP(zobj, prop_offset);
43009 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
43010 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43011 goto fetch_obj_r_copy;
43012 } else {
43013fetch_obj_r_fast_copy:
43014 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43015 ZEND_VM_NEXT_OPCODE();
43016 }
43017 }
43018 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
43019 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
43020 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
43021 prop_offset = prop_info->offset;
43022 goto fetch_obj_r_simple;
43023 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
43024 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
43025 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
43026 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
43027
43028 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
43029 if (IS_CV & IS_CV) {
43030 GC_ADDREF(zobj);
43031 }
43032 if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
43033 call_info |= ZEND_CALL_RELEASE_THIS;
43034 }
43035 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
43036 call->prev_execute_data = execute_data;
43037 call->call = NULL;
43038 call->return_value = EX_VAR(opline->result.var);
43039 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
43040
43041 execute_data = call;
43042 EG(current_execute_data) = execute_data;
43043 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
43044
43045#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
43046 opline = hook->op_array.opcodes;
43047#else
43048 EX(opline) = hook->op_array.opcodes;
43049#endif
43050 LOAD_OPLINE_EX();
43051
43052
43053 ZEND_VM_ENTER_EX();
43054 }
43055 /* Fall through to read_property for hooks. */
43056 } else if (EXPECTED(zobj->properties != NULL)) {
43057 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
43058 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43059 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
43060 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
43061
43062 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
43063 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
43064
43065 if (EXPECTED(p->key == name) ||
43066 (EXPECTED(p->h == ZSTR_H(name)) &&
43067 EXPECTED(p->key != NULL) &&
43068 EXPECTED(zend_string_equal_content(p->key, name)))) {
43069 retval = &p->val;
43070 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43071 goto fetch_obj_r_copy;
43072 } else {
43073 goto fetch_obj_r_fast_copy;
43074 }
43075 }
43076 }
43077 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
43078 }
43079 retval = zend_hash_find_known_hash(zobj->properties, name);
43080 if (EXPECTED(retval)) {
43081 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
43082 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
43083 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43084 goto fetch_obj_r_copy;
43085 } else {
43086 goto fetch_obj_r_fast_copy;
43087 }
43088 }
43089 }
43090 }
43091 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43092 } else {
43093 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43094 if (UNEXPECTED(!name)) {
43095 ZVAL_UNDEF(EX_VAR(opline->result.var));
43096 break;
43097 }
43098 }
43099
43100#if ZEND_DEBUG
43101 /* For non-standard object handlers, verify a declared property type in debug builds.
43102 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
43103 zend_property_info *prop_info = NULL;
43104 if (zobj->handlers->read_property != zend_std_read_property) {
43105 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
43106 }
43107#endif
43108 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
43109#if ZEND_DEBUG
43110 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
43111 && ZEND_TYPE_IS_SET(prop_info->type)) {
43112 ZVAL_OPT_DEREF(retval);
43113 zend_verify_property_type(prop_info, retval, /* strict */ true);
43114 }
43115#endif
43116
43117 if (IS_CONST != IS_CONST) {
43118 zend_tmp_string_release(tmp_name);
43119 }
43120
43121 if (retval != EX_VAR(opline->result.var)) {
43122fetch_obj_r_copy:
43123 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43124 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
43125 zend_unwrap_reference(retval);
43126 }
43127 } while (0);
43128
43129fetch_obj_r_finish:
43130
43131
43132 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43133}
43134
43135static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43136{
43137 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43138}
43139
43140static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43141{
43142 USE_OPLINE
43143 zval *property, *container, *result;
43144
43145 SAVE_OPLINE();
43146
43147 container = EX_VAR(opline->op1.var);
43148 property = RT_CONSTANT(opline, opline->op2);
43149 result = EX_VAR(opline->result.var);
43150 zend_fetch_property_address(
43151 result, container, IS_CV, property, IS_CONST,
43152 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
43153 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
43154
43155 if (IS_CV == IS_VAR) {
43156 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43157 }
43158 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43159}
43160
43161static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43162{
43163 USE_OPLINE
43164 zval *property, *container, *result;
43165
43166 SAVE_OPLINE();
43167 container = EX_VAR(opline->op1.var);
43168 property = RT_CONSTANT(opline, opline->op2);
43169 result = EX_VAR(opline->result.var);
43170 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);
43171
43172 if (IS_CV == IS_VAR) {
43173 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43174 }
43175 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43176}
43177
43178static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43179{
43180 USE_OPLINE
43181 zval *container;
43182 void **cache_slot = NULL;
43183
43184 SAVE_OPLINE();
43185 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
43186
43187 if (IS_CV == IS_CONST ||
43188 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
43189 do {
43190 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
43191 container = Z_REFVAL_P(container);
43192 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
43193 break;
43194 }
43195 }
43196 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
43197 ZVAL_UNDEFINED_OP2();
43198 }
43199 ZVAL_NULL(EX_VAR(opline->result.var));
43200 goto fetch_obj_is_finish;
43201 } while (0);
43202 }
43203
43204 /* here we are sure we are dealing with an object */
43205 do {
43206 zend_object *zobj = Z_OBJ_P(container);
43207 zend_string *name, *tmp_name;
43208 zval *retval;
43209
43210 if (IS_CONST == IS_CONST) {
43211 cache_slot = CACHE_ADDR(opline->extended_value);
43212
43213 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
43214 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43215
43216 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43217fetch_obj_is_simple:
43218 retval = OBJ_PROP(zobj, prop_offset);
43219 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
43220 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43221 goto fetch_obj_is_copy;
43222 } else {
43223fetch_obj_is_fast_copy:
43224 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43225 ZEND_VM_NEXT_OPCODE();
43226 }
43227 }
43228 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
43229 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
43230 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
43231 prop_offset = prop_info->offset;
43232 goto fetch_obj_is_simple;
43233 }
43234 /* Fall through to read_property for hooks. */
43235 } else if (EXPECTED(zobj->properties != NULL)) {
43236 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
43237 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43238 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
43239 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
43240
43241 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
43242 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
43243
43244 if (EXPECTED(p->key == name) ||
43245 (EXPECTED(p->h == ZSTR_H(name)) &&
43246 EXPECTED(p->key != NULL) &&
43247 EXPECTED(zend_string_equal_content(p->key, name)))) {
43248 retval = &p->val;
43249 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43250 goto fetch_obj_is_copy;
43251 } else {
43252 goto fetch_obj_is_fast_copy;
43253 }
43254 }
43255 }
43256 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
43257 }
43258 retval = zend_hash_find_known_hash(zobj->properties, name);
43259 if (EXPECTED(retval)) {
43260 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
43261 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
43262 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43263 goto fetch_obj_is_copy;
43264 } else {
43265 goto fetch_obj_is_fast_copy;
43266 }
43267 }
43268 }
43269 }
43270 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43271 } else {
43272 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43273 if (UNEXPECTED(!name)) {
43274 ZVAL_UNDEF(EX_VAR(opline->result.var));
43275 break;
43276 }
43277 }
43278
43279 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
43280
43281 if (IS_CONST != IS_CONST) {
43282 zend_tmp_string_release(tmp_name);
43283 }
43284
43285 if (retval != EX_VAR(opline->result.var)) {
43286fetch_obj_is_copy:
43287 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43288 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
43289 zend_unwrap_reference(retval);
43290 }
43291 } while (0);
43292
43293fetch_obj_is_finish:
43294
43295
43296 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43297}
43298
43299static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43300{
43301#if 0
43302 USE_OPLINE
43303#endif
43304
43305 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
43306 /* Behave like FETCH_OBJ_W */
43307 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
43308 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43309 }
43310 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43311 } else {
43312 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43313 }
43314}
43315
43316static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43317{
43318 USE_OPLINE
43319 zval *container, *property, *result;
43320
43321 SAVE_OPLINE();
43322 container = EX_VAR(opline->op1.var);
43323 property = RT_CONSTANT(opline, opline->op2);
43324 result = EX_VAR(opline->result.var);
43325 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);
43326
43327 if (IS_CV == IS_VAR) {
43328 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43329 }
43330 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43331}
43332
43333static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43334{
43335 USE_OPLINE
43336 zval *object, *value, tmp;
43337 zend_object *zobj;
43338 zend_string *name, *tmp_name;
43339 zend_refcounted *garbage = NULL;
43340
43341 SAVE_OPLINE();
43342 object = EX_VAR(opline->op1.var);
43343 value = RT_CONSTANT((opline+1), (opline+1)->op1);
43344
43345 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43346 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43347 object = Z_REFVAL_P(object);
43348 goto assign_object;
43349 }
43350 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43351 value = &EG(uninitialized_zval);
43352 goto free_and_exit_assign_obj;
43353 }
43354
43355assign_object:
43356 zobj = Z_OBJ_P(object);
43357 if (IS_CONST == IS_CONST) {
43358 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43359 void **cache_slot = CACHE_ADDR(opline->extended_value);
43360 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43361 zval *property_val;
43362 zend_property_info *prop_info;
43363
43364 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43365 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43366
43367assign_obj_simple:
43368 property_val = OBJ_PROP(zobj, prop_offset);
43369 if (Z_TYPE_P(property_val) != IS_UNDEF) {
43370 if (prop_info != NULL) {
43371 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43372 goto free_and_exit_assign_obj;
43373 } else {
43374fast_assign_obj:
43375 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
43376 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43377 ZVAL_COPY(EX_VAR(opline->result.var), value);
43378 }
43379 goto exit_assign_obj;
43380 }
43381 }
43382 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43383 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43384 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43385 zobj = zend_lazy_object_init(zobj);
43386 if (!zobj) {
43387 value = &EG(uninitialized_zval);
43388 goto free_and_exit_assign_obj;
43389 }
43390 }
43391 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43392 rebuild_object_properties_internal(zobj);
43393 }
43394 if (EXPECTED(zobj->properties != NULL)) {
43395 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43396 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43397 GC_DELREF(zobj->properties);
43398 }
43399 zobj->properties = zend_array_dup(zobj->properties);
43400 }
43401 property_val = zend_hash_find_known_hash(zobj->properties, name);
43402 if (property_val) {
43403 goto fast_assign_obj;
43404 }
43405 }
43406
43407 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43408 if (IS_CONST == IS_CONST) {
43409 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43410 Z_ADDREF_P(value);
43411 }
43412 } else if (IS_CONST != IS_TMP_VAR) {
43413 if (Z_ISREF_P(value)) {
43414 if (IS_CONST == IS_VAR) {
43415 zend_reference *ref = Z_REF_P(value);
43416 if (GC_DELREF(ref) == 0) {
43417 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43418 efree_size(ref, sizeof(zend_reference));
43419 value = &tmp;
43420 } else {
43421 value = Z_REFVAL_P(value);
43422 Z_TRY_ADDREF_P(value);
43423 }
43424 } else {
43425 value = Z_REFVAL_P(value);
43426 Z_TRY_ADDREF_P(value);
43427 }
43428 } else if (IS_CONST == IS_CV) {
43429 Z_TRY_ADDREF_P(value);
43430 }
43431 }
43432 zend_hash_add_new(zobj->properties, name, value);
43433 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43434 ZVAL_COPY(EX_VAR(opline->result.var), value);
43435 }
43436 goto exit_assign_obj;
43437 }
43438 } else {
43439 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43440 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43441 prop_info = CACHED_PTR_EX(cache_slot + 2);
43442 prop_offset = prop_info->offset;
43443 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43444 prop_info = NULL;
43445 }
43446 goto assign_obj_simple;
43447 }
43448 /* Fall through to write_property for hooks. */
43449 }
43450 }
43451 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43452 } else {
43453 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43454 if (UNEXPECTED(!name)) {
43455
43456 UNDEF_RESULT();
43457 goto exit_assign_obj;
43458 }
43459 }
43460
43461 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
43462 ZVAL_DEREF(value);
43463 }
43464
43465 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43466
43467 if (IS_CONST != IS_CONST) {
43468 zend_tmp_string_release(tmp_name);
43469 }
43470
43471free_and_exit_assign_obj:
43472 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43473 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43474 }
43475
43476exit_assign_obj:
43477 if (garbage) {
43478 GC_DTOR_NO_REF(garbage);
43479 }
43480
43481
43482 /* assign_obj has two opcodes! */
43483 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43484}
43485
43486/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
43487static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43488{
43489 USE_OPLINE
43490 zval *object, *value, tmp;
43491 zend_object *zobj;
43492 zend_string *name, *tmp_name;
43493 zend_refcounted *garbage = NULL;
43494
43495 SAVE_OPLINE();
43496 object = EX_VAR(opline->op1.var);
43497 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
43498
43499 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43500 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43501 object = Z_REFVAL_P(object);
43502 goto assign_object;
43503 }
43504 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43505 value = &EG(uninitialized_zval);
43506 goto free_and_exit_assign_obj;
43507 }
43508
43509assign_object:
43510 zobj = Z_OBJ_P(object);
43511 if (IS_CONST == IS_CONST) {
43512 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43513 void **cache_slot = CACHE_ADDR(opline->extended_value);
43514 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43515 zval *property_val;
43516 zend_property_info *prop_info;
43517
43518 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43519 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43520
43521assign_obj_simple:
43522 property_val = OBJ_PROP(zobj, prop_offset);
43523 if (Z_TYPE_P(property_val) != IS_UNDEF) {
43524 if (prop_info != NULL) {
43525 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43526 goto free_and_exit_assign_obj;
43527 } else {
43528fast_assign_obj:
43529 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
43530 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43531 ZVAL_COPY(EX_VAR(opline->result.var), value);
43532 }
43533 goto exit_assign_obj;
43534 }
43535 }
43536 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43537 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43538 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43539 zobj = zend_lazy_object_init(zobj);
43540 if (!zobj) {
43541 value = &EG(uninitialized_zval);
43542 goto free_and_exit_assign_obj;
43543 }
43544 }
43545 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43546 rebuild_object_properties_internal(zobj);
43547 }
43548 if (EXPECTED(zobj->properties != NULL)) {
43549 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43550 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43551 GC_DELREF(zobj->properties);
43552 }
43553 zobj->properties = zend_array_dup(zobj->properties);
43554 }
43555 property_val = zend_hash_find_known_hash(zobj->properties, name);
43556 if (property_val) {
43557 goto fast_assign_obj;
43558 }
43559 }
43560
43561 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43562 if (IS_TMP_VAR == IS_CONST) {
43563 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43564 Z_ADDREF_P(value);
43565 }
43566 } else if (IS_TMP_VAR != IS_TMP_VAR) {
43567 if (Z_ISREF_P(value)) {
43568 if (IS_TMP_VAR == IS_VAR) {
43569 zend_reference *ref = Z_REF_P(value);
43570 if (GC_DELREF(ref) == 0) {
43571 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43572 efree_size(ref, sizeof(zend_reference));
43573 value = &tmp;
43574 } else {
43575 value = Z_REFVAL_P(value);
43576 Z_TRY_ADDREF_P(value);
43577 }
43578 } else {
43579 value = Z_REFVAL_P(value);
43580 Z_TRY_ADDREF_P(value);
43581 }
43582 } else if (IS_TMP_VAR == IS_CV) {
43583 Z_TRY_ADDREF_P(value);
43584 }
43585 }
43586 zend_hash_add_new(zobj->properties, name, value);
43587 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43588 ZVAL_COPY(EX_VAR(opline->result.var), value);
43589 }
43590 goto exit_assign_obj;
43591 }
43592 } else {
43593 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43594 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43595 prop_info = CACHED_PTR_EX(cache_slot + 2);
43596 prop_offset = prop_info->offset;
43597 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43598 prop_info = NULL;
43599 }
43600 goto assign_obj_simple;
43601 }
43602 /* Fall through to write_property for hooks. */
43603 }
43604 }
43605 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43606 } else {
43607 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43608 if (UNEXPECTED(!name)) {
43609 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43610 UNDEF_RESULT();
43611 goto exit_assign_obj;
43612 }
43613 }
43614
43615 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
43616 ZVAL_DEREF(value);
43617 }
43618
43619 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43620
43621 if (IS_CONST != IS_CONST) {
43622 zend_tmp_string_release(tmp_name);
43623 }
43624
43625free_and_exit_assign_obj:
43626 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43627 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43628 }
43629 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43630exit_assign_obj:
43631 if (garbage) {
43632 GC_DTOR_NO_REF(garbage);
43633 }
43634
43635
43636 /* assign_obj has two opcodes! */
43637 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43638}
43639
43640/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
43641static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43642{
43643 USE_OPLINE
43644 zval *object, *value, tmp;
43645 zend_object *zobj;
43646 zend_string *name, *tmp_name;
43647 zend_refcounted *garbage = NULL;
43648
43649 SAVE_OPLINE();
43650 object = EX_VAR(opline->op1.var);
43651 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43652
43653 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43654 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43655 object = Z_REFVAL_P(object);
43656 goto assign_object;
43657 }
43658 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43659 value = &EG(uninitialized_zval);
43660 goto free_and_exit_assign_obj;
43661 }
43662
43663assign_object:
43664 zobj = Z_OBJ_P(object);
43665 if (IS_CONST == IS_CONST) {
43666 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43667 void **cache_slot = CACHE_ADDR(opline->extended_value);
43668 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43669 zval *property_val;
43670 zend_property_info *prop_info;
43671
43672 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43673 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43674
43675assign_obj_simple:
43676 property_val = OBJ_PROP(zobj, prop_offset);
43677 if (Z_TYPE_P(property_val) != IS_UNDEF) {
43678 if (prop_info != NULL) {
43679 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43680 goto free_and_exit_assign_obj;
43681 } else {
43682fast_assign_obj:
43683 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
43684 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43685 ZVAL_COPY(EX_VAR(opline->result.var), value);
43686 }
43687 goto exit_assign_obj;
43688 }
43689 }
43690 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43691 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43692 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43693 zobj = zend_lazy_object_init(zobj);
43694 if (!zobj) {
43695 value = &EG(uninitialized_zval);
43696 goto free_and_exit_assign_obj;
43697 }
43698 }
43699 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43700 rebuild_object_properties_internal(zobj);
43701 }
43702 if (EXPECTED(zobj->properties != NULL)) {
43703 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43704 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43705 GC_DELREF(zobj->properties);
43706 }
43707 zobj->properties = zend_array_dup(zobj->properties);
43708 }
43709 property_val = zend_hash_find_known_hash(zobj->properties, name);
43710 if (property_val) {
43711 goto fast_assign_obj;
43712 }
43713 }
43714
43715 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43716 if (IS_VAR == IS_CONST) {
43717 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43718 Z_ADDREF_P(value);
43719 }
43720 } else if (IS_VAR != IS_TMP_VAR) {
43721 if (Z_ISREF_P(value)) {
43722 if (IS_VAR == IS_VAR) {
43723 zend_reference *ref = Z_REF_P(value);
43724 if (GC_DELREF(ref) == 0) {
43725 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43726 efree_size(ref, sizeof(zend_reference));
43727 value = &tmp;
43728 } else {
43729 value = Z_REFVAL_P(value);
43730 Z_TRY_ADDREF_P(value);
43731 }
43732 } else {
43733 value = Z_REFVAL_P(value);
43734 Z_TRY_ADDREF_P(value);
43735 }
43736 } else if (IS_VAR == IS_CV) {
43737 Z_TRY_ADDREF_P(value);
43738 }
43739 }
43740 zend_hash_add_new(zobj->properties, name, value);
43741 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43742 ZVAL_COPY(EX_VAR(opline->result.var), value);
43743 }
43744 goto exit_assign_obj;
43745 }
43746 } else {
43747 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43748 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43749 prop_info = CACHED_PTR_EX(cache_slot + 2);
43750 prop_offset = prop_info->offset;
43751 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43752 prop_info = NULL;
43753 }
43754 goto assign_obj_simple;
43755 }
43756 /* Fall through to write_property for hooks. */
43757 }
43758 }
43759 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43760 } else {
43761 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43762 if (UNEXPECTED(!name)) {
43763 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43764 UNDEF_RESULT();
43765 goto exit_assign_obj;
43766 }
43767 }
43768
43769 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
43770 ZVAL_DEREF(value);
43771 }
43772
43773 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43774
43775 if (IS_CONST != IS_CONST) {
43776 zend_tmp_string_release(tmp_name);
43777 }
43778
43779free_and_exit_assign_obj:
43780 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43781 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43782 }
43783 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43784exit_assign_obj:
43785 if (garbage) {
43786 GC_DTOR_NO_REF(garbage);
43787 }
43788
43789
43790 /* assign_obj has two opcodes! */
43791 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43792}
43793
43794/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
43795static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43796{
43797 USE_OPLINE
43798 zval *object, *value, tmp;
43799 zend_object *zobj;
43800 zend_string *name, *tmp_name;
43801 zend_refcounted *garbage = NULL;
43802
43803 SAVE_OPLINE();
43804 object = EX_VAR(opline->op1.var);
43805 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
43806
43807 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43808 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43809 object = Z_REFVAL_P(object);
43810 goto assign_object;
43811 }
43812 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43813 value = &EG(uninitialized_zval);
43814 goto free_and_exit_assign_obj;
43815 }
43816
43817assign_object:
43818 zobj = Z_OBJ_P(object);
43819 if (IS_CONST == IS_CONST) {
43820 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43821 void **cache_slot = CACHE_ADDR(opline->extended_value);
43822 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43823 zval *property_val;
43824 zend_property_info *prop_info;
43825
43826 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43827 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43828
43829assign_obj_simple:
43830 property_val = OBJ_PROP(zobj, prop_offset);
43831 if (Z_TYPE_P(property_val) != IS_UNDEF) {
43832 if (prop_info != NULL) {
43833 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43834 goto free_and_exit_assign_obj;
43835 } else {
43836fast_assign_obj:
43837 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
43838 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43839 ZVAL_COPY(EX_VAR(opline->result.var), value);
43840 }
43841 goto exit_assign_obj;
43842 }
43843 }
43844 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43845 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43846 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43847 zobj = zend_lazy_object_init(zobj);
43848 if (!zobj) {
43849 value = &EG(uninitialized_zval);
43850 goto free_and_exit_assign_obj;
43851 }
43852 }
43853 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43854 rebuild_object_properties_internal(zobj);
43855 }
43856 if (EXPECTED(zobj->properties != NULL)) {
43857 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43858 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43859 GC_DELREF(zobj->properties);
43860 }
43861 zobj->properties = zend_array_dup(zobj->properties);
43862 }
43863 property_val = zend_hash_find_known_hash(zobj->properties, name);
43864 if (property_val) {
43865 goto fast_assign_obj;
43866 }
43867 }
43868
43869 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43870 if (IS_CV == IS_CONST) {
43871 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43872 Z_ADDREF_P(value);
43873 }
43874 } else if (IS_CV != IS_TMP_VAR) {
43875 if (Z_ISREF_P(value)) {
43876 if (IS_CV == IS_VAR) {
43877 zend_reference *ref = Z_REF_P(value);
43878 if (GC_DELREF(ref) == 0) {
43879 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43880 efree_size(ref, sizeof(zend_reference));
43881 value = &tmp;
43882 } else {
43883 value = Z_REFVAL_P(value);
43884 Z_TRY_ADDREF_P(value);
43885 }
43886 } else {
43887 value = Z_REFVAL_P(value);
43888 Z_TRY_ADDREF_P(value);
43889 }
43890 } else if (IS_CV == IS_CV) {
43891 Z_TRY_ADDREF_P(value);
43892 }
43893 }
43894 zend_hash_add_new(zobj->properties, name, value);
43895 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43896 ZVAL_COPY(EX_VAR(opline->result.var), value);
43897 }
43898 goto exit_assign_obj;
43899 }
43900 } else {
43901 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43902 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43903 prop_info = CACHED_PTR_EX(cache_slot + 2);
43904 prop_offset = prop_info->offset;
43905 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
43906 prop_info = NULL;
43907 }
43908 goto assign_obj_simple;
43909 }
43910 /* Fall through to write_property for hooks. */
43911 }
43912 }
43913 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43914 } else {
43915 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43916 if (UNEXPECTED(!name)) {
43917
43918 UNDEF_RESULT();
43919 goto exit_assign_obj;
43920 }
43921 }
43922
43923 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
43924 ZVAL_DEREF(value);
43925 }
43926
43927 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43928
43929 if (IS_CONST != IS_CONST) {
43930 zend_tmp_string_release(tmp_name);
43931 }
43932
43933free_and_exit_assign_obj:
43934 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43935 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43936 }
43937
43938exit_assign_obj:
43939 if (garbage) {
43940 GC_DTOR_NO_REF(garbage);
43941 }
43942
43943
43944 /* assign_obj has two opcodes! */
43945 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43946}
43947
43948/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
43949static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43950{
43951 USE_OPLINE
43952 zval *object_ptr, *orig_object_ptr;
43953 zval *value;
43954 zval *variable_ptr;
43955 zval *dim;
43956 zend_refcounted *garbage = NULL;
43957
43958 SAVE_OPLINE();
43959 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
43960
43961 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
43962try_assign_dim_array:
43963 SEPARATE_ARRAY(object_ptr);
43964 if (IS_CONST == IS_UNUSED) {
43965 value = RT_CONSTANT((opline+1), (opline+1)->op1);
43966 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
43967 HashTable *ht = Z_ARRVAL_P(object_ptr);
43968 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
43969 GC_ADDREF(ht);
43970 }
43971 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
43972 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
43973 zend_array_destroy(ht);
43974 goto assign_dim_error;
43975 }
43976 }
43977 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
43978 ZVAL_DEREF(value);
43979 }
43980 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
43981 if (UNEXPECTED(value == NULL)) {
43982 zend_cannot_add_element();
43983 goto assign_dim_error;
43984 } else if (IS_CONST == IS_CV) {
43985 if (Z_REFCOUNTED_P(value)) {
43986 Z_ADDREF_P(value);
43987 }
43988 } else if (IS_CONST == IS_VAR) {
43989 zval *free_op_data = EX_VAR((opline+1)->op1.var);
43990 if (Z_ISREF_P(free_op_data)) {
43991 if (Z_REFCOUNTED_P(value)) {
43992 Z_ADDREF_P(value);
43993 }
43994 zval_ptr_dtor_nogc(free_op_data);
43995 }
43996 } else if (IS_CONST == IS_CONST) {
43997 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
43998 Z_ADDREF_P(value);
43999 }
44000 }
44001 } else {
44002 dim = RT_CONSTANT(opline, opline->op2);
44003 if (IS_CONST == IS_CONST) {
44004 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44005 } else {
44006 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44007 }
44008 if (UNEXPECTED(variable_ptr == NULL)) {
44009 goto assign_dim_error;
44010 }
44011 value = RT_CONSTANT((opline+1), (opline+1)->op1);
44012 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
44013 }
44014 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44015 ZVAL_COPY(EX_VAR(opline->result.var), value);
44016 }
44017 if (garbage) {
44018 GC_DTOR_NO_REF(garbage);
44019 }
44020 } else {
44021 if (EXPECTED(Z_ISREF_P(object_ptr))) {
44022 object_ptr = Z_REFVAL_P(object_ptr);
44023 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44024 goto try_assign_dim_array;
44025 }
44026 }
44027 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44028 zend_object *obj = Z_OBJ_P(object_ptr);
44029
44030 GC_ADDREF(obj);
44031 dim = RT_CONSTANT(opline, opline->op2);
44032 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44033 dim = ZVAL_UNDEFINED_OP2();
44034 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44035 dim++;
44036 }
44037
44038 value = RT_CONSTANT((opline+1), (opline+1)->op1);
44039 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44040 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44041 } else if (IS_CONST & (IS_CV|IS_VAR)) {
44042 ZVAL_DEREF(value);
44043 }
44044
44045 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44046
44047 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44048 zend_objects_store_del(obj);
44049 }
44050 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44051 if (IS_CONST == IS_UNUSED) {
44052 zend_use_new_element_for_string();
44053
44054 UNDEF_RESULT();
44055 } else {
44056 dim = RT_CONSTANT(opline, opline->op2);
44057 value = RT_CONSTANT((opline+1), (opline+1)->op1);
44058 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44059
44060 }
44061 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44062 if (Z_ISREF_P(orig_object_ptr)
44063 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44064 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44065 dim = RT_CONSTANT(opline, opline->op2);
44066
44067 UNDEF_RESULT();
44068 } else {
44069 HashTable *ht = zend_new_array(8);
44070 uint8_t old_type = Z_TYPE_P(object_ptr);
44071
44072 ZVAL_ARR(object_ptr, ht);
44073 if (UNEXPECTED(old_type == IS_FALSE)) {
44074 GC_ADDREF(ht);
44075 zend_false_to_array_deprecated();
44076 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44077 zend_array_destroy(ht);
44078 goto assign_dim_error;
44079 }
44080 }
44081 goto try_assign_dim_array;
44082 }
44083 } else {
44084 zend_use_scalar_as_array();
44085 dim = RT_CONSTANT(opline, opline->op2);
44086assign_dim_error:
44087
44088 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44089 ZVAL_NULL(EX_VAR(opline->result.var));
44090 }
44091 }
44092 }
44093 if (IS_CONST != IS_UNUSED) {
44094
44095 }
44096
44097 /* assign_dim has two opcodes! */
44098 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44099}
44100
44101static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44102{
44103 USE_OPLINE
44104 zval *object_ptr, *orig_object_ptr;
44105 zval *value;
44106 zval *variable_ptr;
44107 zval *dim;
44108 zend_refcounted *garbage = NULL;
44109
44110 SAVE_OPLINE();
44111 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44112
44113 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44114try_assign_dim_array:
44115 SEPARATE_ARRAY(object_ptr);
44116 if (IS_CONST == IS_UNUSED) {
44117 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44118 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44119 HashTable *ht = Z_ARRVAL_P(object_ptr);
44120 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44121 GC_ADDREF(ht);
44122 }
44123 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44124 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44125 zend_array_destroy(ht);
44126 goto assign_dim_error;
44127 }
44128 }
44129 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
44130 ZVAL_DEREF(value);
44131 }
44132 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44133 if (UNEXPECTED(value == NULL)) {
44134 zend_cannot_add_element();
44135 goto assign_dim_error;
44136 } else if (IS_TMP_VAR == IS_CV) {
44137 if (Z_REFCOUNTED_P(value)) {
44138 Z_ADDREF_P(value);
44139 }
44140 } else if (IS_TMP_VAR == IS_VAR) {
44141 zval *free_op_data = EX_VAR((opline+1)->op1.var);
44142 if (Z_ISREF_P(free_op_data)) {
44143 if (Z_REFCOUNTED_P(value)) {
44144 Z_ADDREF_P(value);
44145 }
44146 zval_ptr_dtor_nogc(free_op_data);
44147 }
44148 } else if (IS_TMP_VAR == IS_CONST) {
44149 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44150 Z_ADDREF_P(value);
44151 }
44152 }
44153 } else {
44154 dim = RT_CONSTANT(opline, opline->op2);
44155 if (IS_CONST == IS_CONST) {
44156 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44157 } else {
44158 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44159 }
44160 if (UNEXPECTED(variable_ptr == NULL)) {
44161 goto assign_dim_error;
44162 }
44163 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44164 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
44165 }
44166 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44167 ZVAL_COPY(EX_VAR(opline->result.var), value);
44168 }
44169 if (garbage) {
44170 GC_DTOR_NO_REF(garbage);
44171 }
44172 } else {
44173 if (EXPECTED(Z_ISREF_P(object_ptr))) {
44174 object_ptr = Z_REFVAL_P(object_ptr);
44175 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44176 goto try_assign_dim_array;
44177 }
44178 }
44179 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44180 zend_object *obj = Z_OBJ_P(object_ptr);
44181
44182 GC_ADDREF(obj);
44183 dim = RT_CONSTANT(opline, opline->op2);
44184 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44185 dim = ZVAL_UNDEFINED_OP2();
44186 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44187 dim++;
44188 }
44189
44190 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44191 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44192 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44193 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
44194 ZVAL_DEREF(value);
44195 }
44196
44197 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44198
44199 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44200 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44201 zend_objects_store_del(obj);
44202 }
44203 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44204 if (IS_CONST == IS_UNUSED) {
44205 zend_use_new_element_for_string();
44206 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44207 UNDEF_RESULT();
44208 } else {
44209 dim = RT_CONSTANT(opline, opline->op2);
44210 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44211 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44212 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44213 }
44214 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44215 if (Z_ISREF_P(orig_object_ptr)
44216 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44217 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44218 dim = RT_CONSTANT(opline, opline->op2);
44219 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44220 UNDEF_RESULT();
44221 } else {
44222 HashTable *ht = zend_new_array(8);
44223 uint8_t old_type = Z_TYPE_P(object_ptr);
44224
44225 ZVAL_ARR(object_ptr, ht);
44226 if (UNEXPECTED(old_type == IS_FALSE)) {
44227 GC_ADDREF(ht);
44228 zend_false_to_array_deprecated();
44229 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44230 zend_array_destroy(ht);
44231 goto assign_dim_error;
44232 }
44233 }
44234 goto try_assign_dim_array;
44235 }
44236 } else {
44237 zend_use_scalar_as_array();
44238 dim = RT_CONSTANT(opline, opline->op2);
44239assign_dim_error:
44240 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44241 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44242 ZVAL_NULL(EX_VAR(opline->result.var));
44243 }
44244 }
44245 }
44246 if (IS_CONST != IS_UNUSED) {
44247
44248 }
44249
44250 /* assign_dim has two opcodes! */
44251 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44252}
44253
44254static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44255{
44256 USE_OPLINE
44257 zval *object_ptr, *orig_object_ptr;
44258 zval *value;
44259 zval *variable_ptr;
44260 zval *dim;
44261 zend_refcounted *garbage = NULL;
44262
44263 SAVE_OPLINE();
44264 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44265
44266 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44267try_assign_dim_array:
44268 SEPARATE_ARRAY(object_ptr);
44269 if (IS_CONST == IS_UNUSED) {
44270 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44271 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44272 HashTable *ht = Z_ARRVAL_P(object_ptr);
44273 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44274 GC_ADDREF(ht);
44275 }
44276 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44277 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44278 zend_array_destroy(ht);
44279 goto assign_dim_error;
44280 }
44281 }
44282 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
44283 ZVAL_DEREF(value);
44284 }
44285 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44286 if (UNEXPECTED(value == NULL)) {
44287 zend_cannot_add_element();
44288 goto assign_dim_error;
44289 } else if (IS_VAR == IS_CV) {
44290 if (Z_REFCOUNTED_P(value)) {
44291 Z_ADDREF_P(value);
44292 }
44293 } else if (IS_VAR == IS_VAR) {
44294 zval *free_op_data = EX_VAR((opline+1)->op1.var);
44295 if (Z_ISREF_P(free_op_data)) {
44296 if (Z_REFCOUNTED_P(value)) {
44297 Z_ADDREF_P(value);
44298 }
44299 zval_ptr_dtor_nogc(free_op_data);
44300 }
44301 } else if (IS_VAR == IS_CONST) {
44302 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44303 Z_ADDREF_P(value);
44304 }
44305 }
44306 } else {
44307 dim = RT_CONSTANT(opline, opline->op2);
44308 if (IS_CONST == IS_CONST) {
44309 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44310 } else {
44311 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44312 }
44313 if (UNEXPECTED(variable_ptr == NULL)) {
44314 goto assign_dim_error;
44315 }
44316 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44317 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
44318 }
44319 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44320 ZVAL_COPY(EX_VAR(opline->result.var), value);
44321 }
44322 if (garbage) {
44323 GC_DTOR_NO_REF(garbage);
44324 }
44325 } else {
44326 if (EXPECTED(Z_ISREF_P(object_ptr))) {
44327 object_ptr = Z_REFVAL_P(object_ptr);
44328 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44329 goto try_assign_dim_array;
44330 }
44331 }
44332 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44333 zend_object *obj = Z_OBJ_P(object_ptr);
44334
44335 GC_ADDREF(obj);
44336 dim = RT_CONSTANT(opline, opline->op2);
44337 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44338 dim = ZVAL_UNDEFINED_OP2();
44339 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44340 dim++;
44341 }
44342
44343 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44344 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44345 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44346 } else if (IS_VAR & (IS_CV|IS_VAR)) {
44347 ZVAL_DEREF(value);
44348 }
44349
44350 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44351
44352 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44353 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44354 zend_objects_store_del(obj);
44355 }
44356 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44357 if (IS_CONST == IS_UNUSED) {
44358 zend_use_new_element_for_string();
44359 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44360 UNDEF_RESULT();
44361 } else {
44362 dim = RT_CONSTANT(opline, opline->op2);
44363 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44364 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44365 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44366 }
44367 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44368 if (Z_ISREF_P(orig_object_ptr)
44369 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44370 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44371 dim = RT_CONSTANT(opline, opline->op2);
44372 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44373 UNDEF_RESULT();
44374 } else {
44375 HashTable *ht = zend_new_array(8);
44376 uint8_t old_type = Z_TYPE_P(object_ptr);
44377
44378 ZVAL_ARR(object_ptr, ht);
44379 if (UNEXPECTED(old_type == IS_FALSE)) {
44380 GC_ADDREF(ht);
44381 zend_false_to_array_deprecated();
44382 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44383 zend_array_destroy(ht);
44384 goto assign_dim_error;
44385 }
44386 }
44387 goto try_assign_dim_array;
44388 }
44389 } else {
44390 zend_use_scalar_as_array();
44391 dim = RT_CONSTANT(opline, opline->op2);
44392assign_dim_error:
44393 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44394 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44395 ZVAL_NULL(EX_VAR(opline->result.var));
44396 }
44397 }
44398 }
44399 if (IS_CONST != IS_UNUSED) {
44400
44401 }
44402
44403 /* assign_dim has two opcodes! */
44404 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44405}
44406
44407static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44408{
44409 USE_OPLINE
44410 zval *object_ptr, *orig_object_ptr;
44411 zval *value;
44412 zval *variable_ptr;
44413 zval *dim;
44414 zend_refcounted *garbage = NULL;
44415
44416 SAVE_OPLINE();
44417 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44418
44419 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44420try_assign_dim_array:
44421 SEPARATE_ARRAY(object_ptr);
44422 if (IS_CONST == IS_UNUSED) {
44423 value = EX_VAR((opline+1)->op1.var);
44424 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44425 HashTable *ht = Z_ARRVAL_P(object_ptr);
44426 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44427 GC_ADDREF(ht);
44428 }
44429 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44430 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44431 zend_array_destroy(ht);
44432 goto assign_dim_error;
44433 }
44434 }
44435 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
44436 ZVAL_DEREF(value);
44437 }
44438 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44439 if (UNEXPECTED(value == NULL)) {
44440 zend_cannot_add_element();
44441 goto assign_dim_error;
44442 } else if (IS_CV == IS_CV) {
44443 if (Z_REFCOUNTED_P(value)) {
44444 Z_ADDREF_P(value);
44445 }
44446 } else if (IS_CV == IS_VAR) {
44447 zval *free_op_data = EX_VAR((opline+1)->op1.var);
44448 if (Z_ISREF_P(free_op_data)) {
44449 if (Z_REFCOUNTED_P(value)) {
44450 Z_ADDREF_P(value);
44451 }
44452 zval_ptr_dtor_nogc(free_op_data);
44453 }
44454 } else if (IS_CV == IS_CONST) {
44455 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44456 Z_ADDREF_P(value);
44457 }
44458 }
44459 } else {
44460 dim = RT_CONSTANT(opline, opline->op2);
44461 if (IS_CONST == IS_CONST) {
44462 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44463 } else {
44464 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44465 }
44466 if (UNEXPECTED(variable_ptr == NULL)) {
44467 goto assign_dim_error;
44468 }
44469 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
44470 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
44471 }
44472 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44473 ZVAL_COPY(EX_VAR(opline->result.var), value);
44474 }
44475 if (garbage) {
44476 GC_DTOR_NO_REF(garbage);
44477 }
44478 } else {
44479 if (EXPECTED(Z_ISREF_P(object_ptr))) {
44480 object_ptr = Z_REFVAL_P(object_ptr);
44481 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44482 goto try_assign_dim_array;
44483 }
44484 }
44485 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44486 zend_object *obj = Z_OBJ_P(object_ptr);
44487
44488 GC_ADDREF(obj);
44489 dim = RT_CONSTANT(opline, opline->op2);
44490 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44491 dim = ZVAL_UNDEFINED_OP2();
44492 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44493 dim++;
44494 }
44495
44496 value = EX_VAR((opline+1)->op1.var);
44497 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44498 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44499 } else if (IS_CV & (IS_CV|IS_VAR)) {
44500 ZVAL_DEREF(value);
44501 }
44502
44503 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44504
44505 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44506 zend_objects_store_del(obj);
44507 }
44508 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44509 if (IS_CONST == IS_UNUSED) {
44510 zend_use_new_element_for_string();
44511
44512 UNDEF_RESULT();
44513 } else {
44514 dim = RT_CONSTANT(opline, opline->op2);
44515 value = EX_VAR((opline+1)->op1.var);
44516 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44517
44518 }
44519 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44520 if (Z_ISREF_P(orig_object_ptr)
44521 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44522 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44523 dim = RT_CONSTANT(opline, opline->op2);
44524
44525 UNDEF_RESULT();
44526 } else {
44527 HashTable *ht = zend_new_array(8);
44528 uint8_t old_type = Z_TYPE_P(object_ptr);
44529
44530 ZVAL_ARR(object_ptr, ht);
44531 if (UNEXPECTED(old_type == IS_FALSE)) {
44532 GC_ADDREF(ht);
44533 zend_false_to_array_deprecated();
44534 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44535 zend_array_destroy(ht);
44536 goto assign_dim_error;
44537 }
44538 }
44539 goto try_assign_dim_array;
44540 }
44541 } else {
44542 zend_use_scalar_as_array();
44543 dim = RT_CONSTANT(opline, opline->op2);
44544assign_dim_error:
44545
44546 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44547 ZVAL_NULL(EX_VAR(opline->result.var));
44548 }
44549 }
44550 }
44551 if (IS_CONST != IS_UNUSED) {
44552
44553 }
44554
44555 /* assign_dim has two opcodes! */
44556 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44557}
44558
44559static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44560{
44561 USE_OPLINE
44562 zval *value;
44563 zval *variable_ptr;
44564
44565 SAVE_OPLINE();
44566 value = RT_CONSTANT(opline, opline->op2);
44567 variable_ptr = EX_VAR(opline->op1.var);
44568
44569 if (0 || UNEXPECTED(0)) {
44570 zend_refcounted *garbage = NULL;
44571
44572 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
44573 if (UNEXPECTED(0)) {
44574 ZVAL_COPY(EX_VAR(opline->result.var), value);
44575 }
44576 if (garbage) {
44577 GC_DTOR_NO_REF(garbage);
44578 }
44579 } else {
44580 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
44581 }
44582
44583 /* zend_assign_to_variable() always takes care of op2, never free it! */
44584
44585 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44586}
44587
44588static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44589{
44590 USE_OPLINE
44591 zval *value;
44592 zval *variable_ptr;
44593
44594 SAVE_OPLINE();
44595 value = RT_CONSTANT(opline, opline->op2);
44596 variable_ptr = EX_VAR(opline->op1.var);
44597
44598 if (0 || UNEXPECTED(1)) {
44599 zend_refcounted *garbage = NULL;
44600
44601 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
44602 if (UNEXPECTED(1)) {
44603 ZVAL_COPY(EX_VAR(opline->result.var), value);
44604 }
44605 if (garbage) {
44606 GC_DTOR_NO_REF(garbage);
44607 }
44608 } else {
44609 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
44610 }
44611
44612 /* zend_assign_to_variable() always takes care of op2, never free it! */
44613
44614 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44615}
44616
44617static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44618{
44619 USE_OPLINE
44620 zval *property, *container, *value_ptr;
44621
44622 SAVE_OPLINE();
44623
44624 container = EX_VAR(opline->op1.var);
44625 property = RT_CONSTANT(opline, opline->op2);
44626
44627 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44628
44629 if (1) {
44630 if (IS_CV == IS_UNUSED) {
44631 if (IS_CONST == IS_CONST) {
44632 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44633 } else {
44634 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44635 }
44636 } else {
44637 if (IS_CONST == IS_CONST) {
44638 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44639 } else {
44640 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44641 }
44642 }
44643 } else {
44644 zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44645 }
44646
44647
44648 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44649 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44650}
44651
44652/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
44653static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44654{
44655 USE_OPLINE
44656 zval *property, *container, *value_ptr;
44657
44658 SAVE_OPLINE();
44659
44660 container = EX_VAR(opline->op1.var);
44661 property = RT_CONSTANT(opline, opline->op2);
44662
44663 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
44664
44665 if (1) {
44666 if (IS_CV == IS_UNUSED) {
44667 if (IS_CONST == IS_CONST) {
44668 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44669 } else {
44670 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44671 }
44672 } else {
44673 if (IS_CONST == IS_CONST) {
44674 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44675 } else {
44676 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44677 }
44678 }
44679 } else {
44680 zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44681 }
44682
44683
44684
44685 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44686}
44687
44688/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
44689static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44690{
44691 USE_OPLINE
44692 zval *op1, *op2;
44693 zend_string *op1_str, *op2_str, *str;
44694
44695
44696 op1 = EX_VAR(opline->op1.var);
44697 op2 = RT_CONSTANT(opline, opline->op2);
44698 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
44699 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
44700 zend_string *op1_str = Z_STR_P(op1);
44701 zend_string *op2_str = Z_STR_P(op2);
44702 zend_string *str;
44703 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
44704
44705 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
44706 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
44707 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
44708 } else {
44709 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
44710 }
44711 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44712 zend_string_release_ex(op1_str, 0);
44713 }
44714 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
44715 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
44716 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
44717 } else {
44718 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
44719 }
44720 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44721 zend_string_release_ex(op2_str, 0);
44722 }
44723 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
44724 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
44725 size_t len = ZSTR_LEN(op1_str);
44726
44727 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
44728 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44729 GC_ADD_FLAGS(str, flags);
44730 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44731 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44732 zend_string_release_ex(op2_str, 0);
44733 }
44734 } else {
44735 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
44736 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
44737 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44738 GC_ADD_FLAGS(str, flags);
44739 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44740 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44741 zend_string_release_ex(op1_str, 0);
44742 }
44743 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44744 zend_string_release_ex(op2_str, 0);
44745 }
44746 }
44747 ZEND_VM_NEXT_OPCODE();
44748 }
44749
44750 SAVE_OPLINE();
44751 if (IS_CV == IS_CONST) {
44752 op1_str = Z_STR_P(op1);
44753 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44754 op1_str = zend_string_copy(Z_STR_P(op1));
44755 } else {
44756 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
44757 ZVAL_UNDEFINED_OP1();
44758 }
44759 op1_str = zval_get_string_func(op1);
44760 }
44761 if (IS_CONST == IS_CONST) {
44762 op2_str = Z_STR_P(op2);
44763 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
44764 op2_str = zend_string_copy(Z_STR_P(op2));
44765 } else {
44766 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
44767 ZVAL_UNDEFINED_OP2();
44768 }
44769 op2_str = zval_get_string_func(op2);
44770 }
44771 do {
44772 if (IS_CV != IS_CONST) {
44773 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
44774 if (IS_CONST == IS_CONST) {
44775 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
44776 GC_ADDREF(op2_str);
44777 }
44778 }
44779 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
44780 zend_string_release_ex(op1_str, 0);
44781 break;
44782 }
44783 }
44784 if (IS_CONST != IS_CONST) {
44785 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
44786 if (IS_CV == IS_CONST) {
44787 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
44788 GC_ADDREF(op1_str);
44789 }
44790 }
44791 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
44792 zend_string_release_ex(op2_str, 0);
44793 break;
44794 }
44795 }
44796 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
44797 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
44798 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44799
44800 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
44801 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44802 if (IS_CV != IS_CONST) {
44803 zend_string_release_ex(op1_str, 0);
44804 }
44805 if (IS_CONST != IS_CONST) {
44806 zend_string_release_ex(op2_str, 0);
44807 }
44808 } while (0);
44809
44810
44811 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44812}
44813
44814static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44815{
44816 USE_OPLINE
44817 zval *function_name;
44818 zval *object;
44819 zend_function *fbc;
44820 zend_class_entry *called_scope;
44821 zend_object *obj;
44822 zend_execute_data *call;
44823 uint32_t call_info;
44824
44825 SAVE_OPLINE();
44826
44827 object = EX_VAR(opline->op1.var);
44828
44829 if (IS_CONST != IS_CONST) {
44830 function_name = RT_CONSTANT(opline, opline->op2);
44831 }
44832
44833 if (IS_CONST != IS_CONST &&
44834 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
44835 do {
44836 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
44837 function_name = Z_REFVAL_P(function_name);
44838 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
44839 break;
44840 }
44841 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
44842 ZVAL_UNDEFINED_OP2();
44843 if (UNEXPECTED(EG(exception) != NULL)) {
44844
44845 HANDLE_EXCEPTION();
44846 }
44847 }
44848 zend_throw_error(NULL, "Method name must be a string");
44849
44850
44851 HANDLE_EXCEPTION();
44852 } while (0);
44853 }
44854
44855 if (IS_CV == IS_UNUSED) {
44856 obj = Z_OBJ_P(object);
44857 } else {
44858 do {
44859 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
44860 obj = Z_OBJ_P(object);
44861 } else {
44862 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
44863 zend_reference *ref = Z_REF_P(object);
44864
44865 object = &ref->val;
44866 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
44867 obj = Z_OBJ_P(object);
44868 if (IS_CV & IS_VAR) {
44869 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
44870 efree_size(ref, sizeof(zend_reference));
44871 } else {
44872 Z_ADDREF_P(object);
44873 }
44874 }
44875 break;
44876 }
44877 }
44878 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
44879 object = ZVAL_UNDEFINED_OP1();
44880 if (UNEXPECTED(EG(exception) != NULL)) {
44881 if (IS_CONST != IS_CONST) {
44882
44883 }
44884 HANDLE_EXCEPTION();
44885 }
44886 }
44887 if (IS_CONST == IS_CONST) {
44888 function_name = RT_CONSTANT(opline, opline->op2);
44889 }
44890 zend_invalid_method_call(object, function_name);
44891
44892
44893 HANDLE_EXCEPTION();
44894 }
44895 } while (0);
44896 }
44897
44898 called_scope = obj->ce;
44899
44900 if (IS_CONST == IS_CONST &&
44901 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
44902 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
44903 } else {
44904 zend_object *orig_obj = obj;
44905
44906 if (IS_CONST == IS_CONST) {
44907 function_name = RT_CONSTANT(opline, opline->op2);
44908 }
44909
44910 /* First, locate the function. */
44911 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
44912 if (UNEXPECTED(fbc == NULL)) {
44913 if (EXPECTED(!EG(exception))) {
44914 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
44915 }
44916
44917 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
44918 zend_objects_store_del(orig_obj);
44919 }
44920 HANDLE_EXCEPTION();
44921 }
44922 if (IS_CONST == IS_CONST &&
44923 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
44924 EXPECTED(obj == orig_obj)) {
44925 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
44926 }
44927 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
44928 GC_ADDREF(obj); /* For $this pointer */
44929 if (GC_DELREF(orig_obj) == 0) {
44930 zend_objects_store_del(orig_obj);
44931 }
44932 }
44933 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
44934 init_func_run_time_cache(&fbc->op_array);
44935 }
44936 }
44937
44938 if (IS_CONST != IS_CONST) {
44939
44940 }
44941
44942 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
44943 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
44944 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
44945 zend_objects_store_del(obj);
44946 if (UNEXPECTED(EG(exception))) {
44947 HANDLE_EXCEPTION();
44948 }
44949 }
44950 /* call static method */
44951 obj = (zend_object*)called_scope;
44952 call_info = ZEND_CALL_NESTED_FUNCTION;
44953 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
44954 if (IS_CV == IS_CV) {
44955 GC_ADDREF(obj); /* For $this pointer */
44956 }
44957 /* CV may be changed indirectly (e.g. when it's a reference) */
44958 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
44959 }
44960
44961 call = zend_vm_stack_push_call_frame(call_info,
44962 fbc, opline->extended_value, obj);
44963 call->prev_execute_data = EX(call);
44964 EX(call) = call;
44965
44966 ZEND_VM_NEXT_OPCODE();
44967}
44968
44969static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44970{
44971 USE_OPLINE
44972 zval *varptr, *arg;
44973
44974 if (IS_CONST == IS_CONST) {
44975 SAVE_OPLINE();
44976 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
44977 uint32_t arg_num;
44978 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
44979 if (UNEXPECTED(!arg)) {
44980
44981 HANDLE_EXCEPTION();
44982 }
44983 } else {
44984 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
44985 }
44986
44987 varptr = EX_VAR(opline->op1.var);
44988 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
44989 SAVE_OPLINE();
44990 ZVAL_UNDEFINED_OP1();
44991 ZVAL_NULL(arg);
44992 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44993 }
44994
44995 if (IS_CV == IS_CV) {
44996 ZVAL_COPY_DEREF(arg, varptr);
44997 } else /* if (IS_CV == IS_VAR) */ {
44998 if (UNEXPECTED(Z_ISREF_P(varptr))) {
44999 zend_refcounted *ref = Z_COUNTED_P(varptr);
45000
45001 varptr = Z_REFVAL_P(varptr);
45002 ZVAL_COPY_VALUE(arg, varptr);
45003 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
45004 efree_size(ref, sizeof(zend_reference));
45005 } else if (Z_OPT_REFCOUNTED_P(arg)) {
45006 Z_ADDREF_P(arg);
45007 }
45008 } else {
45009 ZVAL_COPY_VALUE(arg, varptr);
45010 }
45011 }
45012
45013 ZEND_VM_NEXT_OPCODE();
45014}
45015
45016static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45017{
45018 USE_OPLINE
45019 zval *varptr, *arg;
45020
45021 SAVE_OPLINE();
45022 if (IS_CONST == IS_CONST) {
45023 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45024 uint32_t arg_num;
45025 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
45026 if (UNEXPECTED(!arg)) {
45027
45028 HANDLE_EXCEPTION();
45029 }
45030 } else {
45031 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
45032 }
45033
45034 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45035 if (Z_ISREF_P(varptr)) {
45036 Z_ADDREF_P(varptr);
45037 } else {
45038 ZVAL_MAKE_REF_EX(varptr, 2);
45039 }
45040 ZVAL_REF(arg, Z_REF_P(varptr));
45041
45042 ZEND_VM_NEXT_OPCODE();
45043}
45044
45045static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45046{
45047 USE_OPLINE
45048 zval *varptr, *arg;
45049 uint32_t arg_num;
45050
45051 if (IS_CONST == IS_CONST) {
45052 SAVE_OPLINE();
45053 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45054 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
45055 if (UNEXPECTED(!arg)) {
45056
45057 HANDLE_EXCEPTION();
45058 }
45059 } else {
45060 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
45061 arg_num = opline->op2.num;
45062 }
45063
45064 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
45065 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
45066 goto send_var_by_ref;
45067 }
45068 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
45069send_var_by_ref:
45070 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45071 if (Z_ISREF_P(varptr)) {
45072 Z_ADDREF_P(varptr);
45073 } else {
45074 ZVAL_MAKE_REF_EX(varptr, 2);
45075 }
45076 ZVAL_REF(arg, Z_REF_P(varptr));
45077
45078 ZEND_VM_NEXT_OPCODE();
45079 }
45080
45081 varptr = EX_VAR(opline->op1.var);
45082 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
45083 SAVE_OPLINE();
45084 ZVAL_UNDEFINED_OP1();
45085 ZVAL_NULL(arg);
45086 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45087 }
45088
45089 if (IS_CV == IS_CV) {
45090 ZVAL_COPY_DEREF(arg, varptr);
45091 } else /* if (IS_CV == IS_VAR) */ {
45092 if (UNEXPECTED(Z_ISREF_P(varptr))) {
45093 zend_refcounted *ref = Z_COUNTED_P(varptr);
45094
45095 varptr = Z_REFVAL_P(varptr);
45096 ZVAL_COPY_VALUE(arg, varptr);
45097 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
45098 efree_size(ref, sizeof(zend_reference));
45099 } else if (Z_OPT_REFCOUNTED_P(arg)) {
45100 Z_ADDREF_P(arg);
45101 }
45102 } else {
45103 ZVAL_COPY_VALUE(arg, varptr);
45104 }
45105 }
45106
45107 ZEND_VM_NEXT_OPCODE();
45108}
45109
45110static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45111{
45112 USE_OPLINE
45113 zval *expr_ptr, new_expr;
45114
45115 SAVE_OPLINE();
45116 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
45117 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
45118 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45119 if (Z_ISREF_P(expr_ptr)) {
45120 Z_ADDREF_P(expr_ptr);
45121 } else {
45122 ZVAL_MAKE_REF_EX(expr_ptr, 2);
45123 }
45124
45125 } else {
45126 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45127 if (IS_CV == IS_TMP_VAR) {
45128 /* pass */
45129 } else if (IS_CV == IS_CONST) {
45130 Z_TRY_ADDREF_P(expr_ptr);
45131 } else if (IS_CV == IS_CV) {
45132 ZVAL_DEREF(expr_ptr);
45133 Z_TRY_ADDREF_P(expr_ptr);
45134 } else /* if (IS_CV == IS_VAR) */ {
45135 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
45136 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
45137
45138 expr_ptr = Z_REFVAL_P(expr_ptr);
45139 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
45140 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
45141 expr_ptr = &new_expr;
45142 efree_size(ref, sizeof(zend_reference));
45143 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
45144 Z_ADDREF_P(expr_ptr);
45145 }
45146 }
45147 }
45148 }
45149
45150 if (IS_CONST != IS_UNUSED) {
45151 zval *offset = RT_CONSTANT(opline, opline->op2);
45152 zend_string *str;
45153 zend_ulong hval;
45154
45155add_again:
45156 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45157 str = Z_STR_P(offset);
45158 if (IS_CONST != IS_CONST) {
45159 if (ZEND_HANDLE_NUMERIC(str, hval)) {
45160 goto num_index;
45161 }
45162 }
45163str_index:
45164 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
45165 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45166 hval = Z_LVAL_P(offset);
45167num_index:
45168 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
45169 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
45170 offset = Z_REFVAL_P(offset);
45171 goto add_again;
45172 } else if (Z_TYPE_P(offset) == IS_NULL) {
45173 str = ZSTR_EMPTY_ALLOC();
45174 goto str_index;
45175 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
45176 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
45177 goto num_index;
45178 } else if (Z_TYPE_P(offset) == IS_FALSE) {
45179 hval = 0;
45180 goto num_index;
45181 } else if (Z_TYPE_P(offset) == IS_TRUE) {
45182 hval = 1;
45183 goto num_index;
45184 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
45185 zend_use_resource_as_offset(offset);
45186 hval = Z_RES_HANDLE_P(offset);
45187 goto num_index;
45188 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
45189 ZVAL_UNDEFINED_OP2();
45190 str = ZSTR_EMPTY_ALLOC();
45191 goto str_index;
45192 } else {
45193 zend_illegal_array_offset_access(offset);
45194 zval_ptr_dtor_nogc(expr_ptr);
45195 }
45196
45197 } else {
45198 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
45199 zend_cannot_add_element();
45200 zval_ptr_dtor_nogc(expr_ptr);
45201 }
45202 }
45203 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45204}
45205
45206static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45207{
45208 zval *array;
45209 uint32_t size;
45210 USE_OPLINE
45211
45212 SAVE_OPLINE();
45213 array = EX_VAR(opline->result.var);
45214 if (IS_CV != IS_UNUSED) {
45215 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
45216 ZVAL_ARR(array, zend_new_array(size));
45217 /* Explicitly initialize array as not-packed if flag is set */
45218 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
45219 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
45220 }
45221 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45222 } else {
45223 ZVAL_ARR(array, zend_new_array(0));
45224 ZEND_VM_NEXT_OPCODE();
45225 }
45226}
45227
45228static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45229{
45230 USE_OPLINE
45231 zval *container;
45232 zval *offset;
45233 zend_ulong hval;
45234 zend_string *key;
45235
45236 SAVE_OPLINE();
45237 container = EX_VAR(opline->op1.var);
45238 offset = RT_CONSTANT(opline, opline->op2);
45239
45240 do {
45241 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45242 HashTable *ht;
45243
45244unset_dim_array:
45245 SEPARATE_ARRAY(container);
45246 ht = Z_ARRVAL_P(container);
45247offset_again:
45248 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45249 key = Z_STR_P(offset);
45250 if (IS_CONST != IS_CONST) {
45251 if (ZEND_HANDLE_NUMERIC(key, hval)) {
45252 goto num_index_dim;
45253 }
45254 }
45255str_index_dim:
45256 ZEND_ASSERT(ht != &EG(symbol_table));
45257 zend_hash_del(ht, key);
45258 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45259 hval = Z_LVAL_P(offset);
45260num_index_dim:
45261 zend_hash_index_del(ht, hval);
45262 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
45263 offset = Z_REFVAL_P(offset);
45264 goto offset_again;
45265 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
45266 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
45267 goto num_index_dim;
45268 } else if (Z_TYPE_P(offset) == IS_NULL) {
45269 key = ZSTR_EMPTY_ALLOC();
45270 goto str_index_dim;
45271 } else if (Z_TYPE_P(offset) == IS_FALSE) {
45272 hval = 0;
45273 goto num_index_dim;
45274 } else if (Z_TYPE_P(offset) == IS_TRUE) {
45275 hval = 1;
45276 goto num_index_dim;
45277 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
45278 zend_use_resource_as_offset(offset);
45279 hval = Z_RES_HANDLE_P(offset);
45280 goto num_index_dim;
45281 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
45282 ZVAL_UNDEFINED_OP2();
45283 key = ZSTR_EMPTY_ALLOC();
45284 goto str_index_dim;
45285 } else {
45286 zend_illegal_array_offset_unset(offset);
45287 }
45288 break;
45289 } else if (Z_ISREF_P(container)) {
45290 container = Z_REFVAL_P(container);
45291 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45292 goto unset_dim_array;
45293 }
45294 }
45295 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
45296 container = ZVAL_UNDEFINED_OP1();
45297 }
45298 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
45299 offset = ZVAL_UNDEFINED_OP2();
45300 }
45301 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
45302 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
45303 offset++;
45304 }
45305 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
45306 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
45307 zend_throw_error(NULL, "Cannot unset string offsets");
45308 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
45309 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
45310 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
45311 zend_false_to_array_deprecated();
45312 }
45313 } while (0);
45314
45315
45316 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45317}
45318
45319static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45320{
45321 USE_OPLINE
45322 zval *container;
45323 zval *offset;
45324 zend_string *name, *tmp_name;
45325
45326 SAVE_OPLINE();
45327 container = EX_VAR(opline->op1.var);
45328 offset = RT_CONSTANT(opline, opline->op2);
45329
45330 do {
45331 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
45332 if (Z_ISREF_P(container)) {
45333 container = Z_REFVAL_P(container);
45334 if (Z_TYPE_P(container) != IS_OBJECT) {
45335 if (IS_CV == IS_CV
45336 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
45337 ZVAL_UNDEFINED_OP1();
45338 }
45339 break;
45340 }
45341 } else {
45342 break;
45343 }
45344 }
45345 if (IS_CONST == IS_CONST) {
45346 name = Z_STR_P(offset);
45347 } else {
45348 name = zval_try_get_tmp_string(offset, &tmp_name);
45349 if (UNEXPECTED(!name)) {
45350 break;
45351 }
45352 }
45353 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
45354 if (IS_CONST != IS_CONST) {
45355 zend_tmp_string_release(tmp_name);
45356 }
45357 } while (0);
45358
45359
45360 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45361}
45362
45363static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45364{
45365 USE_OPLINE
45366 zval *container;
45367 bool result;
45368 zend_ulong hval;
45369 zval *offset;
45370
45371 SAVE_OPLINE();
45372 container = EX_VAR(opline->op1.var);
45373 offset = RT_CONSTANT(opline, opline->op2);
45374
45375 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45376 HashTable *ht;
45377 zval *value;
45378 zend_string *str;
45379
45380isset_dim_obj_array:
45381 ht = Z_ARRVAL_P(container);
45382isset_again:
45383 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45384 str = Z_STR_P(offset);
45385 if (IS_CONST != IS_CONST) {
45386 if (ZEND_HANDLE_NUMERIC(str, hval)) {
45387 goto num_index_prop;
45388 }
45389 }
45390 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
45391 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45392 hval = Z_LVAL_P(offset);
45393num_index_prop:
45394 value = zend_hash_index_find(ht, hval);
45395 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
45396 offset = Z_REFVAL_P(offset);
45397 goto isset_again;
45398 } else {
45399 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
45400 if (UNEXPECTED(EG(exception))) {
45401 result = 0;
45402 goto isset_dim_obj_exit;
45403 }
45404 }
45405
45406 if (!(opline->extended_value & ZEND_ISEMPTY)) {
45407 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
45408 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
45409 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
45410
45411 if (IS_CV & (IS_CONST|IS_CV)) {
45412 /* avoid exception check */
45413
45414 ZEND_VM_SMART_BRANCH(result, 0);
45415 }
45416 } else {
45417 result = (value == NULL || !i_zend_is_true(value));
45418 }
45419 goto isset_dim_obj_exit;
45420 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
45421 container = Z_REFVAL_P(container);
45422 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45423 goto isset_dim_obj_array;
45424 }
45425 }
45426
45427 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
45428 offset++;
45429 }
45430 if (!(opline->extended_value & ZEND_ISEMPTY)) {
45431 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
45432 } else {
45433 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
45434 }
45435
45436isset_dim_obj_exit:
45437
45438
45439 ZEND_VM_SMART_BRANCH(result, 1);
45440}
45441
45442static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45443{
45444 USE_OPLINE
45445 zval *container;
45446 int result;
45447 zval *offset;
45448 zend_string *name, *tmp_name;
45449
45450 SAVE_OPLINE();
45451 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
45452 offset = RT_CONSTANT(opline, opline->op2);
45453
45454 if (IS_CV == IS_CONST ||
45455 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
45456 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
45457 container = Z_REFVAL_P(container);
45458 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
45459 result = (opline->extended_value & ZEND_ISEMPTY);
45460 goto isset_object_finish;
45461 }
45462 } else {
45463 result = (opline->extended_value & ZEND_ISEMPTY);
45464 goto isset_object_finish;
45465 }
45466 }
45467
45468 if (IS_CONST == IS_CONST) {
45469 name = Z_STR_P(offset);
45470 } else {
45471 name = zval_try_get_tmp_string(offset, &tmp_name);
45472 if (UNEXPECTED(!name)) {
45473 result = 0;
45474 goto isset_object_finish;
45475 }
45476 }
45477
45478 result =
45479 (opline->extended_value & ZEND_ISEMPTY) ^
45480 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));
45481
45482 if (IS_CONST != IS_CONST) {
45483 zend_tmp_string_release(tmp_name);
45484 }
45485
45486isset_object_finish:
45487
45488
45489 ZEND_VM_SMART_BRANCH(result, 1);
45490}
45491
45492static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45493{
45494 USE_OPLINE
45495
45496 zval *key, *subject;
45497 HashTable *ht;
45498 bool result;
45499
45500 SAVE_OPLINE();
45501
45502 key = EX_VAR(opline->op1.var);
45503 subject = RT_CONSTANT(opline, opline->op2);
45504
45505 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
45506array_key_exists_array:
45507 ht = Z_ARRVAL_P(subject);
45508 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
45509 } else {
45510 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
45511 subject = Z_REFVAL_P(subject);
45512 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
45513 goto array_key_exists_array;
45514 }
45515 }
45516 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
45517 result = 0;
45518 }
45519
45520
45521 ZEND_VM_SMART_BRANCH(result, 1);
45522}
45523
45524static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45525{
45526 USE_OPLINE
45527 zval *expr;
45528 bool result;
45529
45530 SAVE_OPLINE();
45531 expr = EX_VAR(opline->op1.var);
45532
45533try_instanceof:
45534 if (Z_TYPE_P(expr) == IS_OBJECT) {
45535 zend_class_entry *ce;
45536
45537 if (IS_CONST == IS_CONST) {
45538 ce = CACHED_PTR(opline->extended_value);
45539 if (UNEXPECTED(ce == NULL)) {
45540 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);
45541 if (EXPECTED(ce)) {
45542 CACHE_PTR(opline->extended_value, ce);
45543 }
45544 }
45545 } else if (IS_CONST == IS_UNUSED) {
45546 ce = zend_fetch_class(NULL, opline->op2.num);
45547 if (UNEXPECTED(ce == NULL)) {
45548
45549 ZVAL_UNDEF(EX_VAR(opline->result.var));
45550 HANDLE_EXCEPTION();
45551 }
45552 } else {
45553 ce = Z_CE_P(EX_VAR(opline->op2.var));
45554 }
45555 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
45556 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
45557 expr = Z_REFVAL_P(expr);
45558 goto try_instanceof;
45559 } else {
45560 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
45561 ZVAL_UNDEFINED_OP1();
45562 }
45563 result = 0;
45564 }
45565
45566 ZEND_VM_SMART_BRANCH(result, 1);
45567}
45568
45569static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45570{
45571 USE_OPLINE
45572
45573 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
45574
45575 SAVE_OPLINE();
45576 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
45577 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45578 }
45579
45580 /* Destroy the previously yielded value */
45581 zval_ptr_dtor(&generator->value);
45582
45583 /* Destroy the previously yielded key */
45584 zval_ptr_dtor(&generator->key);
45585
45586 /* Set the new yielded value */
45587 if (IS_CV != IS_UNUSED) {
45588 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
45589 /* Constants and temporary variables aren't yieldable by reference,
45590 * but we still allow them with a notice. */
45591 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
45592 zval *value;
45593
45594 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
45595
45596 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45597 ZVAL_COPY_VALUE(&generator->value, value);
45598 if (IS_CV == IS_CONST) {
45599 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
45600 Z_ADDREF(generator->value);
45601 }
45602 }
45603 } else {
45604 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45605
45606 /* If a function call result is yielded and the function did
45607 * not return by reference we throw a notice. */
45608 do {
45609 if (IS_CV == IS_VAR) {
45610 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
45611 if (opline->extended_value == ZEND_RETURNS_FUNCTION
45612 && !Z_ISREF_P(value_ptr)) {
45613 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
45614 ZVAL_COPY(&generator->value, value_ptr);
45615 break;
45616 }
45617 }
45618 if (Z_ISREF_P(value_ptr)) {
45619 Z_ADDREF_P(value_ptr);
45620 } else {
45621 ZVAL_MAKE_REF_EX(value_ptr, 2);
45622 }
45623 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
45624 } while (0);
45625
45626 }
45627 } else {
45628 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45629
45630 /* Consts, temporary variables and references need copying */
45631 if (IS_CV == IS_CONST) {
45632 ZVAL_COPY_VALUE(&generator->value, value);
45633 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
45634 Z_ADDREF(generator->value);
45635 }
45636 } else if (IS_CV == IS_TMP_VAR) {
45637 ZVAL_COPY_VALUE(&generator->value, value);
45638 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
45639 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
45640
45641 } else {
45642 ZVAL_COPY_VALUE(&generator->value, value);
45643 if (IS_CV == IS_CV) {
45644 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
45645 }
45646 }
45647 }
45648 } else {
45649 /* If no value was specified yield null */
45650 ZVAL_NULL(&generator->value);
45651 }
45652
45653 /* Set the new yielded key */
45654 if (IS_CONST != IS_UNUSED) {
45655 zval *key = RT_CONSTANT(opline, opline->op2);
45656 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
45657 key = Z_REFVAL_P(key);
45658 }
45659 ZVAL_COPY(&generator->key, key);
45660
45661 if (Z_TYPE(generator->key) == IS_LONG
45662 && Z_LVAL(generator->key) > generator->largest_used_integer_key
45663 ) {
45664 generator->largest_used_integer_key = Z_LVAL(generator->key);
45665 }
45666 } else {
45667 /* If no key was specified we use auto-increment keys */
45668 generator->largest_used_integer_key++;
45669 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
45670 }
45671
45672 if (RETURN_VALUE_USED(opline)) {
45673 /* If the return value of yield is used set the send
45674 * target and initialize it to NULL */
45675 generator->send_target = EX_VAR(opline->result.var);
45676 ZVAL_NULL(generator->send_target);
45677 } else {
45678 generator->send_target = NULL;
45679 }
45680
45681 /* The GOTO VM uses a local opline variable. We need to set the opline
45682 * variable in execute_data so we don't resume at an old position. */
45683 SAVE_OPLINE();
45684
45685 ZEND_VM_RETURN();
45686}
45687
45688static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45689{
45690 USE_OPLINE
45691 zend_string *varname;
45692 zval *value;
45693 zval *variable_ptr;
45694 uintptr_t idx;
45695 zend_reference *ref;
45696
45697 ZEND_VM_REPEATABLE_OPCODE
45698
45699 varname = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45700
45701 /* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45702 idx = (uintptr_t)CACHED_PTR(opline->extended_value) - 1;
45703 if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket))) {
45704 Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
45705
45706 if (EXPECTED(p->key == varname) ||
45707 (EXPECTED(p->h == ZSTR_H(varname)) &&
45708 EXPECTED(p->key != NULL) &&
45709 EXPECTED(zend_string_equal_content(p->key, varname)))) {
45710
45711 value = (zval*)p; /* value = &p->val; */
45712 goto check_indirect;
45713 }
45714 }
45715
45716 value = zend_hash_find_known_hash(&EG(symbol_table), varname);
45717 if (UNEXPECTED(value == NULL)) {
45718 value = zend_hash_add_new(&EG(symbol_table), varname, &EG(uninitialized_zval));
45719 idx = (char*)value - (char*)EG(symbol_table).arData;
45720 /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45721 CACHE_PTR(opline->extended_value, (void*)(idx + 1));
45722 } else {
45723 idx = (char*)value - (char*)EG(symbol_table).arData;
45724 /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45725 CACHE_PTR(opline->extended_value, (void*)(idx + 1));
45726check_indirect:
45727 /* GLOBAL variable may be an INDIRECT pointer to CV */
45728 if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
45729 value = Z_INDIRECT_P(value);
45730 if (UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
45731 ZVAL_NULL(value);
45732 }
45733 }
45734 }
45735
45736 if (UNEXPECTED(!Z_ISREF_P(value))) {
45737 ZVAL_MAKE_REF_EX(value, 2);
45738 ref = Z_REF_P(value);
45739 } else {
45740 ref = Z_REF_P(value);
45741 GC_ADDREF(ref);
45742 }
45743
45744 variable_ptr = EX_VAR(opline->op1.var);
45745
45746 if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr))) {
45747 zend_refcounted *garbage = Z_COUNTED_P(variable_ptr);
45748
45749 ZVAL_REF(variable_ptr, ref);
45750 SAVE_OPLINE();
45751 if (GC_DELREF(garbage) == 0) {
45752 rc_dtor_func(garbage);
45753 if (UNEXPECTED(EG(exception))) {
45754 ZVAL_NULL(variable_ptr);
45755 HANDLE_EXCEPTION();
45756 }
45757 } else {
45758 gc_check_possible_root(garbage);
45759 }
45760 } else {
45761 ZVAL_REF(variable_ptr, ref);
45762 }
45763
45764 ZEND_VM_REPEAT_OPCODE(ZEND_BIND_GLOBAL);
45765 ZEND_VM_NEXT_OPCODE();
45766}
45767
45768static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45769{
45770 USE_OPLINE
45771 zval *op1;
45772 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
45773 zval *result;
45774
45775 op1 = EX_VAR(opline->op1.var);
45776 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45777 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CV == IS_CONST);
45778 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45779 zval_ptr_dtor_str(op1);
45780 }
45781 ZEND_VM_SMART_BRANCH(result, 0);
45782 }
45783
45784 if (opline->extended_value) {
45785 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45786 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
45787 ZEND_VM_SMART_BRANCH(result, 0);
45788 }
45789 SAVE_OPLINE();
45790 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
45791 op1 = Z_REFVAL_P(op1);
45792 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45793 result = zend_hash_find(ht, Z_STR_P(op1));
45794
45795 ZEND_VM_SMART_BRANCH(result, 0);
45796 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45797 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
45798
45799 ZEND_VM_SMART_BRANCH(result, 0);
45800 }
45801 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
45802 ZVAL_UNDEFINED_OP1();
45803 }
45804 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
45805 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
45806 SAVE_OPLINE();
45807 ZVAL_UNDEFINED_OP1();
45808 if (UNEXPECTED(EG(exception) != NULL)) {
45809 HANDLE_EXCEPTION();
45810 }
45811 }
45812 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
45813 ZEND_VM_SMART_BRANCH(result, 0);
45814 } else {
45815 zend_string *key;
45816 zval key_tmp;
45817
45818 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
45819 op1 = Z_REFVAL_P(op1);
45820 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45821 result = zend_hash_find(ht, Z_STR_P(op1));
45822
45823 ZEND_VM_SMART_BRANCH(result, 0);
45824 }
45825 }
45826
45827 SAVE_OPLINE();
45828 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
45829 ZVAL_STR(&key_tmp, key);
45830 if (zend_compare(op1, &key_tmp) == 0) {
45831
45832 ZEND_VM_SMART_BRANCH(1, 1);
45833 }
45834 } ZEND_HASH_FOREACH_END();
45835 }
45836
45837 ZEND_VM_SMART_BRANCH(0, 1);
45838}
45839
45840static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45841{
45842 /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
45843 /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
45844 /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
45845 USE_OPLINE
45846 zval *op1, *op2;
45847 bool result;
45848
45849 op1 = EX_VAR(opline->op1.var);
45850 op2 = RT_CONSTANT(opline, opline->op2);
45851 result = fast_is_identical_function(op1, op2);
45852 /* Free is a no-op for const/cv */
45853 ZEND_VM_SMART_BRANCH(result, 0);
45854}
45855
45856static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45857{
45858 USE_OPLINE
45859 zval *op1, *op2;
45860 bool result;
45861
45862 op1 = EX_VAR(opline->op1.var);
45863 op2 = RT_CONSTANT(opline, opline->op2);
45864 result = fast_is_identical_function(op1, op2);
45865 /* Free is a no-op for const/cv */
45866 ZEND_VM_SMART_BRANCH(!result, 0);
45867}
45868
45869static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45870{
45871 USE_OPLINE
45872 zval *container, *dim, *value;
45873 zend_long offset;
45874 HashTable *ht;
45875
45876 container = EX_VAR(opline->op1.var);
45877 dim = RT_CONSTANT(opline, opline->op2);
45878 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45879fetch_dim_r_index_array:
45880 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
45881 offset = Z_LVAL_P(dim);
45882 } else {
45883 SAVE_OPLINE();
45884 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
45885
45886 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45887 }
45888 ht = Z_ARRVAL_P(container);
45889 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
45890 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
45891 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45892 SAVE_OPLINE();
45893
45894 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45895 } else {
45896 ZEND_VM_NEXT_OPCODE();
45897 }
45898 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
45899 container = Z_REFVAL_P(container);
45900 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45901 goto fetch_dim_r_index_array;
45902 } else {
45903 goto fetch_dim_r_index_slow;
45904 }
45905 } else {
45906fetch_dim_r_index_slow:
45907 SAVE_OPLINE();
45908 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
45909 dim++;
45910 }
45911 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
45912
45913 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45914 }
45915
45916fetch_dim_r_index_undef:
45917 ZVAL_NULL(EX_VAR(opline->result.var));
45918 SAVE_OPLINE();
45919 zend_undefined_offset(offset);
45920
45921 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45922}
45923
45924static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45925{
45926 USE_OPLINE
45927 zval *container, *dim, *value;
45928 zend_long offset;
45929 HashTable *ht;
45930
45931 container = EX_VAR(opline->op1.var);
45932 dim = EX_VAR(opline->op2.var);
45933 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45934fetch_dim_r_index_array:
45935 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
45936 offset = Z_LVAL_P(dim);
45937 } else {
45938 SAVE_OPLINE();
45939 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
45940
45941 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45942 }
45943 ht = Z_ARRVAL_P(container);
45944 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
45945 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
45946 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45947 SAVE_OPLINE();
45948
45949 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45950 } else {
45951 ZEND_VM_NEXT_OPCODE();
45952 }
45953 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
45954 container = Z_REFVAL_P(container);
45955 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45956 goto fetch_dim_r_index_array;
45957 } else {
45958 goto fetch_dim_r_index_slow;
45959 }
45960 } else {
45961fetch_dim_r_index_slow:
45962 SAVE_OPLINE();
45963 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
45964 dim++;
45965 }
45966 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
45967
45968 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45969 }
45970
45971fetch_dim_r_index_undef:
45972 ZVAL_NULL(EX_VAR(opline->result.var));
45973 SAVE_OPLINE();
45974 zend_undefined_offset(offset);
45975
45976 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45977}
45978
45979static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45980{
45981 USE_OPLINE
45982 zval *op1, *op2;
45983
45984 SAVE_OPLINE();
45985 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45986 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45987 div_function(EX_VAR(opline->result.var), op1, op2);
45988
45989 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45990 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45991}
45992
45993static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45994{
45995 USE_OPLINE
45996 zval *op1, *op2;
45997
45998 SAVE_OPLINE();
45999 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46000 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46001 pow_function(EX_VAR(opline->result.var), op1, op2);
46002
46003 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46004 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46005}
46006
46007static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46008{
46009 USE_OPLINE
46010 zval *op1, *op2;
46011
46012 op1 = EX_VAR(opline->op1.var);
46013 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46014
46015 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
46016 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
46017 zend_string *op1_str = Z_STR_P(op1);
46018 zend_string *op2_str = Z_STR_P(op2);
46019 zend_string *str;
46020 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
46021
46022 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
46023 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
46024 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
46025 } else {
46026 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
46027 }
46028 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46029 zend_string_release_ex(op1_str, 0);
46030 }
46031 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
46032 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
46033 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
46034 } else {
46035 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
46036 }
46037 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46038 zend_string_release_ex(op2_str, 0);
46039 }
46040 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
46041 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
46042 size_t len = ZSTR_LEN(op1_str);
46043
46044 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
46045 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
46046 }
46047 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
46048 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
46049 GC_ADD_FLAGS(str, flags);
46050 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
46051 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46052 zend_string_release_ex(op2_str, 0);
46053 }
46054 } else {
46055 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
46056 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
46057 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
46058 GC_ADD_FLAGS(str, flags);
46059 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
46060 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46061 zend_string_release_ex(op1_str, 0);
46062 }
46063 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46064 zend_string_release_ex(op2_str, 0);
46065 }
46066 }
46067 ZEND_VM_NEXT_OPCODE();
46068 } else {
46069 SAVE_OPLINE();
46070
46071 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
46072 op1 = ZVAL_UNDEFINED_OP1();
46073 }
46074 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
46075 op2 = ZVAL_UNDEFINED_OP2();
46076 }
46077 concat_function(EX_VAR(opline->result.var), op1, op2);
46078
46079 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46080 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46081 }
46082}
46083
46084static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46085{
46086 USE_OPLINE
46087 zval *op1, *op2;
46088 double d1, d2;
46089
46090 op1 = EX_VAR(opline->op1.var);
46091 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46092 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46093 /* pass */
46094 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46095 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46096 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46097is_equal_true:
46098 ZEND_VM_SMART_BRANCH_TRUE_NONE();
46099 } else {
46100is_equal_false:
46101 ZEND_VM_SMART_BRANCH_FALSE_NONE();
46102 }
46103 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46104 d1 = (double)Z_LVAL_P(op1);
46105 d2 = Z_DVAL_P(op2);
46106 goto is_equal_double;
46107 }
46108 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46109 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46110 d1 = Z_DVAL_P(op1);
46111 d2 = Z_DVAL_P(op2);
46112is_equal_double:
46113 if (d1 == d2) {
46114 goto is_equal_true;
46115 } else {
46116 goto is_equal_false;
46117 }
46118 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46119 d1 = Z_DVAL_P(op1);
46120 d2 = (double)Z_LVAL_P(op2);
46121 goto is_equal_double;
46122 }
46123 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46124 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46125 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46126 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46127 zval_ptr_dtor_str(op1);
46128 }
46129 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46130 zval_ptr_dtor_str(op2);
46131 }
46132 if (result) {
46133 goto is_equal_true;
46134 } else {
46135 goto is_equal_false;
46136 }
46137 }
46138 }
46139 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46140}
46141
46142static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46143{
46144 USE_OPLINE
46145 zval *op1, *op2;
46146 double d1, d2;
46147
46148 op1 = EX_VAR(opline->op1.var);
46149 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46150 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46151 /* pass */
46152 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46153 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46154 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46155is_equal_true:
46156 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
46157 } else {
46158is_equal_false:
46159 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
46160 }
46161 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46162 d1 = (double)Z_LVAL_P(op1);
46163 d2 = Z_DVAL_P(op2);
46164 goto is_equal_double;
46165 }
46166 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46167 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46168 d1 = Z_DVAL_P(op1);
46169 d2 = Z_DVAL_P(op2);
46170is_equal_double:
46171 if (d1 == d2) {
46172 goto is_equal_true;
46173 } else {
46174 goto is_equal_false;
46175 }
46176 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46177 d1 = Z_DVAL_P(op1);
46178 d2 = (double)Z_LVAL_P(op2);
46179 goto is_equal_double;
46180 }
46181 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46182 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46183 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46184 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46185 zval_ptr_dtor_str(op1);
46186 }
46187 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46188 zval_ptr_dtor_str(op2);
46189 }
46190 if (result) {
46191 goto is_equal_true;
46192 } else {
46193 goto is_equal_false;
46194 }
46195 }
46196 }
46197 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46198}
46199
46200static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46201{
46202 USE_OPLINE
46203 zval *op1, *op2;
46204 double d1, d2;
46205
46206 op1 = EX_VAR(opline->op1.var);
46207 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46208 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46209 /* pass */
46210 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46211 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46212 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46213is_equal_true:
46214 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
46215 } else {
46216is_equal_false:
46217 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
46218 }
46219 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46220 d1 = (double)Z_LVAL_P(op1);
46221 d2 = Z_DVAL_P(op2);
46222 goto is_equal_double;
46223 }
46224 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46225 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46226 d1 = Z_DVAL_P(op1);
46227 d2 = Z_DVAL_P(op2);
46228is_equal_double:
46229 if (d1 == d2) {
46230 goto is_equal_true;
46231 } else {
46232 goto is_equal_false;
46233 }
46234 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46235 d1 = Z_DVAL_P(op1);
46236 d2 = (double)Z_LVAL_P(op2);
46237 goto is_equal_double;
46238 }
46239 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46240 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46241 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46242 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46243 zval_ptr_dtor_str(op1);
46244 }
46245 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46246 zval_ptr_dtor_str(op2);
46247 }
46248 if (result) {
46249 goto is_equal_true;
46250 } else {
46251 goto is_equal_false;
46252 }
46253 }
46254 }
46255 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46256}
46257
46258static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46259{
46260 USE_OPLINE
46261 zval *op1, *op2;
46262 double d1, d2;
46263
46264 op1 = EX_VAR(opline->op1.var);
46265 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46266 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46267 /* pass */
46268 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46269 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46270 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46271is_not_equal_true:
46272 ZEND_VM_SMART_BRANCH_TRUE_NONE();
46273 } else {
46274is_not_equal_false:
46275 ZEND_VM_SMART_BRANCH_FALSE_NONE();
46276 }
46277 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46278 d1 = (double)Z_LVAL_P(op1);
46279 d2 = Z_DVAL_P(op2);
46280 goto is_not_equal_double;
46281 }
46282 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46283 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46284 d1 = Z_DVAL_P(op1);
46285 d2 = Z_DVAL_P(op2);
46286is_not_equal_double:
46287 if (d1 != d2) {
46288 goto is_not_equal_true;
46289 } else {
46290 goto is_not_equal_false;
46291 }
46292 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46293 d1 = Z_DVAL_P(op1);
46294 d2 = (double)Z_LVAL_P(op2);
46295 goto is_not_equal_double;
46296 }
46297 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46298 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46299 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46300 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46301 zval_ptr_dtor_str(op1);
46302 }
46303 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46304 zval_ptr_dtor_str(op2);
46305 }
46306 if (!result) {
46307 goto is_not_equal_true;
46308 } else {
46309 goto is_not_equal_false;
46310 }
46311 }
46312 }
46313 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46314}
46315
46316static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46317{
46318 USE_OPLINE
46319 zval *op1, *op2;
46320 double d1, d2;
46321
46322 op1 = EX_VAR(opline->op1.var);
46323 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46324 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46325 /* pass */
46326 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46327 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46328 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46329is_not_equal_true:
46330 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
46331 } else {
46332is_not_equal_false:
46333 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
46334 }
46335 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46336 d1 = (double)Z_LVAL_P(op1);
46337 d2 = Z_DVAL_P(op2);
46338 goto is_not_equal_double;
46339 }
46340 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46341 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46342 d1 = Z_DVAL_P(op1);
46343 d2 = Z_DVAL_P(op2);
46344is_not_equal_double:
46345 if (d1 != d2) {
46346 goto is_not_equal_true;
46347 } else {
46348 goto is_not_equal_false;
46349 }
46350 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46351 d1 = Z_DVAL_P(op1);
46352 d2 = (double)Z_LVAL_P(op2);
46353 goto is_not_equal_double;
46354 }
46355 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46356 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46357 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46358 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46359 zval_ptr_dtor_str(op1);
46360 }
46361 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46362 zval_ptr_dtor_str(op2);
46363 }
46364 if (!result) {
46365 goto is_not_equal_true;
46366 } else {
46367 goto is_not_equal_false;
46368 }
46369 }
46370 }
46371 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46372}
46373
46374static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46375{
46376 USE_OPLINE
46377 zval *op1, *op2;
46378 double d1, d2;
46379
46380 op1 = EX_VAR(opline->op1.var);
46381 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46382 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46383 /* pass */
46384 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46385 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46386 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46387is_not_equal_true:
46388 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
46389 } else {
46390is_not_equal_false:
46391 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
46392 }
46393 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46394 d1 = (double)Z_LVAL_P(op1);
46395 d2 = Z_DVAL_P(op2);
46396 goto is_not_equal_double;
46397 }
46398 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46399 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46400 d1 = Z_DVAL_P(op1);
46401 d2 = Z_DVAL_P(op2);
46402is_not_equal_double:
46403 if (d1 != d2) {
46404 goto is_not_equal_true;
46405 } else {
46406 goto is_not_equal_false;
46407 }
46408 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46409 d1 = Z_DVAL_P(op1);
46410 d2 = (double)Z_LVAL_P(op2);
46411 goto is_not_equal_double;
46412 }
46413 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46414 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46415 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46416 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46417 zval_ptr_dtor_str(op1);
46418 }
46419 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46420 zval_ptr_dtor_str(op2);
46421 }
46422 if (!result) {
46423 goto is_not_equal_true;
46424 } else {
46425 goto is_not_equal_false;
46426 }
46427 }
46428 }
46429 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46430}
46431
46432static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46433{
46434 USE_OPLINE
46435 zval *op1, *op2;
46436
46437 SAVE_OPLINE();
46438 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46439 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46440 compare_function(EX_VAR(opline->result.var), op1, op2);
46441
46442 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46443 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46444}
46445
46446static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46447{
46448 USE_OPLINE
46449 zval *op1, *op2;
46450
46451 SAVE_OPLINE();
46452 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46453 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46454 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
46455
46456 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46457 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46458}
46459
46460static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46461{
46462 USE_OPLINE
46463 zval *object;
46464 zval *property;
46465 zval *value;
46466 zval *zptr;
46467 void *_cache_slot[3] = {0};
46468 void **cache_slot;
46469 zend_property_info *prop_info;
46470 zend_object *zobj;
46471 zend_string *name, *tmp_name;
46472
46473 SAVE_OPLINE();
46474 object = EX_VAR(opline->op1.var);
46475 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46476
46477 do {
46478 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
46479
46480 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46481 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46482 object = Z_REFVAL_P(object);
46483 goto assign_op_object;
46484 }
46485 if (IS_CV == IS_CV
46486 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46487 ZVAL_UNDEFINED_OP1();
46488 }
46489 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46490 break;
46491 }
46492
46493assign_op_object:
46494 /* here we are sure we are dealing with an object */
46495 zobj = Z_OBJ_P(object);
46496 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46497 name = Z_STR_P(property);
46498 } else {
46499 name = zval_try_get_tmp_string(property, &tmp_name);
46500 if (UNEXPECTED(!name)) {
46501 UNDEF_RESULT();
46502 break;
46503 }
46504 }
46505 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
46506 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46507 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46508 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46509 ZVAL_NULL(EX_VAR(opline->result.var));
46510 }
46511 } else {
46512 zend_reference *ref;
46513
46514 do {
46515 if (UNEXPECTED(Z_ISREF_P(zptr))) {
46516 ref = Z_REF_P(zptr);
46517 zptr = Z_REFVAL_P(zptr);
46518 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46519 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46520 break;
46521 }
46522 }
46523
46524 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
46525 if (prop_info) {
46526 /* special case for typed properties */
46527 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
46528 } else {
46529 zend_binary_op(zptr, zptr, value OPLINE_CC);
46530 }
46531 } while (0);
46532
46533 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46534 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
46535 }
46536 }
46537 } else {
46538 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
46539 }
46540 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46541 zend_tmp_string_release(tmp_name);
46542 }
46543 } while (0);
46544
46545 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46546 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46547
46548 /* assign_obj has two opcodes! */
46549 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46550}
46551
46552/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
46553static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46554{
46555 USE_OPLINE
46556 zval *var_ptr;
46557 zval *value, *container, *dim;
46558 HashTable *ht;
46559
46560 SAVE_OPLINE();
46561 container = EX_VAR(opline->op1.var);
46562
46563 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46564assign_dim_op_array:
46565 SEPARATE_ARRAY(container);
46566 ht = Z_ARRVAL_P(container);
46567assign_dim_op_new_array:
46568 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46569 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46570 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
46571 if (UNEXPECTED(!var_ptr)) {
46572 zend_cannot_add_element();
46573 goto assign_dim_op_ret_null;
46574 }
46575 } else {
46576 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46577 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
46578 } else {
46579 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
46580 }
46581 if (UNEXPECTED(!var_ptr)) {
46582 goto assign_dim_op_ret_null;
46583 }
46584 }
46585
46586 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
46587
46588 do {
46589 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
46590 zend_reference *ref = Z_REF_P(var_ptr);
46591 var_ptr = Z_REFVAL_P(var_ptr);
46592 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46593 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46594 break;
46595 }
46596 }
46597 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
46598 } while (0);
46599
46600 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46601 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
46602 }
46603 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46604 } else {
46605 if (EXPECTED(Z_ISREF_P(container))) {
46606 container = Z_REFVAL_P(container);
46607 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46608 goto assign_dim_op_array;
46609 }
46610 }
46611
46612 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
46613 zend_object *obj = Z_OBJ_P(container);
46614
46615 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46616 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46617 dim++;
46618 }
46619 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
46620 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
46621 uint8_t old_type;
46622
46623 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
46624 ZVAL_UNDEFINED_OP1();
46625 }
46626 ht = zend_new_array(8);
46627 old_type = Z_TYPE_P(container);
46628 ZVAL_ARR(container, ht);
46629 if (UNEXPECTED(old_type == IS_FALSE)) {
46630 GC_ADDREF(ht);
46631 zend_false_to_array_deprecated();
46632 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
46633 zend_array_destroy(ht);
46634 goto assign_dim_op_ret_null;
46635 }
46636 }
46637 goto assign_dim_op_new_array;
46638 } else {
46639 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46640 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
46641assign_dim_op_ret_null:
46642 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46643 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46644 ZVAL_NULL(EX_VAR(opline->result.var));
46645 }
46646 }
46647 }
46648
46649 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46650
46651 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46652}
46653
46654static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46655{
46656 USE_OPLINE
46657 zval *var_ptr;
46658 zval *value;
46659
46660 SAVE_OPLINE();
46661 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46662 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
46663
46664 do {
46665 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
46666 zend_reference *ref = Z_REF_P(var_ptr);
46667 var_ptr = Z_REFVAL_P(var_ptr);
46668 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46669 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46670 break;
46671 }
46672 }
46673 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
46674 } while (0);
46675
46676 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46677 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
46678 }
46679
46680 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46681
46682 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46683}
46684
46685static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46686{
46687 USE_OPLINE
46688 zval *object;
46689 zval *property;
46690 zval *zptr;
46691 void *_cache_slot[3] = {0};
46692 void **cache_slot;
46693 zend_property_info *prop_info;
46694 zend_object *zobj;
46695 zend_string *name, *tmp_name;
46696
46697 SAVE_OPLINE();
46698 object = EX_VAR(opline->op1.var);
46699 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46700
46701 do {
46702 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46703 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46704 object = Z_REFVAL_P(object);
46705 goto pre_incdec_object;
46706 }
46707 if (IS_CV == IS_CV
46708 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46709 ZVAL_UNDEFINED_OP1();
46710 }
46711 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46712 break;
46713 }
46714
46715pre_incdec_object:
46716 /* here we are sure we are dealing with an object */
46717 zobj = Z_OBJ_P(object);
46718 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46719 name = Z_STR_P(property);
46720 } else {
46721 name = zval_try_get_tmp_string(property, &tmp_name);
46722 if (UNEXPECTED(!name)) {
46723 UNDEF_RESULT();
46724 break;
46725 }
46726 }
46727 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
46728 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46729 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46730 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46731 ZVAL_NULL(EX_VAR(opline->result.var));
46732 }
46733 } else {
46734 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
46735 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
46736 }
46737 } else {
46738 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
46739 }
46740 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46741 zend_tmp_string_release(tmp_name);
46742 }
46743 } while (0);
46744
46745 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46746
46747 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46748}
46749
46750static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46751{
46752 USE_OPLINE
46753 zval *object;
46754 zval *property;
46755 zval *zptr;
46756 void *_cache_slot[3] = {0};
46757 void **cache_slot;
46758 zend_property_info *prop_info;
46759 zend_object *zobj;
46760 zend_string *name, *tmp_name;
46761
46762 SAVE_OPLINE();
46763 object = EX_VAR(opline->op1.var);
46764 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46765
46766 do {
46767 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46768 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46769 object = Z_REFVAL_P(object);
46770 goto post_incdec_object;
46771 }
46772 if (IS_CV == IS_CV
46773 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46774 ZVAL_UNDEFINED_OP1();
46775 }
46776 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46777 break;
46778 }
46779
46780post_incdec_object:
46781 /* here we are sure we are dealing with an object */
46782 zobj = Z_OBJ_P(object);
46783 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46784 name = Z_STR_P(property);
46785 } else {
46786 name = zval_try_get_tmp_string(property, &tmp_name);
46787 if (UNEXPECTED(!name)) {
46788 ZVAL_UNDEF(EX_VAR(opline->result.var));
46789 break;
46790 }
46791 }
46792 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
46793 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46794 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46795 ZVAL_NULL(EX_VAR(opline->result.var));
46796 } else {
46797 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
46798 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
46799 }
46800 } else {
46801 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
46802 }
46803 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46804 zend_tmp_string_release(tmp_name);
46805 }
46806 } while (0);
46807
46808 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46809
46810 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46811}
46812
46813static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46814{
46815 USE_OPLINE
46816 zval *container, *dim, *value;
46817
46818 SAVE_OPLINE();
46819 container = EX_VAR(opline->op1.var);
46820 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46821 if (IS_CV != IS_CONST) {
46822 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46823fetch_dim_r_array:
46824 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
46825 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46826 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
46827 container = Z_REFVAL_P(container);
46828 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46829 goto fetch_dim_r_array;
46830 } else {
46831 goto fetch_dim_r_slow;
46832 }
46833 } else {
46834fetch_dim_r_slow:
46835 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46836 dim++;
46837 }
46838 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
46839 }
46840 } else {
46841 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
46842 }
46843 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46844
46845 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46846}
46847
46848static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46849{
46850 USE_OPLINE
46851 zval *container;
46852
46853 SAVE_OPLINE();
46854 container = EX_VAR(opline->op1.var);
46855 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);
46856 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46857 if (IS_CV == IS_VAR) {
46858 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
46859 }
46860 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46861}
46862
46863static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46864{
46865 USE_OPLINE
46866 zval *container;
46867
46868 SAVE_OPLINE();
46869 container = EX_VAR(opline->op1.var);
46870 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);
46871 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46872 if (IS_CV == IS_VAR) {
46873 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
46874 }
46875 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46876}
46877
46878static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46879{
46880 USE_OPLINE
46881 zval *container;
46882
46883 SAVE_OPLINE();
46884 container = EX_VAR(opline->op1.var);
46885 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);
46886 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46887
46888 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46889}
46890
46891static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46892{
46893#if 0
46894 USE_OPLINE
46895#endif
46896
46897 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
46898 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
46899 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46900 }
46901 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46902 } else {
46903 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46904 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46905 }
46906 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46907 }
46908}
46909
46910static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46911{
46912 USE_OPLINE
46913 zval *container;
46914
46915 SAVE_OPLINE();
46916 container = EX_VAR(opline->op1.var);
46917 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);
46918 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46919 if (IS_CV == IS_VAR) {
46920 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
46921 }
46922 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46923}
46924
46925static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46926{
46927 USE_OPLINE
46928 zval *container;
46929 void **cache_slot = NULL;
46930
46931 SAVE_OPLINE();
46932 container = EX_VAR(opline->op1.var);
46933
46934 if (IS_CV == IS_CONST ||
46935 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
46936 do {
46937 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
46938 container = Z_REFVAL_P(container);
46939 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
46940 break;
46941 }
46942 }
46943 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
46944 ZVAL_UNDEFINED_OP1();
46945 }
46946 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46947 ZVAL_NULL(EX_VAR(opline->result.var));
46948 goto fetch_obj_r_finish;
46949 } while (0);
46950 }
46951
46952 /* here we are sure we are dealing with an object */
46953 do {
46954 zend_object *zobj = Z_OBJ_P(container);
46955 zend_string *name, *tmp_name;
46956 zval *retval;
46957
46958 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46959 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
46960
46961 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
46962 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
46963
46964 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
46965fetch_obj_r_simple:
46966 retval = OBJ_PROP(zobj, prop_offset);
46967 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
46968 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
46969 goto fetch_obj_r_copy;
46970 } else {
46971fetch_obj_r_fast_copy:
46972 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
46973 ZEND_VM_NEXT_OPCODE();
46974 }
46975 }
46976 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
46977 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
46978 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
46979 prop_offset = prop_info->offset;
46980 goto fetch_obj_r_simple;
46981 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
46982 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
46983 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
46984 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
46985
46986 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
46987 if (IS_CV & IS_CV) {
46988 GC_ADDREF(zobj);
46989 }
46990 if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
46991 call_info |= ZEND_CALL_RELEASE_THIS;
46992 }
46993 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
46994 call->prev_execute_data = execute_data;
46995 call->call = NULL;
46996 call->return_value = EX_VAR(opline->result.var);
46997 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
46998
46999 execute_data = call;
47000 EG(current_execute_data) = execute_data;
47001 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
47002
47003#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
47004 opline = hook->op_array.opcodes;
47005#else
47006 EX(opline) = hook->op_array.opcodes;
47007#endif
47008 LOAD_OPLINE_EX();
47009
47010
47011 ZEND_VM_ENTER_EX();
47012 }
47013 /* Fall through to read_property for hooks. */
47014 } else if (EXPECTED(zobj->properties != NULL)) {
47015 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
47016 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47017 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
47018 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
47019
47020 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
47021 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
47022
47023 if (EXPECTED(p->key == name) ||
47024 (EXPECTED(p->h == ZSTR_H(name)) &&
47025 EXPECTED(p->key != NULL) &&
47026 EXPECTED(zend_string_equal_content(p->key, name)))) {
47027 retval = &p->val;
47028 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47029 goto fetch_obj_r_copy;
47030 } else {
47031 goto fetch_obj_r_fast_copy;
47032 }
47033 }
47034 }
47035 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
47036 }
47037 retval = zend_hash_find_known_hash(zobj->properties, name);
47038 if (EXPECTED(retval)) {
47039 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
47040 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
47041 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47042 goto fetch_obj_r_copy;
47043 } else {
47044 goto fetch_obj_r_fast_copy;
47045 }
47046 }
47047 }
47048 }
47049 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47050 } else {
47051 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47052 if (UNEXPECTED(!name)) {
47053 ZVAL_UNDEF(EX_VAR(opline->result.var));
47054 break;
47055 }
47056 }
47057
47058#if ZEND_DEBUG
47059 /* For non-standard object handlers, verify a declared property type in debug builds.
47060 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
47061 zend_property_info *prop_info = NULL;
47062 if (zobj->handlers->read_property != zend_std_read_property) {
47063 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
47064 }
47065#endif
47066 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
47067#if ZEND_DEBUG
47068 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
47069 && ZEND_TYPE_IS_SET(prop_info->type)) {
47070 ZVAL_OPT_DEREF(retval);
47071 zend_verify_property_type(prop_info, retval, /* strict */ true);
47072 }
47073#endif
47074
47075 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47076 zend_tmp_string_release(tmp_name);
47077 }
47078
47079 if (retval != EX_VAR(opline->result.var)) {
47080fetch_obj_r_copy:
47081 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47082 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
47083 zend_unwrap_reference(retval);
47084 }
47085 } while (0);
47086
47087fetch_obj_r_finish:
47088 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47089
47090 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47091}
47092
47093static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47094{
47095 USE_OPLINE
47096 zval *property, *container, *result;
47097
47098 SAVE_OPLINE();
47099
47100 container = EX_VAR(opline->op1.var);
47101 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47102 result = EX_VAR(opline->result.var);
47103 zend_fetch_property_address(
47104 result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR),
47105 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
47106 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
47107 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47108 if (IS_CV == IS_VAR) {
47109 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47110 }
47111 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47112}
47113
47114static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47115{
47116 USE_OPLINE
47117 zval *property, *container, *result;
47118
47119 SAVE_OPLINE();
47120 container = EX_VAR(opline->op1.var);
47121 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47122 result = EX_VAR(opline->result.var);
47123 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);
47124 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47125 if (IS_CV == IS_VAR) {
47126 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47127 }
47128 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47129}
47130
47131static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47132{
47133 USE_OPLINE
47134 zval *container;
47135 void **cache_slot = NULL;
47136
47137 SAVE_OPLINE();
47138 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
47139
47140 if (IS_CV == IS_CONST ||
47141 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
47142 do {
47143 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
47144 container = Z_REFVAL_P(container);
47145 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
47146 break;
47147 }
47148 }
47149 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
47150 ZVAL_UNDEFINED_OP2();
47151 }
47152 ZVAL_NULL(EX_VAR(opline->result.var));
47153 goto fetch_obj_is_finish;
47154 } while (0);
47155 }
47156
47157 /* here we are sure we are dealing with an object */
47158 do {
47159 zend_object *zobj = Z_OBJ_P(container);
47160 zend_string *name, *tmp_name;
47161 zval *retval;
47162
47163 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47164 cache_slot = CACHE_ADDR(opline->extended_value);
47165
47166 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
47167 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47168
47169 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47170fetch_obj_is_simple:
47171 retval = OBJ_PROP(zobj, prop_offset);
47172 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
47173 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47174 goto fetch_obj_is_copy;
47175 } else {
47176fetch_obj_is_fast_copy:
47177 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47178 ZEND_VM_NEXT_OPCODE();
47179 }
47180 }
47181 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
47182 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
47183 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
47184 prop_offset = prop_info->offset;
47185 goto fetch_obj_is_simple;
47186 }
47187 /* Fall through to read_property for hooks. */
47188 } else if (EXPECTED(zobj->properties != NULL)) {
47189 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
47190 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47191 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
47192 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
47193
47194 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
47195 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
47196
47197 if (EXPECTED(p->key == name) ||
47198 (EXPECTED(p->h == ZSTR_H(name)) &&
47199 EXPECTED(p->key != NULL) &&
47200 EXPECTED(zend_string_equal_content(p->key, name)))) {
47201 retval = &p->val;
47202 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47203 goto fetch_obj_is_copy;
47204 } else {
47205 goto fetch_obj_is_fast_copy;
47206 }
47207 }
47208 }
47209 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
47210 }
47211 retval = zend_hash_find_known_hash(zobj->properties, name);
47212 if (EXPECTED(retval)) {
47213 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
47214 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
47215 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47216 goto fetch_obj_is_copy;
47217 } else {
47218 goto fetch_obj_is_fast_copy;
47219 }
47220 }
47221 }
47222 }
47223 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47224 } else {
47225 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47226 if (UNEXPECTED(!name)) {
47227 ZVAL_UNDEF(EX_VAR(opline->result.var));
47228 break;
47229 }
47230 }
47231
47232 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
47233
47234 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47235 zend_tmp_string_release(tmp_name);
47236 }
47237
47238 if (retval != EX_VAR(opline->result.var)) {
47239fetch_obj_is_copy:
47240 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47241 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
47242 zend_unwrap_reference(retval);
47243 }
47244 } while (0);
47245
47246fetch_obj_is_finish:
47247 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47248
47249 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47250}
47251
47252static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47253{
47254#if 0
47255 USE_OPLINE
47256#endif
47257
47258 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
47259 /* Behave like FETCH_OBJ_W */
47260 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
47261 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47262 }
47263 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47264 } else {
47265 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47266 }
47267}
47268
47269static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47270{
47271 USE_OPLINE
47272 zval *container, *property, *result;
47273
47274 SAVE_OPLINE();
47275 container = EX_VAR(opline->op1.var);
47276 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47277 result = EX_VAR(opline->result.var);
47278 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);
47279 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47280 if (IS_CV == IS_VAR) {
47281 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47282 }
47283 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47284}
47285
47286static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47287{
47288 USE_OPLINE
47289 zval *object, *value, tmp;
47290 zend_object *zobj;
47291 zend_string *name, *tmp_name;
47292 zend_refcounted *garbage = NULL;
47293
47294 SAVE_OPLINE();
47295 object = EX_VAR(opline->op1.var);
47296 value = RT_CONSTANT((opline+1), (opline+1)->op1);
47297
47298 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47299 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47300 object = Z_REFVAL_P(object);
47301 goto assign_object;
47302 }
47303 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47304 value = &EG(uninitialized_zval);
47305 goto free_and_exit_assign_obj;
47306 }
47307
47308assign_object:
47309 zobj = Z_OBJ_P(object);
47310 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47311 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47312 void **cache_slot = CACHE_ADDR(opline->extended_value);
47313 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47314 zval *property_val;
47315 zend_property_info *prop_info;
47316
47317 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47318 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47319
47320assign_obj_simple:
47321 property_val = OBJ_PROP(zobj, prop_offset);
47322 if (Z_TYPE_P(property_val) != IS_UNDEF) {
47323 if (prop_info != NULL) {
47324 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47325 goto free_and_exit_assign_obj;
47326 } else {
47327fast_assign_obj:
47328 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
47329 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47330 ZVAL_COPY(EX_VAR(opline->result.var), value);
47331 }
47332 goto exit_assign_obj;
47333 }
47334 }
47335 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47336 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47337 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47338 zobj = zend_lazy_object_init(zobj);
47339 if (!zobj) {
47340 value = &EG(uninitialized_zval);
47341 goto free_and_exit_assign_obj;
47342 }
47343 }
47344 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47345 rebuild_object_properties_internal(zobj);
47346 }
47347 if (EXPECTED(zobj->properties != NULL)) {
47348 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47349 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47350 GC_DELREF(zobj->properties);
47351 }
47352 zobj->properties = zend_array_dup(zobj->properties);
47353 }
47354 property_val = zend_hash_find_known_hash(zobj->properties, name);
47355 if (property_val) {
47356 goto fast_assign_obj;
47357 }
47358 }
47359
47360 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47361 if (IS_CONST == IS_CONST) {
47362 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47363 Z_ADDREF_P(value);
47364 }
47365 } else if (IS_CONST != IS_TMP_VAR) {
47366 if (Z_ISREF_P(value)) {
47367 if (IS_CONST == IS_VAR) {
47368 zend_reference *ref = Z_REF_P(value);
47369 if (GC_DELREF(ref) == 0) {
47370 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47371 efree_size(ref, sizeof(zend_reference));
47372 value = &tmp;
47373 } else {
47374 value = Z_REFVAL_P(value);
47375 Z_TRY_ADDREF_P(value);
47376 }
47377 } else {
47378 value = Z_REFVAL_P(value);
47379 Z_TRY_ADDREF_P(value);
47380 }
47381 } else if (IS_CONST == IS_CV) {
47382 Z_TRY_ADDREF_P(value);
47383 }
47384 }
47385 zend_hash_add_new(zobj->properties, name, value);
47386 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47387 ZVAL_COPY(EX_VAR(opline->result.var), value);
47388 }
47389 goto exit_assign_obj;
47390 }
47391 } else {
47392 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47393 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47394 prop_info = CACHED_PTR_EX(cache_slot + 2);
47395 prop_offset = prop_info->offset;
47396 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47397 prop_info = NULL;
47398 }
47399 goto assign_obj_simple;
47400 }
47401 /* Fall through to write_property for hooks. */
47402 }
47403 }
47404 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47405 } else {
47406 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47407 if (UNEXPECTED(!name)) {
47408
47409 UNDEF_RESULT();
47410 goto exit_assign_obj;
47411 }
47412 }
47413
47414 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
47415 ZVAL_DEREF(value);
47416 }
47417
47418 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47419
47420 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47421 zend_tmp_string_release(tmp_name);
47422 }
47423
47424free_and_exit_assign_obj:
47425 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47426 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47427 }
47428
47429exit_assign_obj:
47430 if (garbage) {
47431 GC_DTOR_NO_REF(garbage);
47432 }
47433 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47434
47435 /* assign_obj has two opcodes! */
47436 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47437}
47438
47439/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47440static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47441{
47442 USE_OPLINE
47443 zval *object, *value, tmp;
47444 zend_object *zobj;
47445 zend_string *name, *tmp_name;
47446 zend_refcounted *garbage = NULL;
47447
47448 SAVE_OPLINE();
47449 object = EX_VAR(opline->op1.var);
47450 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
47451
47452 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47453 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47454 object = Z_REFVAL_P(object);
47455 goto assign_object;
47456 }
47457 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47458 value = &EG(uninitialized_zval);
47459 goto free_and_exit_assign_obj;
47460 }
47461
47462assign_object:
47463 zobj = Z_OBJ_P(object);
47464 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47465 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47466 void **cache_slot = CACHE_ADDR(opline->extended_value);
47467 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47468 zval *property_val;
47469 zend_property_info *prop_info;
47470
47471 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47472 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47473
47474assign_obj_simple:
47475 property_val = OBJ_PROP(zobj, prop_offset);
47476 if (Z_TYPE_P(property_val) != IS_UNDEF) {
47477 if (prop_info != NULL) {
47478 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47479 goto free_and_exit_assign_obj;
47480 } else {
47481fast_assign_obj:
47482 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
47483 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47484 ZVAL_COPY(EX_VAR(opline->result.var), value);
47485 }
47486 goto exit_assign_obj;
47487 }
47488 }
47489 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47490 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47491 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47492 zobj = zend_lazy_object_init(zobj);
47493 if (!zobj) {
47494 value = &EG(uninitialized_zval);
47495 goto free_and_exit_assign_obj;
47496 }
47497 }
47498 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47499 rebuild_object_properties_internal(zobj);
47500 }
47501 if (EXPECTED(zobj->properties != NULL)) {
47502 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47503 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47504 GC_DELREF(zobj->properties);
47505 }
47506 zobj->properties = zend_array_dup(zobj->properties);
47507 }
47508 property_val = zend_hash_find_known_hash(zobj->properties, name);
47509 if (property_val) {
47510 goto fast_assign_obj;
47511 }
47512 }
47513
47514 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47515 if (IS_TMP_VAR == IS_CONST) {
47516 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47517 Z_ADDREF_P(value);
47518 }
47519 } else if (IS_TMP_VAR != IS_TMP_VAR) {
47520 if (Z_ISREF_P(value)) {
47521 if (IS_TMP_VAR == IS_VAR) {
47522 zend_reference *ref = Z_REF_P(value);
47523 if (GC_DELREF(ref) == 0) {
47524 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47525 efree_size(ref, sizeof(zend_reference));
47526 value = &tmp;
47527 } else {
47528 value = Z_REFVAL_P(value);
47529 Z_TRY_ADDREF_P(value);
47530 }
47531 } else {
47532 value = Z_REFVAL_P(value);
47533 Z_TRY_ADDREF_P(value);
47534 }
47535 } else if (IS_TMP_VAR == IS_CV) {
47536 Z_TRY_ADDREF_P(value);
47537 }
47538 }
47539 zend_hash_add_new(zobj->properties, name, value);
47540 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47541 ZVAL_COPY(EX_VAR(opline->result.var), value);
47542 }
47543 goto exit_assign_obj;
47544 }
47545 } else {
47546 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47547 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47548 prop_info = CACHED_PTR_EX(cache_slot + 2);
47549 prop_offset = prop_info->offset;
47550 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47551 prop_info = NULL;
47552 }
47553 goto assign_obj_simple;
47554 }
47555 /* Fall through to write_property for hooks. */
47556 }
47557 }
47558 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47559 } else {
47560 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47561 if (UNEXPECTED(!name)) {
47562 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47563 UNDEF_RESULT();
47564 goto exit_assign_obj;
47565 }
47566 }
47567
47568 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
47569 ZVAL_DEREF(value);
47570 }
47571
47572 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47573
47574 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47575 zend_tmp_string_release(tmp_name);
47576 }
47577
47578free_and_exit_assign_obj:
47579 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47580 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47581 }
47582 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47583exit_assign_obj:
47584 if (garbage) {
47585 GC_DTOR_NO_REF(garbage);
47586 }
47587 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47588
47589 /* assign_obj has two opcodes! */
47590 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47591}
47592
47593/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47594static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47595{
47596 USE_OPLINE
47597 zval *object, *value, tmp;
47598 zend_object *zobj;
47599 zend_string *name, *tmp_name;
47600 zend_refcounted *garbage = NULL;
47601
47602 SAVE_OPLINE();
47603 object = EX_VAR(opline->op1.var);
47604 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
47605
47606 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47607 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47608 object = Z_REFVAL_P(object);
47609 goto assign_object;
47610 }
47611 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47612 value = &EG(uninitialized_zval);
47613 goto free_and_exit_assign_obj;
47614 }
47615
47616assign_object:
47617 zobj = Z_OBJ_P(object);
47618 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47619 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47620 void **cache_slot = CACHE_ADDR(opline->extended_value);
47621 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47622 zval *property_val;
47623 zend_property_info *prop_info;
47624
47625 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47626 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47627
47628assign_obj_simple:
47629 property_val = OBJ_PROP(zobj, prop_offset);
47630 if (Z_TYPE_P(property_val) != IS_UNDEF) {
47631 if (prop_info != NULL) {
47632 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47633 goto free_and_exit_assign_obj;
47634 } else {
47635fast_assign_obj:
47636 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
47637 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47638 ZVAL_COPY(EX_VAR(opline->result.var), value);
47639 }
47640 goto exit_assign_obj;
47641 }
47642 }
47643 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47644 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47645 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47646 zobj = zend_lazy_object_init(zobj);
47647 if (!zobj) {
47648 value = &EG(uninitialized_zval);
47649 goto free_and_exit_assign_obj;
47650 }
47651 }
47652 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47653 rebuild_object_properties_internal(zobj);
47654 }
47655 if (EXPECTED(zobj->properties != NULL)) {
47656 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47657 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47658 GC_DELREF(zobj->properties);
47659 }
47660 zobj->properties = zend_array_dup(zobj->properties);
47661 }
47662 property_val = zend_hash_find_known_hash(zobj->properties, name);
47663 if (property_val) {
47664 goto fast_assign_obj;
47665 }
47666 }
47667
47668 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47669 if (IS_VAR == IS_CONST) {
47670 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47671 Z_ADDREF_P(value);
47672 }
47673 } else if (IS_VAR != IS_TMP_VAR) {
47674 if (Z_ISREF_P(value)) {
47675 if (IS_VAR == IS_VAR) {
47676 zend_reference *ref = Z_REF_P(value);
47677 if (GC_DELREF(ref) == 0) {
47678 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47679 efree_size(ref, sizeof(zend_reference));
47680 value = &tmp;
47681 } else {
47682 value = Z_REFVAL_P(value);
47683 Z_TRY_ADDREF_P(value);
47684 }
47685 } else {
47686 value = Z_REFVAL_P(value);
47687 Z_TRY_ADDREF_P(value);
47688 }
47689 } else if (IS_VAR == IS_CV) {
47690 Z_TRY_ADDREF_P(value);
47691 }
47692 }
47693 zend_hash_add_new(zobj->properties, name, value);
47694 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47695 ZVAL_COPY(EX_VAR(opline->result.var), value);
47696 }
47697 goto exit_assign_obj;
47698 }
47699 } else {
47700 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47701 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47702 prop_info = CACHED_PTR_EX(cache_slot + 2);
47703 prop_offset = prop_info->offset;
47704 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47705 prop_info = NULL;
47706 }
47707 goto assign_obj_simple;
47708 }
47709 /* Fall through to write_property for hooks. */
47710 }
47711 }
47712 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47713 } else {
47714 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47715 if (UNEXPECTED(!name)) {
47716 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47717 UNDEF_RESULT();
47718 goto exit_assign_obj;
47719 }
47720 }
47721
47722 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
47723 ZVAL_DEREF(value);
47724 }
47725
47726 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47727
47728 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47729 zend_tmp_string_release(tmp_name);
47730 }
47731
47732free_and_exit_assign_obj:
47733 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47734 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47735 }
47736 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47737exit_assign_obj:
47738 if (garbage) {
47739 GC_DTOR_NO_REF(garbage);
47740 }
47741 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47742
47743 /* assign_obj has two opcodes! */
47744 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47745}
47746
47747/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47748static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47749{
47750 USE_OPLINE
47751 zval *object, *value, tmp;
47752 zend_object *zobj;
47753 zend_string *name, *tmp_name;
47754 zend_refcounted *garbage = NULL;
47755
47756 SAVE_OPLINE();
47757 object = EX_VAR(opline->op1.var);
47758 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
47759
47760 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47761 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47762 object = Z_REFVAL_P(object);
47763 goto assign_object;
47764 }
47765 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47766 value = &EG(uninitialized_zval);
47767 goto free_and_exit_assign_obj;
47768 }
47769
47770assign_object:
47771 zobj = Z_OBJ_P(object);
47772 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47773 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47774 void **cache_slot = CACHE_ADDR(opline->extended_value);
47775 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47776 zval *property_val;
47777 zend_property_info *prop_info;
47778
47779 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47780 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47781
47782assign_obj_simple:
47783 property_val = OBJ_PROP(zobj, prop_offset);
47784 if (Z_TYPE_P(property_val) != IS_UNDEF) {
47785 if (prop_info != NULL) {
47786 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47787 goto free_and_exit_assign_obj;
47788 } else {
47789fast_assign_obj:
47790 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
47791 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47792 ZVAL_COPY(EX_VAR(opline->result.var), value);
47793 }
47794 goto exit_assign_obj;
47795 }
47796 }
47797 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47798 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47799 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47800 zobj = zend_lazy_object_init(zobj);
47801 if (!zobj) {
47802 value = &EG(uninitialized_zval);
47803 goto free_and_exit_assign_obj;
47804 }
47805 }
47806 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47807 rebuild_object_properties_internal(zobj);
47808 }
47809 if (EXPECTED(zobj->properties != NULL)) {
47810 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47811 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47812 GC_DELREF(zobj->properties);
47813 }
47814 zobj->properties = zend_array_dup(zobj->properties);
47815 }
47816 property_val = zend_hash_find_known_hash(zobj->properties, name);
47817 if (property_val) {
47818 goto fast_assign_obj;
47819 }
47820 }
47821
47822 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47823 if (IS_CV == IS_CONST) {
47824 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47825 Z_ADDREF_P(value);
47826 }
47827 } else if (IS_CV != IS_TMP_VAR) {
47828 if (Z_ISREF_P(value)) {
47829 if (IS_CV == IS_VAR) {
47830 zend_reference *ref = Z_REF_P(value);
47831 if (GC_DELREF(ref) == 0) {
47832 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47833 efree_size(ref, sizeof(zend_reference));
47834 value = &tmp;
47835 } else {
47836 value = Z_REFVAL_P(value);
47837 Z_TRY_ADDREF_P(value);
47838 }
47839 } else {
47840 value = Z_REFVAL_P(value);
47841 Z_TRY_ADDREF_P(value);
47842 }
47843 } else if (IS_CV == IS_CV) {
47844 Z_TRY_ADDREF_P(value);
47845 }
47846 }
47847 zend_hash_add_new(zobj->properties, name, value);
47848 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47849 ZVAL_COPY(EX_VAR(opline->result.var), value);
47850 }
47851 goto exit_assign_obj;
47852 }
47853 } else {
47854 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47855 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47856 prop_info = CACHED_PTR_EX(cache_slot + 2);
47857 prop_offset = prop_info->offset;
47858 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
47859 prop_info = NULL;
47860 }
47861 goto assign_obj_simple;
47862 }
47863 /* Fall through to write_property for hooks. */
47864 }
47865 }
47866 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47867 } else {
47868 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47869 if (UNEXPECTED(!name)) {
47870
47871 UNDEF_RESULT();
47872 goto exit_assign_obj;
47873 }
47874 }
47875
47876 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
47877 ZVAL_DEREF(value);
47878 }
47879
47880 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47881
47882 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47883 zend_tmp_string_release(tmp_name);
47884 }
47885
47886free_and_exit_assign_obj:
47887 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47888 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47889 }
47890
47891exit_assign_obj:
47892 if (garbage) {
47893 GC_DTOR_NO_REF(garbage);
47894 }
47895 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47896
47897 /* assign_obj has two opcodes! */
47898 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47899}
47900
47901/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
47902static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47903{
47904 USE_OPLINE
47905 zval *object_ptr, *orig_object_ptr;
47906 zval *value;
47907 zval *variable_ptr;
47908 zval *dim;
47909 zend_refcounted *garbage = NULL;
47910
47911 SAVE_OPLINE();
47912 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
47913
47914 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
47915try_assign_dim_array:
47916 SEPARATE_ARRAY(object_ptr);
47917 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
47918 value = RT_CONSTANT((opline+1), (opline+1)->op1);
47919 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
47920 HashTable *ht = Z_ARRVAL_P(object_ptr);
47921 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
47922 GC_ADDREF(ht);
47923 }
47924 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
47925 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
47926 zend_array_destroy(ht);
47927 goto assign_dim_error;
47928 }
47929 }
47930 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
47931 ZVAL_DEREF(value);
47932 }
47933 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
47934 if (UNEXPECTED(value == NULL)) {
47935 zend_cannot_add_element();
47936 goto assign_dim_error;
47937 } else if (IS_CONST == IS_CV) {
47938 if (Z_REFCOUNTED_P(value)) {
47939 Z_ADDREF_P(value);
47940 }
47941 } else if (IS_CONST == IS_VAR) {
47942 zval *free_op_data = EX_VAR((opline+1)->op1.var);
47943 if (Z_ISREF_P(free_op_data)) {
47944 if (Z_REFCOUNTED_P(value)) {
47945 Z_ADDREF_P(value);
47946 }
47947 zval_ptr_dtor_nogc(free_op_data);
47948 }
47949 } else if (IS_CONST == IS_CONST) {
47950 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
47951 Z_ADDREF_P(value);
47952 }
47953 }
47954 } else {
47955 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47956 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47957 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
47958 } else {
47959 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
47960 }
47961 if (UNEXPECTED(variable_ptr == NULL)) {
47962 goto assign_dim_error;
47963 }
47964 value = RT_CONSTANT((opline+1), (opline+1)->op1);
47965 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
47966 }
47967 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47968 ZVAL_COPY(EX_VAR(opline->result.var), value);
47969 }
47970 if (garbage) {
47971 GC_DTOR_NO_REF(garbage);
47972 }
47973 } else {
47974 if (EXPECTED(Z_ISREF_P(object_ptr))) {
47975 object_ptr = Z_REFVAL_P(object_ptr);
47976 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
47977 goto try_assign_dim_array;
47978 }
47979 }
47980 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
47981 zend_object *obj = Z_OBJ_P(object_ptr);
47982
47983 GC_ADDREF(obj);
47984 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47985 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
47986 dim = ZVAL_UNDEFINED_OP2();
47987 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
47988 dim++;
47989 }
47990
47991 value = RT_CONSTANT((opline+1), (opline+1)->op1);
47992 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
47993 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
47994 } else if (IS_CONST & (IS_CV|IS_VAR)) {
47995 ZVAL_DEREF(value);
47996 }
47997
47998 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
47999
48000 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48001 zend_objects_store_del(obj);
48002 }
48003 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48004 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48005 zend_use_new_element_for_string();
48006
48007 UNDEF_RESULT();
48008 } else {
48009 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48010 value = RT_CONSTANT((opline+1), (opline+1)->op1);
48011 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48012
48013 }
48014 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48015 if (Z_ISREF_P(orig_object_ptr)
48016 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48017 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48018 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48019
48020 UNDEF_RESULT();
48021 } else {
48022 HashTable *ht = zend_new_array(8);
48023 uint8_t old_type = Z_TYPE_P(object_ptr);
48024
48025 ZVAL_ARR(object_ptr, ht);
48026 if (UNEXPECTED(old_type == IS_FALSE)) {
48027 GC_ADDREF(ht);
48028 zend_false_to_array_deprecated();
48029 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48030 zend_array_destroy(ht);
48031 goto assign_dim_error;
48032 }
48033 }
48034 goto try_assign_dim_array;
48035 }
48036 } else {
48037 zend_use_scalar_as_array();
48038 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48039assign_dim_error:
48040
48041 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48042 ZVAL_NULL(EX_VAR(opline->result.var));
48043 }
48044 }
48045 }
48046 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48047 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48048 }
48049
48050 /* assign_dim has two opcodes! */
48051 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48052}
48053
48054static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48055{
48056 USE_OPLINE
48057 zval *object_ptr, *orig_object_ptr;
48058 zval *value;
48059 zval *variable_ptr;
48060 zval *dim;
48061 zend_refcounted *garbage = NULL;
48062
48063 SAVE_OPLINE();
48064 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48065
48066 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48067try_assign_dim_array:
48068 SEPARATE_ARRAY(object_ptr);
48069 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48070 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48071 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48072 HashTable *ht = Z_ARRVAL_P(object_ptr);
48073 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48074 GC_ADDREF(ht);
48075 }
48076 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48077 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48078 zend_array_destroy(ht);
48079 goto assign_dim_error;
48080 }
48081 }
48082 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
48083 ZVAL_DEREF(value);
48084 }
48085 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48086 if (UNEXPECTED(value == NULL)) {
48087 zend_cannot_add_element();
48088 goto assign_dim_error;
48089 } else if (IS_TMP_VAR == IS_CV) {
48090 if (Z_REFCOUNTED_P(value)) {
48091 Z_ADDREF_P(value);
48092 }
48093 } else if (IS_TMP_VAR == IS_VAR) {
48094 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48095 if (Z_ISREF_P(free_op_data)) {
48096 if (Z_REFCOUNTED_P(value)) {
48097 Z_ADDREF_P(value);
48098 }
48099 zval_ptr_dtor_nogc(free_op_data);
48100 }
48101 } else if (IS_TMP_VAR == IS_CONST) {
48102 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48103 Z_ADDREF_P(value);
48104 }
48105 }
48106 } else {
48107 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48108 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48109 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48110 } else {
48111 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48112 }
48113 if (UNEXPECTED(variable_ptr == NULL)) {
48114 goto assign_dim_error;
48115 }
48116 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48117 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
48118 }
48119 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48120 ZVAL_COPY(EX_VAR(opline->result.var), value);
48121 }
48122 if (garbage) {
48123 GC_DTOR_NO_REF(garbage);
48124 }
48125 } else {
48126 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48127 object_ptr = Z_REFVAL_P(object_ptr);
48128 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48129 goto try_assign_dim_array;
48130 }
48131 }
48132 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48133 zend_object *obj = Z_OBJ_P(object_ptr);
48134
48135 GC_ADDREF(obj);
48136 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48137 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48138 dim = ZVAL_UNDEFINED_OP2();
48139 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48140 dim++;
48141 }
48142
48143 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48144 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48145 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48146 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
48147 ZVAL_DEREF(value);
48148 }
48149
48150 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48151
48152 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48153 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48154 zend_objects_store_del(obj);
48155 }
48156 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48157 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48158 zend_use_new_element_for_string();
48159 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48160 UNDEF_RESULT();
48161 } else {
48162 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48163 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48164 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48165 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48166 }
48167 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48168 if (Z_ISREF_P(orig_object_ptr)
48169 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48170 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48171 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48172 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48173 UNDEF_RESULT();
48174 } else {
48175 HashTable *ht = zend_new_array(8);
48176 uint8_t old_type = Z_TYPE_P(object_ptr);
48177
48178 ZVAL_ARR(object_ptr, ht);
48179 if (UNEXPECTED(old_type == IS_FALSE)) {
48180 GC_ADDREF(ht);
48181 zend_false_to_array_deprecated();
48182 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48183 zend_array_destroy(ht);
48184 goto assign_dim_error;
48185 }
48186 }
48187 goto try_assign_dim_array;
48188 }
48189 } else {
48190 zend_use_scalar_as_array();
48191 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48192assign_dim_error:
48193 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48194 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48195 ZVAL_NULL(EX_VAR(opline->result.var));
48196 }
48197 }
48198 }
48199 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48200 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48201 }
48202
48203 /* assign_dim has two opcodes! */
48204 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48205}
48206
48207static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48208{
48209 USE_OPLINE
48210 zval *object_ptr, *orig_object_ptr;
48211 zval *value;
48212 zval *variable_ptr;
48213 zval *dim;
48214 zend_refcounted *garbage = NULL;
48215
48216 SAVE_OPLINE();
48217 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48218
48219 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48220try_assign_dim_array:
48221 SEPARATE_ARRAY(object_ptr);
48222 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48223 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48224 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48225 HashTable *ht = Z_ARRVAL_P(object_ptr);
48226 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48227 GC_ADDREF(ht);
48228 }
48229 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48230 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48231 zend_array_destroy(ht);
48232 goto assign_dim_error;
48233 }
48234 }
48235 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
48236 ZVAL_DEREF(value);
48237 }
48238 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48239 if (UNEXPECTED(value == NULL)) {
48240 zend_cannot_add_element();
48241 goto assign_dim_error;
48242 } else if (IS_VAR == IS_CV) {
48243 if (Z_REFCOUNTED_P(value)) {
48244 Z_ADDREF_P(value);
48245 }
48246 } else if (IS_VAR == IS_VAR) {
48247 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48248 if (Z_ISREF_P(free_op_data)) {
48249 if (Z_REFCOUNTED_P(value)) {
48250 Z_ADDREF_P(value);
48251 }
48252 zval_ptr_dtor_nogc(free_op_data);
48253 }
48254 } else if (IS_VAR == IS_CONST) {
48255 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48256 Z_ADDREF_P(value);
48257 }
48258 }
48259 } else {
48260 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48261 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48262 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48263 } else {
48264 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48265 }
48266 if (UNEXPECTED(variable_ptr == NULL)) {
48267 goto assign_dim_error;
48268 }
48269 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48270 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
48271 }
48272 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48273 ZVAL_COPY(EX_VAR(opline->result.var), value);
48274 }
48275 if (garbage) {
48276 GC_DTOR_NO_REF(garbage);
48277 }
48278 } else {
48279 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48280 object_ptr = Z_REFVAL_P(object_ptr);
48281 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48282 goto try_assign_dim_array;
48283 }
48284 }
48285 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48286 zend_object *obj = Z_OBJ_P(object_ptr);
48287
48288 GC_ADDREF(obj);
48289 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48290 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48291 dim = ZVAL_UNDEFINED_OP2();
48292 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48293 dim++;
48294 }
48295
48296 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48297 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48298 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48299 } else if (IS_VAR & (IS_CV|IS_VAR)) {
48300 ZVAL_DEREF(value);
48301 }
48302
48303 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48304
48305 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48306 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48307 zend_objects_store_del(obj);
48308 }
48309 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48310 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48311 zend_use_new_element_for_string();
48312 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48313 UNDEF_RESULT();
48314 } else {
48315 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48316 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48317 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48318 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48319 }
48320 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48321 if (Z_ISREF_P(orig_object_ptr)
48322 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48323 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48324 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48325 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48326 UNDEF_RESULT();
48327 } else {
48328 HashTable *ht = zend_new_array(8);
48329 uint8_t old_type = Z_TYPE_P(object_ptr);
48330
48331 ZVAL_ARR(object_ptr, ht);
48332 if (UNEXPECTED(old_type == IS_FALSE)) {
48333 GC_ADDREF(ht);
48334 zend_false_to_array_deprecated();
48335 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48336 zend_array_destroy(ht);
48337 goto assign_dim_error;
48338 }
48339 }
48340 goto try_assign_dim_array;
48341 }
48342 } else {
48343 zend_use_scalar_as_array();
48344 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48345assign_dim_error:
48346 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48347 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48348 ZVAL_NULL(EX_VAR(opline->result.var));
48349 }
48350 }
48351 }
48352 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48353 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48354 }
48355
48356 /* assign_dim has two opcodes! */
48357 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48358}
48359
48360static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48361{
48362 USE_OPLINE
48363 zval *object_ptr, *orig_object_ptr;
48364 zval *value;
48365 zval *variable_ptr;
48366 zval *dim;
48367 zend_refcounted *garbage = NULL;
48368
48369 SAVE_OPLINE();
48370 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48371
48372 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48373try_assign_dim_array:
48374 SEPARATE_ARRAY(object_ptr);
48375 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48376 value = EX_VAR((opline+1)->op1.var);
48377 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48378 HashTable *ht = Z_ARRVAL_P(object_ptr);
48379 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48380 GC_ADDREF(ht);
48381 }
48382 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48383 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48384 zend_array_destroy(ht);
48385 goto assign_dim_error;
48386 }
48387 }
48388 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
48389 ZVAL_DEREF(value);
48390 }
48391 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48392 if (UNEXPECTED(value == NULL)) {
48393 zend_cannot_add_element();
48394 goto assign_dim_error;
48395 } else if (IS_CV == IS_CV) {
48396 if (Z_REFCOUNTED_P(value)) {
48397 Z_ADDREF_P(value);
48398 }
48399 } else if (IS_CV == IS_VAR) {
48400 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48401 if (Z_ISREF_P(free_op_data)) {
48402 if (Z_REFCOUNTED_P(value)) {
48403 Z_ADDREF_P(value);
48404 }
48405 zval_ptr_dtor_nogc(free_op_data);
48406 }
48407 } else if (IS_CV == IS_CONST) {
48408 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48409 Z_ADDREF_P(value);
48410 }
48411 }
48412 } else {
48413 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48414 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48415 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48416 } else {
48417 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48418 }
48419 if (UNEXPECTED(variable_ptr == NULL)) {
48420 goto assign_dim_error;
48421 }
48422 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
48423 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
48424 }
48425 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48426 ZVAL_COPY(EX_VAR(opline->result.var), value);
48427 }
48428 if (garbage) {
48429 GC_DTOR_NO_REF(garbage);
48430 }
48431 } else {
48432 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48433 object_ptr = Z_REFVAL_P(object_ptr);
48434 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48435 goto try_assign_dim_array;
48436 }
48437 }
48438 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48439 zend_object *obj = Z_OBJ_P(object_ptr);
48440
48441 GC_ADDREF(obj);
48442 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48443 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48444 dim = ZVAL_UNDEFINED_OP2();
48445 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48446 dim++;
48447 }
48448
48449 value = EX_VAR((opline+1)->op1.var);
48450 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48451 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48452 } else if (IS_CV & (IS_CV|IS_VAR)) {
48453 ZVAL_DEREF(value);
48454 }
48455
48456 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48457
48458 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48459 zend_objects_store_del(obj);
48460 }
48461 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48462 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48463 zend_use_new_element_for_string();
48464
48465 UNDEF_RESULT();
48466 } else {
48467 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48468 value = EX_VAR((opline+1)->op1.var);
48469 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48470
48471 }
48472 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48473 if (Z_ISREF_P(orig_object_ptr)
48474 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48475 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48476 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48477
48478 UNDEF_RESULT();
48479 } else {
48480 HashTable *ht = zend_new_array(8);
48481 uint8_t old_type = Z_TYPE_P(object_ptr);
48482
48483 ZVAL_ARR(object_ptr, ht);
48484 if (UNEXPECTED(old_type == IS_FALSE)) {
48485 GC_ADDREF(ht);
48486 zend_false_to_array_deprecated();
48487 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48488 zend_array_destroy(ht);
48489 goto assign_dim_error;
48490 }
48491 }
48492 goto try_assign_dim_array;
48493 }
48494 } else {
48495 zend_use_scalar_as_array();
48496 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48497assign_dim_error:
48498
48499 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48500 ZVAL_NULL(EX_VAR(opline->result.var));
48501 }
48502 }
48503 }
48504 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48505 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48506 }
48507
48508 /* assign_dim has two opcodes! */
48509 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48510}
48511
48512static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48513{
48514 USE_OPLINE
48515 zval *property, *container, *value_ptr;
48516
48517 SAVE_OPLINE();
48518
48519 container = EX_VAR(opline->op1.var);
48520 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48521
48522 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48523
48524 if (1) {
48525 if (IS_CV == IS_UNUSED) {
48526 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48527 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48528 } else {
48529 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48530 }
48531 } else {
48532 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48533 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48534 } else {
48535 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48536 }
48537 }
48538 } else {
48539 zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
48540 }
48541
48542 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48543 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48544 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48545}
48546
48547/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
48548static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48549{
48550 USE_OPLINE
48551 zval *property, *container, *value_ptr;
48552
48553 SAVE_OPLINE();
48554
48555 container = EX_VAR(opline->op1.var);
48556 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48557
48558 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
48559
48560 if (1) {
48561 if (IS_CV == IS_UNUSED) {
48562 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48563 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48564 } else {
48565 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48566 }
48567 } else {
48568 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48569 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48570 } else {
48571 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48572 }
48573 }
48574 } else {
48575 zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
48576 }
48577
48578 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48579
48580 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48581}
48582
48583/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
48584static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48585{
48586 USE_OPLINE
48587 zval *op1, *op2;
48588 zend_string *op1_str, *op2_str, *str;
48589
48590
48591 op1 = EX_VAR(opline->op1.var);
48592 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48593 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
48594 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
48595 zend_string *op1_str = Z_STR_P(op1);
48596 zend_string *op2_str = Z_STR_P(op2);
48597 zend_string *str;
48598 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
48599
48600 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
48601 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
48602 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
48603 } else {
48604 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
48605 }
48606 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
48607 zend_string_release_ex(op1_str, 0);
48608 }
48609 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
48610 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
48611 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
48612 } else {
48613 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
48614 }
48615 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48616 zend_string_release_ex(op2_str, 0);
48617 }
48618 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
48619 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
48620 size_t len = ZSTR_LEN(op1_str);
48621
48622 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
48623 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48624 GC_ADD_FLAGS(str, flags);
48625 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48626 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48627 zend_string_release_ex(op2_str, 0);
48628 }
48629 } else {
48630 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
48631 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
48632 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48633 GC_ADD_FLAGS(str, flags);
48634 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48635 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
48636 zend_string_release_ex(op1_str, 0);
48637 }
48638 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48639 zend_string_release_ex(op2_str, 0);
48640 }
48641 }
48642 ZEND_VM_NEXT_OPCODE();
48643 }
48644
48645 SAVE_OPLINE();
48646 if (IS_CV == IS_CONST) {
48647 op1_str = Z_STR_P(op1);
48648 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
48649 op1_str = zend_string_copy(Z_STR_P(op1));
48650 } else {
48651 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
48652 ZVAL_UNDEFINED_OP1();
48653 }
48654 op1_str = zval_get_string_func(op1);
48655 }
48656 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48657 op2_str = Z_STR_P(op2);
48658 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
48659 op2_str = zend_string_copy(Z_STR_P(op2));
48660 } else {
48661 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
48662 ZVAL_UNDEFINED_OP2();
48663 }
48664 op2_str = zval_get_string_func(op2);
48665 }
48666 do {
48667 if (IS_CV != IS_CONST) {
48668 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
48669 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48670 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
48671 GC_ADDREF(op2_str);
48672 }
48673 }
48674 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
48675 zend_string_release_ex(op1_str, 0);
48676 break;
48677 }
48678 }
48679 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48680 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
48681 if (IS_CV == IS_CONST) {
48682 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
48683 GC_ADDREF(op1_str);
48684 }
48685 }
48686 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
48687 zend_string_release_ex(op2_str, 0);
48688 break;
48689 }
48690 }
48691 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
48692 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
48693 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48694
48695 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
48696 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48697 if (IS_CV != IS_CONST) {
48698 zend_string_release_ex(op1_str, 0);
48699 }
48700 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48701 zend_string_release_ex(op2_str, 0);
48702 }
48703 } while (0);
48704
48705 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48706 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48707}
48708
48709static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48710{
48711 USE_OPLINE
48712 zval *function_name;
48713 zval *object;
48714 zend_function *fbc;
48715 zend_class_entry *called_scope;
48716 zend_object *obj;
48717 zend_execute_data *call;
48718 uint32_t call_info;
48719
48720 SAVE_OPLINE();
48721
48722 object = EX_VAR(opline->op1.var);
48723
48724 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48725 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48726 }
48727
48728 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
48729 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
48730 do {
48731 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
48732 function_name = Z_REFVAL_P(function_name);
48733 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
48734 break;
48735 }
48736 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
48737 ZVAL_UNDEFINED_OP2();
48738 if (UNEXPECTED(EG(exception) != NULL)) {
48739
48740 HANDLE_EXCEPTION();
48741 }
48742 }
48743 zend_throw_error(NULL, "Method name must be a string");
48744 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48745
48746 HANDLE_EXCEPTION();
48747 } while (0);
48748 }
48749
48750 if (IS_CV == IS_UNUSED) {
48751 obj = Z_OBJ_P(object);
48752 } else {
48753 do {
48754 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
48755 obj = Z_OBJ_P(object);
48756 } else {
48757 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
48758 zend_reference *ref = Z_REF_P(object);
48759
48760 object = &ref->val;
48761 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
48762 obj = Z_OBJ_P(object);
48763 if (IS_CV & IS_VAR) {
48764 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
48765 efree_size(ref, sizeof(zend_reference));
48766 } else {
48767 Z_ADDREF_P(object);
48768 }
48769 }
48770 break;
48771 }
48772 }
48773 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
48774 object = ZVAL_UNDEFINED_OP1();
48775 if (UNEXPECTED(EG(exception) != NULL)) {
48776 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48777 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48778 }
48779 HANDLE_EXCEPTION();
48780 }
48781 }
48782 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48783 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48784 }
48785 zend_invalid_method_call(object, function_name);
48786 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48787
48788 HANDLE_EXCEPTION();
48789 }
48790 } while (0);
48791 }
48792
48793 called_scope = obj->ce;
48794
48795 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
48796 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
48797 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
48798 } else {
48799 zend_object *orig_obj = obj;
48800
48801 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48802 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48803 }
48804
48805 /* First, locate the function. */
48806 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));
48807 if (UNEXPECTED(fbc == NULL)) {
48808 if (EXPECTED(!EG(exception))) {
48809 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
48810 }
48811 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48812 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
48813 zend_objects_store_del(orig_obj);
48814 }
48815 HANDLE_EXCEPTION();
48816 }
48817 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
48818 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
48819 EXPECTED(obj == orig_obj)) {
48820 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
48821 }
48822 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
48823 GC_ADDREF(obj); /* For $this pointer */
48824 if (GC_DELREF(orig_obj) == 0) {
48825 zend_objects_store_del(orig_obj);
48826 }
48827 }
48828 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
48829 init_func_run_time_cache(&fbc->op_array);
48830 }
48831 }
48832
48833 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48834 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48835 }
48836
48837 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
48838 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
48839 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
48840 zend_objects_store_del(obj);
48841 if (UNEXPECTED(EG(exception))) {
48842 HANDLE_EXCEPTION();
48843 }
48844 }
48845 /* call static method */
48846 obj = (zend_object*)called_scope;
48847 call_info = ZEND_CALL_NESTED_FUNCTION;
48848 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
48849 if (IS_CV == IS_CV) {
48850 GC_ADDREF(obj); /* For $this pointer */
48851 }
48852 /* CV may be changed indirectly (e.g. when it's a reference) */
48853 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
48854 }
48855
48856 call = zend_vm_stack_push_call_frame(call_info,
48857 fbc, opline->extended_value, obj);
48858 call->prev_execute_data = EX(call);
48859 EX(call) = call;
48860
48861 ZEND_VM_NEXT_OPCODE();
48862}
48863
48864static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48865{
48866 USE_OPLINE
48867 zval *expr_ptr, new_expr;
48868
48869 SAVE_OPLINE();
48870 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
48871 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
48872 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
48873 if (Z_ISREF_P(expr_ptr)) {
48874 Z_ADDREF_P(expr_ptr);
48875 } else {
48876 ZVAL_MAKE_REF_EX(expr_ptr, 2);
48877 }
48878
48879 } else {
48880 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48881 if (IS_CV == IS_TMP_VAR) {
48882 /* pass */
48883 } else if (IS_CV == IS_CONST) {
48884 Z_TRY_ADDREF_P(expr_ptr);
48885 } else if (IS_CV == IS_CV) {
48886 ZVAL_DEREF(expr_ptr);
48887 Z_TRY_ADDREF_P(expr_ptr);
48888 } else /* if (IS_CV == IS_VAR) */ {
48889 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
48890 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
48891
48892 expr_ptr = Z_REFVAL_P(expr_ptr);
48893 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
48894 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
48895 expr_ptr = &new_expr;
48896 efree_size(ref, sizeof(zend_reference));
48897 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
48898 Z_ADDREF_P(expr_ptr);
48899 }
48900 }
48901 }
48902 }
48903
48904 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48905 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48906 zend_string *str;
48907 zend_ulong hval;
48908
48909add_again:
48910 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
48911 str = Z_STR_P(offset);
48912 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48913 if (ZEND_HANDLE_NUMERIC(str, hval)) {
48914 goto num_index;
48915 }
48916 }
48917str_index:
48918 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
48919 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
48920 hval = Z_LVAL_P(offset);
48921num_index:
48922 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
48923 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
48924 offset = Z_REFVAL_P(offset);
48925 goto add_again;
48926 } else if (Z_TYPE_P(offset) == IS_NULL) {
48927 str = ZSTR_EMPTY_ALLOC();
48928 goto str_index;
48929 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
48930 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
48931 goto num_index;
48932 } else if (Z_TYPE_P(offset) == IS_FALSE) {
48933 hval = 0;
48934 goto num_index;
48935 } else if (Z_TYPE_P(offset) == IS_TRUE) {
48936 hval = 1;
48937 goto num_index;
48938 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
48939 zend_use_resource_as_offset(offset);
48940 hval = Z_RES_HANDLE_P(offset);
48941 goto num_index;
48942 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
48943 ZVAL_UNDEFINED_OP2();
48944 str = ZSTR_EMPTY_ALLOC();
48945 goto str_index;
48946 } else {
48947 zend_illegal_array_offset_access(offset);
48948 zval_ptr_dtor_nogc(expr_ptr);
48949 }
48950 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48951 } else {
48952 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
48953 zend_cannot_add_element();
48954 zval_ptr_dtor_nogc(expr_ptr);
48955 }
48956 }
48957 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48958}
48959
48960static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48961{
48962 zval *array;
48963 uint32_t size;
48964 USE_OPLINE
48965
48966 SAVE_OPLINE();
48967 array = EX_VAR(opline->result.var);
48968 if (IS_CV != IS_UNUSED) {
48969 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
48970 ZVAL_ARR(array, zend_new_array(size));
48971 /* Explicitly initialize array as not-packed if flag is set */
48972 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
48973 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
48974 }
48975 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
48976 } else {
48977 ZVAL_ARR(array, zend_new_array(0));
48978 ZEND_VM_NEXT_OPCODE();
48979 }
48980}
48981
48982static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48983{
48984 USE_OPLINE
48985 zval *container;
48986 zval *offset;
48987 zend_ulong hval;
48988 zend_string *key;
48989
48990 SAVE_OPLINE();
48991 container = EX_VAR(opline->op1.var);
48992 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48993
48994 do {
48995 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
48996 HashTable *ht;
48997
48998unset_dim_array:
48999 SEPARATE_ARRAY(container);
49000 ht = Z_ARRVAL_P(container);
49001offset_again:
49002 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
49003 key = Z_STR_P(offset);
49004 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49005 if (ZEND_HANDLE_NUMERIC(key, hval)) {
49006 goto num_index_dim;
49007 }
49008 }
49009str_index_dim:
49010 ZEND_ASSERT(ht != &EG(symbol_table));
49011 zend_hash_del(ht, key);
49012 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
49013 hval = Z_LVAL_P(offset);
49014num_index_dim:
49015 zend_hash_index_del(ht, hval);
49016 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
49017 offset = Z_REFVAL_P(offset);
49018 goto offset_again;
49019 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
49020 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
49021 goto num_index_dim;
49022 } else if (Z_TYPE_P(offset) == IS_NULL) {
49023 key = ZSTR_EMPTY_ALLOC();
49024 goto str_index_dim;
49025 } else if (Z_TYPE_P(offset) == IS_FALSE) {
49026 hval = 0;
49027 goto num_index_dim;
49028 } else if (Z_TYPE_P(offset) == IS_TRUE) {
49029 hval = 1;
49030 goto num_index_dim;
49031 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
49032 zend_use_resource_as_offset(offset);
49033 hval = Z_RES_HANDLE_P(offset);
49034 goto num_index_dim;
49035 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
49036 ZVAL_UNDEFINED_OP2();
49037 key = ZSTR_EMPTY_ALLOC();
49038 goto str_index_dim;
49039 } else {
49040 zend_illegal_array_offset_unset(offset);
49041 }
49042 break;
49043 } else if (Z_ISREF_P(container)) {
49044 container = Z_REFVAL_P(container);
49045 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49046 goto unset_dim_array;
49047 }
49048 }
49049 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
49050 container = ZVAL_UNDEFINED_OP1();
49051 }
49052 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
49053 offset = ZVAL_UNDEFINED_OP2();
49054 }
49055 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
49056 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
49057 offset++;
49058 }
49059 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
49060 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
49061 zend_throw_error(NULL, "Cannot unset string offsets");
49062 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
49063 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
49064 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
49065 zend_false_to_array_deprecated();
49066 }
49067 } while (0);
49068
49069 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49070
49071 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49072}
49073
49074static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49075{
49076 USE_OPLINE
49077 zval *container;
49078 zval *offset;
49079 zend_string *name, *tmp_name;
49080
49081 SAVE_OPLINE();
49082 container = EX_VAR(opline->op1.var);
49083 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49084
49085 do {
49086 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
49087 if (Z_ISREF_P(container)) {
49088 container = Z_REFVAL_P(container);
49089 if (Z_TYPE_P(container) != IS_OBJECT) {
49090 if (IS_CV == IS_CV
49091 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
49092 ZVAL_UNDEFINED_OP1();
49093 }
49094 break;
49095 }
49096 } else {
49097 break;
49098 }
49099 }
49100 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
49101 name = Z_STR_P(offset);
49102 } else {
49103 name = zval_try_get_tmp_string(offset, &tmp_name);
49104 if (UNEXPECTED(!name)) {
49105 break;
49106 }
49107 }
49108 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));
49109 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49110 zend_tmp_string_release(tmp_name);
49111 }
49112 } while (0);
49113
49114 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49115
49116 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49117}
49118
49119static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49120{
49121 USE_OPLINE
49122 zval *container;
49123 bool result;
49124 zend_ulong hval;
49125 zval *offset;
49126
49127 SAVE_OPLINE();
49128 container = EX_VAR(opline->op1.var);
49129 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49130
49131 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49132 HashTable *ht;
49133 zval *value;
49134 zend_string *str;
49135
49136isset_dim_obj_array:
49137 ht = Z_ARRVAL_P(container);
49138isset_again:
49139 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
49140 str = Z_STR_P(offset);
49141 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49142 if (ZEND_HANDLE_NUMERIC(str, hval)) {
49143 goto num_index_prop;
49144 }
49145 }
49146 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
49147 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
49148 hval = Z_LVAL_P(offset);
49149num_index_prop:
49150 value = zend_hash_index_find(ht, hval);
49151 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
49152 offset = Z_REFVAL_P(offset);
49153 goto isset_again;
49154 } else {
49155 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
49156 if (UNEXPECTED(EG(exception))) {
49157 result = 0;
49158 goto isset_dim_obj_exit;
49159 }
49160 }
49161
49162 if (!(opline->extended_value & ZEND_ISEMPTY)) {
49163 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
49164 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
49165 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
49166
49167 if (IS_CV & (IS_CONST|IS_CV)) {
49168 /* avoid exception check */
49169 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49170 ZEND_VM_SMART_BRANCH(result, 0);
49171 }
49172 } else {
49173 result = (value == NULL || !i_zend_is_true(value));
49174 }
49175 goto isset_dim_obj_exit;
49176 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
49177 container = Z_REFVAL_P(container);
49178 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49179 goto isset_dim_obj_array;
49180 }
49181 }
49182
49183 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
49184 offset++;
49185 }
49186 if (!(opline->extended_value & ZEND_ISEMPTY)) {
49187 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
49188 } else {
49189 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
49190 }
49191
49192isset_dim_obj_exit:
49193 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49194
49195 ZEND_VM_SMART_BRANCH(result, 1);
49196}
49197
49198static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49199{
49200 USE_OPLINE
49201 zval *container;
49202 int result;
49203 zval *offset;
49204 zend_string *name, *tmp_name;
49205
49206 SAVE_OPLINE();
49207 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
49208 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49209
49210 if (IS_CV == IS_CONST ||
49211 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
49212 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
49213 container = Z_REFVAL_P(container);
49214 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
49215 result = (opline->extended_value & ZEND_ISEMPTY);
49216 goto isset_object_finish;
49217 }
49218 } else {
49219 result = (opline->extended_value & ZEND_ISEMPTY);
49220 goto isset_object_finish;
49221 }
49222 }
49223
49224 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
49225 name = Z_STR_P(offset);
49226 } else {
49227 name = zval_try_get_tmp_string(offset, &tmp_name);
49228 if (UNEXPECTED(!name)) {
49229 result = 0;
49230 goto isset_object_finish;
49231 }
49232 }
49233
49234 result =
49235 (opline->extended_value & ZEND_ISEMPTY) ^
49236 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));
49237
49238 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49239 zend_tmp_string_release(tmp_name);
49240 }
49241
49242isset_object_finish:
49243 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49244
49245 ZEND_VM_SMART_BRANCH(result, 1);
49246}
49247
49248static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49249{
49250 USE_OPLINE
49251
49252 zval *key, *subject;
49253 HashTable *ht;
49254 bool result;
49255
49256 SAVE_OPLINE();
49257
49258 key = EX_VAR(opline->op1.var);
49259 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49260
49261 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
49262array_key_exists_array:
49263 ht = Z_ARRVAL_P(subject);
49264 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
49265 } else {
49266 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
49267 subject = Z_REFVAL_P(subject);
49268 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
49269 goto array_key_exists_array;
49270 }
49271 }
49272 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
49273 result = 0;
49274 }
49275
49276 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49277
49278 ZEND_VM_SMART_BRANCH(result, 1);
49279}
49280
49281static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49282{
49283 USE_OPLINE
49284
49285 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
49286
49287 SAVE_OPLINE();
49288 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
49289 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49290 }
49291
49292 /* Destroy the previously yielded value */
49293 zval_ptr_dtor(&generator->value);
49294
49295 /* Destroy the previously yielded key */
49296 zval_ptr_dtor(&generator->key);
49297
49298 /* Set the new yielded value */
49299 if (IS_CV != IS_UNUSED) {
49300 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
49301 /* Constants and temporary variables aren't yieldable by reference,
49302 * but we still allow them with a notice. */
49303 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
49304 zval *value;
49305
49306 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49307
49308 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49309 ZVAL_COPY_VALUE(&generator->value, value);
49310 if (IS_CV == IS_CONST) {
49311 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49312 Z_ADDREF(generator->value);
49313 }
49314 }
49315 } else {
49316 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49317
49318 /* If a function call result is yielded and the function did
49319 * not return by reference we throw a notice. */
49320 do {
49321 if (IS_CV == IS_VAR) {
49322 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
49323 if (opline->extended_value == ZEND_RETURNS_FUNCTION
49324 && !Z_ISREF_P(value_ptr)) {
49325 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49326 ZVAL_COPY(&generator->value, value_ptr);
49327 break;
49328 }
49329 }
49330 if (Z_ISREF_P(value_ptr)) {
49331 Z_ADDREF_P(value_ptr);
49332 } else {
49333 ZVAL_MAKE_REF_EX(value_ptr, 2);
49334 }
49335 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
49336 } while (0);
49337
49338 }
49339 } else {
49340 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49341
49342 /* Consts, temporary variables and references need copying */
49343 if (IS_CV == IS_CONST) {
49344 ZVAL_COPY_VALUE(&generator->value, value);
49345 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49346 Z_ADDREF(generator->value);
49347 }
49348 } else if (IS_CV == IS_TMP_VAR) {
49349 ZVAL_COPY_VALUE(&generator->value, value);
49350 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
49351 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
49352
49353 } else {
49354 ZVAL_COPY_VALUE(&generator->value, value);
49355 if (IS_CV == IS_CV) {
49356 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
49357 }
49358 }
49359 }
49360 } else {
49361 /* If no value was specified yield null */
49362 ZVAL_NULL(&generator->value);
49363 }
49364
49365 /* Set the new yielded key */
49366 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
49367 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49368 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
49369 key = Z_REFVAL_P(key);
49370 }
49371 ZVAL_COPY(&generator->key, key);
49372 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49373
49374 if (Z_TYPE(generator->key) == IS_LONG
49375 && Z_LVAL(generator->key) > generator->largest_used_integer_key
49376 ) {
49377 generator->largest_used_integer_key = Z_LVAL(generator->key);
49378 }
49379 } else {
49380 /* If no key was specified we use auto-increment keys */
49381 generator->largest_used_integer_key++;
49382 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
49383 }
49384
49385 if (RETURN_VALUE_USED(opline)) {
49386 /* If the return value of yield is used set the send
49387 * target and initialize it to NULL */
49388 generator->send_target = EX_VAR(opline->result.var);
49389 ZVAL_NULL(generator->send_target);
49390 } else {
49391 generator->send_target = NULL;
49392 }
49393
49394 /* The GOTO VM uses a local opline variable. We need to set the opline
49395 * variable in execute_data so we don't resume at an old position. */
49396 SAVE_OPLINE();
49397
49398 ZEND_VM_RETURN();
49399}
49400
49401static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49402{
49403 USE_OPLINE
49404 zval *op1, *op2;
49405 bool result;
49406
49407 SAVE_OPLINE();
49408 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49409 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49410 result = fast_is_identical_function(op1, op2);
49411
49412 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49413 ZEND_VM_SMART_BRANCH(result, 1);
49414}
49415
49416static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49417{
49418 USE_OPLINE
49419 zval *op1, *op2;
49420 bool result;
49421
49422 SAVE_OPLINE();
49423 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49424 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49425 result = fast_is_not_identical_function(op1, op2);
49426
49427 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49428 ZEND_VM_SMART_BRANCH(result, 1);
49429}
49430
49431static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49432{
49433 USE_OPLINE
49434 zval *value;
49435 zval *variable_ptr;
49436
49437 SAVE_OPLINE();
49438 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49439 variable_ptr = EX_VAR(opline->op1.var);
49440
49441 if (0 || UNEXPECTED(0)) {
49442 zend_refcounted *garbage = NULL;
49443
49444 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
49445 if (UNEXPECTED(0)) {
49446 ZVAL_COPY(EX_VAR(opline->result.var), value);
49447 }
49448 if (garbage) {
49449 GC_DTOR_NO_REF(garbage);
49450 }
49451 } else {
49452 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
49453 }
49454
49455 /* zend_assign_to_variable() always takes care of op2, never free it! */
49456
49457 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49458}
49459
49460static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49461{
49462 USE_OPLINE
49463 zval *value;
49464 zval *variable_ptr;
49465
49466 SAVE_OPLINE();
49467 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49468 variable_ptr = EX_VAR(opline->op1.var);
49469
49470 if (0 || UNEXPECTED(1)) {
49471 zend_refcounted *garbage = NULL;
49472
49473 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
49474 if (UNEXPECTED(1)) {
49475 ZVAL_COPY(EX_VAR(opline->result.var), value);
49476 }
49477 if (garbage) {
49478 GC_DTOR_NO_REF(garbage);
49479 }
49480 } else {
49481 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
49482 }
49483
49484 /* zend_assign_to_variable() always takes care of op2, never free it! */
49485
49486 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49487}
49488
49489static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49490{
49491 USE_OPLINE
49492 zval *op1, *op2;
49493 bool result;
49494
49495 SAVE_OPLINE();
49496 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49497 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
49498 result = fast_is_identical_function(op1, op2);
49499
49500 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49501 ZEND_VM_SMART_BRANCH(result, 1);
49502}
49503
49504static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49505{
49506 USE_OPLINE
49507 zval *op1, *op2;
49508 bool result;
49509
49510 SAVE_OPLINE();
49511 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49512 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
49513 result = fast_is_not_identical_function(op1, op2);
49514
49515 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49516 ZEND_VM_SMART_BRANCH(result, 1);
49517}
49518
49519static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49520{
49521 USE_OPLINE
49522 zval *value;
49523 zval *variable_ptr;
49524
49525 SAVE_OPLINE();
49526 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49527 variable_ptr = EX_VAR(opline->op1.var);
49528
49529 if (0 || UNEXPECTED(0)) {
49530 zend_refcounted *garbage = NULL;
49531
49532 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
49533 if (UNEXPECTED(0)) {
49534 ZVAL_COPY(EX_VAR(opline->result.var), value);
49535 }
49536 if (garbage) {
49537 GC_DTOR_NO_REF(garbage);
49538 }
49539 } else {
49540 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
49541 }
49542
49543 /* zend_assign_to_variable() always takes care of op2, never free it! */
49544
49545 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49546}
49547
49548static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49549{
49550 USE_OPLINE
49551 zval *value;
49552 zval *variable_ptr;
49553
49554 SAVE_OPLINE();
49555 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49556 variable_ptr = EX_VAR(opline->op1.var);
49557
49558 if (0 || UNEXPECTED(1)) {
49559 zend_refcounted *garbage = NULL;
49560
49561 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
49562 if (UNEXPECTED(1)) {
49563 ZVAL_COPY(EX_VAR(opline->result.var), value);
49564 }
49565 if (garbage) {
49566 GC_DTOR_NO_REF(garbage);
49567 }
49568 } else {
49569 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
49570 }
49571
49572 /* zend_assign_to_variable() always takes care of op2, never free it! */
49573
49574 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49575}
49576
49577static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49578{
49579 USE_OPLINE
49580 zval *variable_ptr;
49581 zval *value_ptr;
49582 zend_refcounted *garbage = NULL;
49583
49584 SAVE_OPLINE();
49585 value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49586 variable_ptr = EX_VAR(opline->op1.var);
49587
49588 if (IS_CV == IS_VAR &&
49589 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
49590
49591 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
49592 variable_ptr = &EG(uninitialized_zval);
49593 } else if (IS_VAR == IS_VAR &&
49594 opline->extended_value == ZEND_RETURNS_FUNCTION &&
49595 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
49596
49597 variable_ptr = zend_wrong_assign_to_variable_reference(
49598 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
49599 } else {
49600 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
49601 }
49602
49603 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49604 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
49605 }
49606
49607 if (garbage) {
49608 GC_DTOR(garbage);
49609 }
49610
49611 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49612
49613 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49614}
49615
49616static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49617{
49618 USE_OPLINE
49619 zval *expr;
49620 bool result;
49621
49622 SAVE_OPLINE();
49623 expr = EX_VAR(opline->op1.var);
49624
49625try_instanceof:
49626 if (Z_TYPE_P(expr) == IS_OBJECT) {
49627 zend_class_entry *ce;
49628
49629 if (IS_VAR == IS_CONST) {
49630 ce = CACHED_PTR(opline->extended_value);
49631 if (UNEXPECTED(ce == NULL)) {
49632 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);
49633 if (EXPECTED(ce)) {
49634 CACHE_PTR(opline->extended_value, ce);
49635 }
49636 }
49637 } else if (IS_VAR == IS_UNUSED) {
49638 ce = zend_fetch_class(NULL, opline->op2.num);
49639 if (UNEXPECTED(ce == NULL)) {
49640
49641 ZVAL_UNDEF(EX_VAR(opline->result.var));
49642 HANDLE_EXCEPTION();
49643 }
49644 } else {
49645 ce = Z_CE_P(EX_VAR(opline->op2.var));
49646 }
49647 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
49648 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
49649 expr = Z_REFVAL_P(expr);
49650 goto try_instanceof;
49651 } else {
49652 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
49653 ZVAL_UNDEFINED_OP1();
49654 }
49655 result = 0;
49656 }
49657
49658 ZEND_VM_SMART_BRANCH(result, 1);
49659}
49660
49661static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49662{
49663 USE_OPLINE
49664 zval *var_ptr;
49665 zval *value, *container, *dim;
49666 HashTable *ht;
49667
49668 SAVE_OPLINE();
49669 container = EX_VAR(opline->op1.var);
49670
49671 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49672assign_dim_op_array:
49673 SEPARATE_ARRAY(container);
49674 ht = Z_ARRVAL_P(container);
49675assign_dim_op_new_array:
49676 dim = NULL;
49677 if (IS_UNUSED == IS_UNUSED) {
49678 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
49679 if (UNEXPECTED(!var_ptr)) {
49680 zend_cannot_add_element();
49681 goto assign_dim_op_ret_null;
49682 }
49683 } else {
49684 if (IS_UNUSED == IS_CONST) {
49685 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
49686 } else {
49687 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
49688 }
49689 if (UNEXPECTED(!var_ptr)) {
49690 goto assign_dim_op_ret_null;
49691 }
49692 }
49693
49694 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
49695
49696 do {
49697 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
49698 zend_reference *ref = Z_REF_P(var_ptr);
49699 var_ptr = Z_REFVAL_P(var_ptr);
49700 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
49701 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
49702 break;
49703 }
49704 }
49705 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
49706 } while (0);
49707
49708 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49709 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
49710 }
49711 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
49712 } else {
49713 if (EXPECTED(Z_ISREF_P(container))) {
49714 container = Z_REFVAL_P(container);
49715 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49716 goto assign_dim_op_array;
49717 }
49718 }
49719
49720 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
49721 zend_object *obj = Z_OBJ_P(container);
49722
49723 dim = NULL;
49724 if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
49725 dim++;
49726 }
49727 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
49728 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
49729 uint8_t old_type;
49730
49731 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
49732 ZVAL_UNDEFINED_OP1();
49733 }
49734 ht = zend_new_array(8);
49735 old_type = Z_TYPE_P(container);
49736 ZVAL_ARR(container, ht);
49737 if (UNEXPECTED(old_type == IS_FALSE)) {
49738 GC_ADDREF(ht);
49739 zend_false_to_array_deprecated();
49740 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
49741 zend_array_destroy(ht);
49742 goto assign_dim_op_ret_null;
49743 }
49744 }
49745 goto assign_dim_op_new_array;
49746 } else {
49747 dim = NULL;
49748 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
49749assign_dim_op_ret_null:
49750 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
49751 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49752 ZVAL_NULL(EX_VAR(opline->result.var));
49753 }
49754 }
49755 }
49756
49757
49758 ZEND_VM_NEXT_OPCODE_EX(1, 2);
49759}
49760
49761static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
49762{
49763 USE_OPLINE
49764 zval *varname;
49765 zval *retval;
49766 zend_string *name, *tmp_name;
49767 HashTable *target_symbol_table;
49768
49769 SAVE_OPLINE();
49770 varname = EX_VAR(opline->op1.var);
49771
49772 if (IS_CV == IS_CONST) {
49773 name = Z_STR_P(varname);
49774 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
49775 name = Z_STR_P(varname);
49776 tmp_name = NULL;
49777 } else {
49778 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
49779 ZVAL_UNDEFINED_OP1();
49780 }
49781 name = zval_try_get_tmp_string(varname, &tmp_name);
49782 if (UNEXPECTED(!name)) {
49783 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
49784
49785 }
49786 ZVAL_UNDEF(EX_VAR(opline->result.var));
49787 HANDLE_EXCEPTION();
49788 }
49789 }
49790
49791 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
49792 retval = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
49793 if (retval == NULL) {
49794 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
49795fetch_this:
49796 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
49797 if (IS_CV != IS_CONST) {
49798 zend_tmp_string_release(tmp_name);
49799 }
49800 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49801 }
49802 if (type == BP_VAR_W) {
49803 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
49804 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
49805 retval = &EG(uninitialized_zval);
49806 } else {
49807 if (IS_CV == IS_CV) {
49808 /* Keep name alive in case an error handler tries to free it. */
49809 zend_string_addref(name);
49810 }
49811 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
49812 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
49813 if (type == BP_VAR_RW && !EG(exception)) {
49814 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
49815 } else {
49816 retval = &EG(uninitialized_zval);
49817 }
49818 if (IS_CV == IS_CV) {
49819 zend_string_release(name);
49820 }
49821 }
49822 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
49823 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
49824 retval = Z_INDIRECT_P(retval);
49825 if (Z_TYPE_P(retval) == IS_UNDEF) {
49826 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
49827 goto fetch_this;
49828 }
49829 if (type == BP_VAR_W) {
49830 ZVAL_NULL(retval);
49831 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
49832 retval = &EG(uninitialized_zval);
49833 } else {
49834 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
49835 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
49836 if (type == BP_VAR_RW && !EG(exception)) {
49837 ZVAL_NULL(retval);
49838 } else {
49839 retval = &EG(uninitialized_zval);
49840 }
49841 }
49842 }
49843 }
49844
49845 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
49846
49847 }
49848
49849 if (IS_CV != IS_CONST) {
49850 zend_tmp_string_release(tmp_name);
49851 }
49852
49853 ZEND_ASSERT(retval != NULL);
49854 if (type == BP_VAR_R || type == BP_VAR_IS) {
49855 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
49856 } else {
49857 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
49858 }
49859 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49860}
49861
49862static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49863{
49864 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49865}
49866
49867static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49868{
49869 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49870}
49871
49872static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49873{
49874 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49875}
49876
49877static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49878{
49879 int fetch_type =
49880 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
49881 BP_VAR_W : BP_VAR_R;
49882 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49883}
49884
49885static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49886{
49887 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49888}
49889
49890static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49891{
49892 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49893}
49894
49895/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
49896static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49897{
49898 USE_OPLINE
49899 zval *container;
49900
49901 SAVE_OPLINE();
49902 container = EX_VAR(opline->op1.var);
49903 zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
49904
49905 if (IS_CV == IS_VAR) {
49906 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
49907 }
49908 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49909}
49910
49911static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49912{
49913 USE_OPLINE
49914 zval *container;
49915
49916 SAVE_OPLINE();
49917 container = EX_VAR(opline->op1.var);
49918 zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
49919
49920 if (IS_CV == IS_VAR) {
49921 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
49922 }
49923 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49924}
49925
49926static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49927{
49928#if 0
49929 USE_OPLINE
49930#endif
49931
49932 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
49933 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
49934 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49935 }
49936 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49937 } else {
49938 if (IS_UNUSED == IS_UNUSED) {
49939 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49940 }
49941 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49942 }
49943}
49944
49945static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49946{
49947 USE_OPLINE
49948 zval *object_ptr, *orig_object_ptr;
49949 zval *value;
49950 zval *variable_ptr;
49951 zval *dim;
49952 zend_refcounted *garbage = NULL;
49953
49954 SAVE_OPLINE();
49955 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
49956
49957 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
49958try_assign_dim_array:
49959 SEPARATE_ARRAY(object_ptr);
49960 if (IS_UNUSED == IS_UNUSED) {
49961 value = RT_CONSTANT((opline+1), (opline+1)->op1);
49962 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
49963 HashTable *ht = Z_ARRVAL_P(object_ptr);
49964 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
49965 GC_ADDREF(ht);
49966 }
49967 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
49968 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
49969 zend_array_destroy(ht);
49970 goto assign_dim_error;
49971 }
49972 }
49973 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
49974 ZVAL_DEREF(value);
49975 }
49976 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
49977 if (UNEXPECTED(value == NULL)) {
49978 zend_cannot_add_element();
49979 goto assign_dim_error;
49980 } else if (IS_CONST == IS_CV) {
49981 if (Z_REFCOUNTED_P(value)) {
49982 Z_ADDREF_P(value);
49983 }
49984 } else if (IS_CONST == IS_VAR) {
49985 zval *free_op_data = EX_VAR((opline+1)->op1.var);
49986 if (Z_ISREF_P(free_op_data)) {
49987 if (Z_REFCOUNTED_P(value)) {
49988 Z_ADDREF_P(value);
49989 }
49990 zval_ptr_dtor_nogc(free_op_data);
49991 }
49992 } else if (IS_CONST == IS_CONST) {
49993 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
49994 Z_ADDREF_P(value);
49995 }
49996 }
49997 } else {
49998 dim = NULL;
49999 if (IS_UNUSED == IS_CONST) {
50000 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50001 } else {
50002 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50003 }
50004 if (UNEXPECTED(variable_ptr == NULL)) {
50005 goto assign_dim_error;
50006 }
50007 value = RT_CONSTANT((opline+1), (opline+1)->op1);
50008 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
50009 }
50010 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50011 ZVAL_COPY(EX_VAR(opline->result.var), value);
50012 }
50013 if (garbage) {
50014 GC_DTOR_NO_REF(garbage);
50015 }
50016 } else {
50017 if (EXPECTED(Z_ISREF_P(object_ptr))) {
50018 object_ptr = Z_REFVAL_P(object_ptr);
50019 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50020 goto try_assign_dim_array;
50021 }
50022 }
50023 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50024 zend_object *obj = Z_OBJ_P(object_ptr);
50025
50026 GC_ADDREF(obj);
50027 dim = NULL;
50028 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50029 dim = ZVAL_UNDEFINED_OP2();
50030 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50031 dim++;
50032 }
50033
50034 value = RT_CONSTANT((opline+1), (opline+1)->op1);
50035 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50036 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50037 } else if (IS_CONST & (IS_CV|IS_VAR)) {
50038 ZVAL_DEREF(value);
50039 }
50040
50041 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50042
50043 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50044 zend_objects_store_del(obj);
50045 }
50046 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50047 if (IS_UNUSED == IS_UNUSED) {
50048 zend_use_new_element_for_string();
50049
50050 UNDEF_RESULT();
50051 } else {
50052 dim = NULL;
50053 value = RT_CONSTANT((opline+1), (opline+1)->op1);
50054 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50055
50056 }
50057 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50058 if (Z_ISREF_P(orig_object_ptr)
50059 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50060 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50061 dim = NULL;
50062
50063 UNDEF_RESULT();
50064 } else {
50065 HashTable *ht = zend_new_array(8);
50066 uint8_t old_type = Z_TYPE_P(object_ptr);
50067
50068 ZVAL_ARR(object_ptr, ht);
50069 if (UNEXPECTED(old_type == IS_FALSE)) {
50070 GC_ADDREF(ht);
50071 zend_false_to_array_deprecated();
50072 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50073 zend_array_destroy(ht);
50074 goto assign_dim_error;
50075 }
50076 }
50077 goto try_assign_dim_array;
50078 }
50079 } else {
50080 zend_use_scalar_as_array();
50081 dim = NULL;
50082assign_dim_error:
50083
50084 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50085 ZVAL_NULL(EX_VAR(opline->result.var));
50086 }
50087 }
50088 }
50089 if (IS_UNUSED != IS_UNUSED) {
50090
50091 }
50092
50093 /* assign_dim has two opcodes! */
50094 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50095}
50096
50097static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50098{
50099 USE_OPLINE
50100 zval *object_ptr, *orig_object_ptr;
50101 zval *value;
50102 zval *variable_ptr;
50103 zval *dim;
50104 zend_refcounted *garbage = NULL;
50105
50106 SAVE_OPLINE();
50107 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50108
50109 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50110try_assign_dim_array:
50111 SEPARATE_ARRAY(object_ptr);
50112 if (IS_UNUSED == IS_UNUSED) {
50113 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50114 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50115 HashTable *ht = Z_ARRVAL_P(object_ptr);
50116 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50117 GC_ADDREF(ht);
50118 }
50119 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50120 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50121 zend_array_destroy(ht);
50122 goto assign_dim_error;
50123 }
50124 }
50125 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
50126 ZVAL_DEREF(value);
50127 }
50128 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50129 if (UNEXPECTED(value == NULL)) {
50130 zend_cannot_add_element();
50131 goto assign_dim_error;
50132 } else if (IS_TMP_VAR == IS_CV) {
50133 if (Z_REFCOUNTED_P(value)) {
50134 Z_ADDREF_P(value);
50135 }
50136 } else if (IS_TMP_VAR == IS_VAR) {
50137 zval *free_op_data = EX_VAR((opline+1)->op1.var);
50138 if (Z_ISREF_P(free_op_data)) {
50139 if (Z_REFCOUNTED_P(value)) {
50140 Z_ADDREF_P(value);
50141 }
50142 zval_ptr_dtor_nogc(free_op_data);
50143 }
50144 } else if (IS_TMP_VAR == IS_CONST) {
50145 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50146 Z_ADDREF_P(value);
50147 }
50148 }
50149 } else {
50150 dim = NULL;
50151 if (IS_UNUSED == IS_CONST) {
50152 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50153 } else {
50154 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50155 }
50156 if (UNEXPECTED(variable_ptr == NULL)) {
50157 goto assign_dim_error;
50158 }
50159 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50160 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
50161 }
50162 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50163 ZVAL_COPY(EX_VAR(opline->result.var), value);
50164 }
50165 if (garbage) {
50166 GC_DTOR_NO_REF(garbage);
50167 }
50168 } else {
50169 if (EXPECTED(Z_ISREF_P(object_ptr))) {
50170 object_ptr = Z_REFVAL_P(object_ptr);
50171 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50172 goto try_assign_dim_array;
50173 }
50174 }
50175 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50176 zend_object *obj = Z_OBJ_P(object_ptr);
50177
50178 GC_ADDREF(obj);
50179 dim = NULL;
50180 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50181 dim = ZVAL_UNDEFINED_OP2();
50182 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50183 dim++;
50184 }
50185
50186 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50187 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50188 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50189 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
50190 ZVAL_DEREF(value);
50191 }
50192
50193 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50194
50195 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50196 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50197 zend_objects_store_del(obj);
50198 }
50199 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50200 if (IS_UNUSED == IS_UNUSED) {
50201 zend_use_new_element_for_string();
50202 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50203 UNDEF_RESULT();
50204 } else {
50205 dim = NULL;
50206 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50207 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50208 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50209 }
50210 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50211 if (Z_ISREF_P(orig_object_ptr)
50212 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50213 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50214 dim = NULL;
50215 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50216 UNDEF_RESULT();
50217 } else {
50218 HashTable *ht = zend_new_array(8);
50219 uint8_t old_type = Z_TYPE_P(object_ptr);
50220
50221 ZVAL_ARR(object_ptr, ht);
50222 if (UNEXPECTED(old_type == IS_FALSE)) {
50223 GC_ADDREF(ht);
50224 zend_false_to_array_deprecated();
50225 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50226 zend_array_destroy(ht);
50227 goto assign_dim_error;
50228 }
50229 }
50230 goto try_assign_dim_array;
50231 }
50232 } else {
50233 zend_use_scalar_as_array();
50234 dim = NULL;
50235assign_dim_error:
50236 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50237 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50238 ZVAL_NULL(EX_VAR(opline->result.var));
50239 }
50240 }
50241 }
50242 if (IS_UNUSED != IS_UNUSED) {
50243
50244 }
50245
50246 /* assign_dim has two opcodes! */
50247 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50248}
50249
50250static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50251{
50252 USE_OPLINE
50253 zval *object_ptr, *orig_object_ptr;
50254 zval *value;
50255 zval *variable_ptr;
50256 zval *dim;
50257 zend_refcounted *garbage = NULL;
50258
50259 SAVE_OPLINE();
50260 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50261
50262 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50263try_assign_dim_array:
50264 SEPARATE_ARRAY(object_ptr);
50265 if (IS_UNUSED == IS_UNUSED) {
50266 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50267 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50268 HashTable *ht = Z_ARRVAL_P(object_ptr);
50269 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50270 GC_ADDREF(ht);
50271 }
50272 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50273 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50274 zend_array_destroy(ht);
50275 goto assign_dim_error;
50276 }
50277 }
50278 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
50279 ZVAL_DEREF(value);
50280 }
50281 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50282 if (UNEXPECTED(value == NULL)) {
50283 zend_cannot_add_element();
50284 goto assign_dim_error;
50285 } else if (IS_VAR == IS_CV) {
50286 if (Z_REFCOUNTED_P(value)) {
50287 Z_ADDREF_P(value);
50288 }
50289 } else if (IS_VAR == IS_VAR) {
50290 zval *free_op_data = EX_VAR((opline+1)->op1.var);
50291 if (Z_ISREF_P(free_op_data)) {
50292 if (Z_REFCOUNTED_P(value)) {
50293 Z_ADDREF_P(value);
50294 }
50295 zval_ptr_dtor_nogc(free_op_data);
50296 }
50297 } else if (IS_VAR == IS_CONST) {
50298 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50299 Z_ADDREF_P(value);
50300 }
50301 }
50302 } else {
50303 dim = NULL;
50304 if (IS_UNUSED == IS_CONST) {
50305 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50306 } else {
50307 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50308 }
50309 if (UNEXPECTED(variable_ptr == NULL)) {
50310 goto assign_dim_error;
50311 }
50312 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50313 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
50314 }
50315 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50316 ZVAL_COPY(EX_VAR(opline->result.var), value);
50317 }
50318 if (garbage) {
50319 GC_DTOR_NO_REF(garbage);
50320 }
50321 } else {
50322 if (EXPECTED(Z_ISREF_P(object_ptr))) {
50323 object_ptr = Z_REFVAL_P(object_ptr);
50324 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50325 goto try_assign_dim_array;
50326 }
50327 }
50328 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50329 zend_object *obj = Z_OBJ_P(object_ptr);
50330
50331 GC_ADDREF(obj);
50332 dim = NULL;
50333 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50334 dim = ZVAL_UNDEFINED_OP2();
50335 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50336 dim++;
50337 }
50338
50339 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50340 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50341 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50342 } else if (IS_VAR & (IS_CV|IS_VAR)) {
50343 ZVAL_DEREF(value);
50344 }
50345
50346 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50347
50348 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50349 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50350 zend_objects_store_del(obj);
50351 }
50352 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50353 if (IS_UNUSED == IS_UNUSED) {
50354 zend_use_new_element_for_string();
50355 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50356 UNDEF_RESULT();
50357 } else {
50358 dim = NULL;
50359 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50360 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50361 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50362 }
50363 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50364 if (Z_ISREF_P(orig_object_ptr)
50365 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50366 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50367 dim = NULL;
50368 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50369 UNDEF_RESULT();
50370 } else {
50371 HashTable *ht = zend_new_array(8);
50372 uint8_t old_type = Z_TYPE_P(object_ptr);
50373
50374 ZVAL_ARR(object_ptr, ht);
50375 if (UNEXPECTED(old_type == IS_FALSE)) {
50376 GC_ADDREF(ht);
50377 zend_false_to_array_deprecated();
50378 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50379 zend_array_destroy(ht);
50380 goto assign_dim_error;
50381 }
50382 }
50383 goto try_assign_dim_array;
50384 }
50385 } else {
50386 zend_use_scalar_as_array();
50387 dim = NULL;
50388assign_dim_error:
50389 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50390 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50391 ZVAL_NULL(EX_VAR(opline->result.var));
50392 }
50393 }
50394 }
50395 if (IS_UNUSED != IS_UNUSED) {
50396
50397 }
50398
50399 /* assign_dim has two opcodes! */
50400 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50401}
50402
50403static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50404{
50405 USE_OPLINE
50406 zval *object_ptr, *orig_object_ptr;
50407 zval *value;
50408 zval *variable_ptr;
50409 zval *dim;
50410 zend_refcounted *garbage = NULL;
50411
50412 SAVE_OPLINE();
50413 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50414
50415 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50416try_assign_dim_array:
50417 SEPARATE_ARRAY(object_ptr);
50418 if (IS_UNUSED == IS_UNUSED) {
50419 value = EX_VAR((opline+1)->op1.var);
50420 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50421 HashTable *ht = Z_ARRVAL_P(object_ptr);
50422 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50423 GC_ADDREF(ht);
50424 }
50425 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50426 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50427 zend_array_destroy(ht);
50428 goto assign_dim_error;
50429 }
50430 }
50431 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
50432 ZVAL_DEREF(value);
50433 }
50434 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50435 if (UNEXPECTED(value == NULL)) {
50436 zend_cannot_add_element();
50437 goto assign_dim_error;
50438 } else if (IS_CV == IS_CV) {
50439 if (Z_REFCOUNTED_P(value)) {
50440 Z_ADDREF_P(value);
50441 }
50442 } else if (IS_CV == IS_VAR) {
50443 zval *free_op_data = EX_VAR((opline+1)->op1.var);
50444 if (Z_ISREF_P(free_op_data)) {
50445 if (Z_REFCOUNTED_P(value)) {
50446 Z_ADDREF_P(value);
50447 }
50448 zval_ptr_dtor_nogc(free_op_data);
50449 }
50450 } else if (IS_CV == IS_CONST) {
50451 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50452 Z_ADDREF_P(value);
50453 }
50454 }
50455 } else {
50456 dim = NULL;
50457 if (IS_UNUSED == IS_CONST) {
50458 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50459 } else {
50460 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50461 }
50462 if (UNEXPECTED(variable_ptr == NULL)) {
50463 goto assign_dim_error;
50464 }
50465 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
50466 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
50467 }
50468 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50469 ZVAL_COPY(EX_VAR(opline->result.var), value);
50470 }
50471 if (garbage) {
50472 GC_DTOR_NO_REF(garbage);
50473 }
50474 } else {
50475 if (EXPECTED(Z_ISREF_P(object_ptr))) {
50476 object_ptr = Z_REFVAL_P(object_ptr);
50477 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50478 goto try_assign_dim_array;
50479 }
50480 }
50481 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50482 zend_object *obj = Z_OBJ_P(object_ptr);
50483
50484 GC_ADDREF(obj);
50485 dim = NULL;
50486 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50487 dim = ZVAL_UNDEFINED_OP2();
50488 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50489 dim++;
50490 }
50491
50492 value = EX_VAR((opline+1)->op1.var);
50493 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50494 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50495 } else if (IS_CV & (IS_CV|IS_VAR)) {
50496 ZVAL_DEREF(value);
50497 }
50498
50499 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50500
50501 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50502 zend_objects_store_del(obj);
50503 }
50504 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50505 if (IS_UNUSED == IS_UNUSED) {
50506 zend_use_new_element_for_string();
50507
50508 UNDEF_RESULT();
50509 } else {
50510 dim = NULL;
50511 value = EX_VAR((opline+1)->op1.var);
50512 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50513
50514 }
50515 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50516 if (Z_ISREF_P(orig_object_ptr)
50517 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50518 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50519 dim = NULL;
50520
50521 UNDEF_RESULT();
50522 } else {
50523 HashTable *ht = zend_new_array(8);
50524 uint8_t old_type = Z_TYPE_P(object_ptr);
50525
50526 ZVAL_ARR(object_ptr, ht);
50527 if (UNEXPECTED(old_type == IS_FALSE)) {
50528 GC_ADDREF(ht);
50529 zend_false_to_array_deprecated();
50530 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50531 zend_array_destroy(ht);
50532 goto assign_dim_error;
50533 }
50534 }
50535 goto try_assign_dim_array;
50536 }
50537 } else {
50538 zend_use_scalar_as_array();
50539 dim = NULL;
50540assign_dim_error:
50541
50542 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50543 ZVAL_NULL(EX_VAR(opline->result.var));
50544 }
50545 }
50546 }
50547 if (IS_UNUSED != IS_UNUSED) {
50548
50549 }
50550
50551 /* assign_dim has two opcodes! */
50552 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50553}
50554
50555static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50556{
50557 if (IS_CV == IS_UNUSED) {
50558 SAVE_OPLINE();
50559 zend_verify_missing_return_type(EX(func));
50560 HANDLE_EXCEPTION();
50561 } else {
50562/* prevents "undefined variable opline" errors */
50563#if 0 || (IS_CV != IS_UNUSED)
50564 USE_OPLINE
50565 zval *retval_ref, *retval_ptr;
50566 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
50567 retval_ref = retval_ptr = EX_VAR(opline->op1.var);
50568
50569 if (IS_CV == IS_CONST) {
50570 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
50571 retval_ref = retval_ptr = EX_VAR(opline->result.var);
50572 } else if (IS_CV == IS_VAR) {
50573 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
50574 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
50575 }
50576 ZVAL_DEREF(retval_ptr);
50577 } else if (IS_CV == IS_CV) {
50578 ZVAL_DEREF(retval_ptr);
50579 }
50580
50581 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
50582 ZEND_VM_NEXT_OPCODE();
50583 }
50584
50585 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
50586 SAVE_OPLINE();
50587 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
50588 if (UNEXPECTED(EG(exception))) {
50589 HANDLE_EXCEPTION();
50590 }
50591 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
50592 ZEND_VM_NEXT_OPCODE();
50593 }
50594 }
50595
50596 zend_reference *ref = NULL;
50597 void *cache_slot = CACHE_ADDR(opline->op2.num);
50598 if (UNEXPECTED(retval_ref != retval_ptr)) {
50599 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
50600 ref = Z_REF_P(retval_ref);
50601 } else {
50602 /* A cast might happen - unwrap the reference if this is a by-value return */
50603 if (Z_REFCOUNT_P(retval_ref) == 1) {
50604 ZVAL_UNREF(retval_ref);
50605 } else {
50606 Z_DELREF_P(retval_ref);
50607 ZVAL_COPY(retval_ref, retval_ptr);
50608 }
50609 retval_ptr = retval_ref;
50610 }
50611 }
50612
50613 SAVE_OPLINE();
50614 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
50615 zend_verify_return_error(EX(func), retval_ptr);
50616 HANDLE_EXCEPTION();
50617 }
50618 ZEND_VM_NEXT_OPCODE();
50619#endif
50620 }
50621}
50622
50623static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50624{
50625 USE_OPLINE
50626 zval *varptr, *arg;
50627
50628 if (IS_UNUSED == IS_CONST) {
50629 SAVE_OPLINE();
50630 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50631 uint32_t arg_num;
50632 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50633 if (UNEXPECTED(!arg)) {
50634
50635 HANDLE_EXCEPTION();
50636 }
50637 } else {
50638 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50639 }
50640
50641 varptr = EX_VAR(opline->op1.var);
50642 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50643 SAVE_OPLINE();
50644 ZVAL_UNDEFINED_OP1();
50645 ZVAL_NULL(arg);
50646 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50647 }
50648
50649 if (IS_CV == IS_CV) {
50650 ZVAL_COPY_DEREF(arg, varptr);
50651 } else /* if (IS_CV == IS_VAR) */ {
50652 if (UNEXPECTED(Z_ISREF_P(varptr))) {
50653 zend_refcounted *ref = Z_COUNTED_P(varptr);
50654
50655 varptr = Z_REFVAL_P(varptr);
50656 ZVAL_COPY_VALUE(arg, varptr);
50657 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50658 efree_size(ref, sizeof(zend_reference));
50659 } else if (Z_OPT_REFCOUNTED_P(arg)) {
50660 Z_ADDREF_P(arg);
50661 }
50662 } else {
50663 ZVAL_COPY_VALUE(arg, varptr);
50664 }
50665 }
50666
50667 ZEND_VM_NEXT_OPCODE();
50668}
50669
50670static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50671{
50672 USE_OPLINE
50673 zval *varptr, *arg;
50674
50675 SAVE_OPLINE();
50676 if (IS_UNUSED == IS_CONST) {
50677 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50678 uint32_t arg_num;
50679 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50680 if (UNEXPECTED(!arg)) {
50681
50682 HANDLE_EXCEPTION();
50683 }
50684 } else {
50685 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50686 }
50687
50688 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50689 if (Z_ISREF_P(varptr)) {
50690 Z_ADDREF_P(varptr);
50691 } else {
50692 ZVAL_MAKE_REF_EX(varptr, 2);
50693 }
50694 ZVAL_REF(arg, Z_REF_P(varptr));
50695
50696 ZEND_VM_NEXT_OPCODE();
50697}
50698
50699static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50700{
50701 USE_OPLINE
50702 zval *varptr, *arg;
50703 uint32_t arg_num;
50704
50705 if (IS_UNUSED == IS_CONST) {
50706 SAVE_OPLINE();
50707 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50708 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50709 if (UNEXPECTED(!arg)) {
50710
50711 HANDLE_EXCEPTION();
50712 }
50713 } else {
50714 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50715 arg_num = opline->op2.num;
50716 }
50717
50718 if (EXPECTED(0)) {
50719 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50720 goto send_var_by_ref;
50721 }
50722 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50723send_var_by_ref:
50724 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50725 if (Z_ISREF_P(varptr)) {
50726 Z_ADDREF_P(varptr);
50727 } else {
50728 ZVAL_MAKE_REF_EX(varptr, 2);
50729 }
50730 ZVAL_REF(arg, Z_REF_P(varptr));
50731
50732 ZEND_VM_NEXT_OPCODE();
50733 }
50734
50735 varptr = EX_VAR(opline->op1.var);
50736 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50737 SAVE_OPLINE();
50738 ZVAL_UNDEFINED_OP1();
50739 ZVAL_NULL(arg);
50740 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50741 }
50742
50743 if (IS_CV == IS_CV) {
50744 ZVAL_COPY_DEREF(arg, varptr);
50745 } else /* if (IS_CV == IS_VAR) */ {
50746 if (UNEXPECTED(Z_ISREF_P(varptr))) {
50747 zend_refcounted *ref = Z_COUNTED_P(varptr);
50748
50749 varptr = Z_REFVAL_P(varptr);
50750 ZVAL_COPY_VALUE(arg, varptr);
50751 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50752 efree_size(ref, sizeof(zend_reference));
50753 } else if (Z_OPT_REFCOUNTED_P(arg)) {
50754 Z_ADDREF_P(arg);
50755 }
50756 } else {
50757 ZVAL_COPY_VALUE(arg, varptr);
50758 }
50759 }
50760
50761 ZEND_VM_NEXT_OPCODE();
50762}
50763
50764static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50765{
50766 USE_OPLINE
50767 zval *varptr, *arg;
50768 uint32_t arg_num;
50769
50770 if (IS_UNUSED == IS_CONST) {
50771 SAVE_OPLINE();
50772 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50773 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50774 if (UNEXPECTED(!arg)) {
50775
50776 HANDLE_EXCEPTION();
50777 }
50778 } else {
50779 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50780 arg_num = opline->op2.num;
50781 }
50782
50783 if (EXPECTED(1)) {
50784 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50785 goto send_var_by_ref;
50786 }
50787 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50788send_var_by_ref:
50789 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50790 if (Z_ISREF_P(varptr)) {
50791 Z_ADDREF_P(varptr);
50792 } else {
50793 ZVAL_MAKE_REF_EX(varptr, 2);
50794 }
50795 ZVAL_REF(arg, Z_REF_P(varptr));
50796
50797 ZEND_VM_NEXT_OPCODE();
50798 }
50799
50800 varptr = EX_VAR(opline->op1.var);
50801 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50802 SAVE_OPLINE();
50803 ZVAL_UNDEFINED_OP1();
50804 ZVAL_NULL(arg);
50805 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50806 }
50807
50808 if (IS_CV == IS_CV) {
50809 ZVAL_COPY_DEREF(arg, varptr);
50810 } else /* if (IS_CV == IS_VAR) */ {
50811 if (UNEXPECTED(Z_ISREF_P(varptr))) {
50812 zend_refcounted *ref = Z_COUNTED_P(varptr);
50813
50814 varptr = Z_REFVAL_P(varptr);
50815 ZVAL_COPY_VALUE(arg, varptr);
50816 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50817 efree_size(ref, sizeof(zend_reference));
50818 } else if (Z_OPT_REFCOUNTED_P(arg)) {
50819 Z_ADDREF_P(arg);
50820 }
50821 } else {
50822 ZVAL_COPY_VALUE(arg, varptr);
50823 }
50824 }
50825
50826 ZEND_VM_NEXT_OPCODE();
50827}
50828
50829static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50830{
50831 USE_OPLINE
50832 zval *expr_ptr, new_expr;
50833
50834 SAVE_OPLINE();
50835 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
50836 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
50837 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50838 if (Z_ISREF_P(expr_ptr)) {
50839 Z_ADDREF_P(expr_ptr);
50840 } else {
50841 ZVAL_MAKE_REF_EX(expr_ptr, 2);
50842 }
50843
50844 } else {
50845 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50846 if (IS_CV == IS_TMP_VAR) {
50847 /* pass */
50848 } else if (IS_CV == IS_CONST) {
50849 Z_TRY_ADDREF_P(expr_ptr);
50850 } else if (IS_CV == IS_CV) {
50851 ZVAL_DEREF(expr_ptr);
50852 Z_TRY_ADDREF_P(expr_ptr);
50853 } else /* if (IS_CV == IS_VAR) */ {
50854 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
50855 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
50856
50857 expr_ptr = Z_REFVAL_P(expr_ptr);
50858 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50859 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
50860 expr_ptr = &new_expr;
50861 efree_size(ref, sizeof(zend_reference));
50862 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
50863 Z_ADDREF_P(expr_ptr);
50864 }
50865 }
50866 }
50867 }
50868
50869 if (IS_UNUSED != IS_UNUSED) {
50870 zval *offset = NULL;
50871 zend_string *str;
50872 zend_ulong hval;
50873
50874add_again:
50875 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
50876 str = Z_STR_P(offset);
50877 if (IS_UNUSED != IS_CONST) {
50878 if (ZEND_HANDLE_NUMERIC(str, hval)) {
50879 goto num_index;
50880 }
50881 }
50882str_index:
50883 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
50884 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
50885 hval = Z_LVAL_P(offset);
50886num_index:
50887 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
50888 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
50889 offset = Z_REFVAL_P(offset);
50890 goto add_again;
50891 } else if (Z_TYPE_P(offset) == IS_NULL) {
50892 str = ZSTR_EMPTY_ALLOC();
50893 goto str_index;
50894 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
50895 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
50896 goto num_index;
50897 } else if (Z_TYPE_P(offset) == IS_FALSE) {
50898 hval = 0;
50899 goto num_index;
50900 } else if (Z_TYPE_P(offset) == IS_TRUE) {
50901 hval = 1;
50902 goto num_index;
50903 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
50904 zend_use_resource_as_offset(offset);
50905 hval = Z_RES_HANDLE_P(offset);
50906 goto num_index;
50907 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
50908 ZVAL_UNDEFINED_OP2();
50909 str = ZSTR_EMPTY_ALLOC();
50910 goto str_index;
50911 } else {
50912 zend_illegal_array_offset_access(offset);
50913 zval_ptr_dtor_nogc(expr_ptr);
50914 }
50915
50916 } else {
50917 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
50918 zend_cannot_add_element();
50919 zval_ptr_dtor_nogc(expr_ptr);
50920 }
50921 }
50922 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50923}
50924
50925static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50926{
50927 zval *array;
50928 uint32_t size;
50929 USE_OPLINE
50930
50931 SAVE_OPLINE();
50932 array = EX_VAR(opline->result.var);
50933 if (IS_CV != IS_UNUSED) {
50934 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
50935 ZVAL_ARR(array, zend_new_array(size));
50936 /* Explicitly initialize array as not-packed if flag is set */
50937 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
50938 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
50939 }
50940 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50941 } else {
50942 ZVAL_ARR(array, zend_new_array(0));
50943 ZEND_VM_NEXT_OPCODE();
50944 }
50945}
50946
50947static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50948{
50949 USE_OPLINE
50950 zval *var = EX_VAR(opline->op1.var);
50951
50952 if (Z_REFCOUNTED_P(var)) {
50953 zend_refcounted *garbage = Z_COUNTED_P(var);
50954
50955 ZVAL_UNDEF(var);
50956 SAVE_OPLINE();
50957 GC_DTOR(garbage);
50958 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50959 } else {
50960 ZVAL_UNDEF(var);
50961 }
50962 ZEND_VM_NEXT_OPCODE();
50963}
50964
50965static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50966{
50967 USE_OPLINE
50968 zval *varname;
50969 zend_string *name, *tmp_name;
50970 HashTable *target_symbol_table;
50971
50972 SAVE_OPLINE();
50973
50974 varname = EX_VAR(opline->op1.var);
50975
50976 if (IS_CV == IS_CONST) {
50977 name = Z_STR_P(varname);
50978 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
50979 name = Z_STR_P(varname);
50980 tmp_name = NULL;
50981 } else {
50982 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
50983 varname = ZVAL_UNDEFINED_OP1();
50984 }
50985 name = zval_try_get_tmp_string(varname, &tmp_name);
50986 if (UNEXPECTED(!name)) {
50987
50988 HANDLE_EXCEPTION();
50989 }
50990 }
50991
50992 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
50993 zend_hash_del_ind(target_symbol_table, name);
50994
50995 if (IS_CV != IS_CONST) {
50996 zend_tmp_string_release(tmp_name);
50997 }
50998
50999 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51000}
51001
51002/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
51003static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51004{
51005 USE_OPLINE
51006 zval *value;
51007
51008 value = EX_VAR(opline->op1.var);
51009 if (!(0)) {
51010 if (Z_TYPE_P(value) > IS_NULL &&
51011 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
51012 ZEND_VM_SMART_BRANCH_TRUE();
51013 } else {
51014 ZEND_VM_SMART_BRANCH_FALSE();
51015 }
51016 } else {
51017 bool result;
51018
51019 SAVE_OPLINE();
51020 result = !i_zend_is_true(value);
51021 ZEND_VM_SMART_BRANCH(result, 1);
51022 }
51023}
51024
51025static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51026{
51027 USE_OPLINE
51028 zval *value;
51029
51030 value = EX_VAR(opline->op1.var);
51031 if (!(1)) {
51032 if (Z_TYPE_P(value) > IS_NULL &&
51033 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
51034 ZEND_VM_SMART_BRANCH_TRUE();
51035 } else {
51036 ZEND_VM_SMART_BRANCH_FALSE();
51037 }
51038 } else {
51039 bool result;
51040
51041 SAVE_OPLINE();
51042 result = !i_zend_is_true(value);
51043 ZEND_VM_SMART_BRANCH(result, 1);
51044 }
51045}
51046
51047static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51048{
51049 USE_OPLINE
51050 zval *value;
51051 bool result;
51052 zval *varname;
51053 zend_string *name, *tmp_name;
51054 HashTable *target_symbol_table;
51055
51056 SAVE_OPLINE();
51057 varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
51058 if (IS_CV == IS_CONST) {
51059 name = Z_STR_P(varname);
51060 } else {
51061 name = zval_get_tmp_string(varname, &tmp_name);
51062 }
51063
51064 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
51065 value = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
51066
51067 if (IS_CV != IS_CONST) {
51068 zend_tmp_string_release(tmp_name);
51069 }
51070
51071 if (!value) {
51072 result = (opline->extended_value & ZEND_ISEMPTY);
51073 } else {
51074 if (Z_TYPE_P(value) == IS_INDIRECT) {
51075 value = Z_INDIRECT_P(value);
51076 }
51077 if (!(opline->extended_value & ZEND_ISEMPTY)) {
51078 if (Z_ISREF_P(value)) {
51079 value = Z_REFVAL_P(value);
51080 }
51081 result = Z_TYPE_P(value) > IS_NULL;
51082 } else {
51083 result = !i_zend_is_true(value);
51084 }
51085 }
51086
51087 ZEND_VM_SMART_BRANCH(result, true);
51088}
51089
51090/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
51091static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51092{
51093 USE_OPLINE
51094 zval *expr;
51095 bool result;
51096
51097 SAVE_OPLINE();
51098 expr = EX_VAR(opline->op1.var);
51099
51100try_instanceof:
51101 if (Z_TYPE_P(expr) == IS_OBJECT) {
51102 zend_class_entry *ce;
51103
51104 if (IS_UNUSED == IS_CONST) {
51105 ce = CACHED_PTR(opline->extended_value);
51106 if (UNEXPECTED(ce == NULL)) {
51107 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);
51108 if (EXPECTED(ce)) {
51109 CACHE_PTR(opline->extended_value, ce);
51110 }
51111 }
51112 } else if (IS_UNUSED == IS_UNUSED) {
51113 ce = zend_fetch_class(NULL, opline->op2.num);
51114 if (UNEXPECTED(ce == NULL)) {
51115
51116 ZVAL_UNDEF(EX_VAR(opline->result.var));
51117 HANDLE_EXCEPTION();
51118 }
51119 } else {
51120 ce = Z_CE_P(EX_VAR(opline->op2.var));
51121 }
51122 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
51123 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
51124 expr = Z_REFVAL_P(expr);
51125 goto try_instanceof;
51126 } else {
51127 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
51128 ZVAL_UNDEFINED_OP1();
51129 }
51130 result = 0;
51131 }
51132
51133 ZEND_VM_SMART_BRANCH(result, 1);
51134}
51135
51136static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51137{
51138 USE_OPLINE
51139
51140 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
51141
51142 SAVE_OPLINE();
51143 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
51144 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51145 }
51146
51147 /* Destroy the previously yielded value */
51148 zval_ptr_dtor(&generator->value);
51149
51150 /* Destroy the previously yielded key */
51151 zval_ptr_dtor(&generator->key);
51152
51153 /* Set the new yielded value */
51154 if (IS_CV != IS_UNUSED) {
51155 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
51156 /* Constants and temporary variables aren't yieldable by reference,
51157 * but we still allow them with a notice. */
51158 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
51159 zval *value;
51160
51161 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
51162
51163 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51164 ZVAL_COPY_VALUE(&generator->value, value);
51165 if (IS_CV == IS_CONST) {
51166 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
51167 Z_ADDREF(generator->value);
51168 }
51169 }
51170 } else {
51171 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
51172
51173 /* If a function call result is yielded and the function did
51174 * not return by reference we throw a notice. */
51175 do {
51176 if (IS_CV == IS_VAR) {
51177 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
51178 if (opline->extended_value == ZEND_RETURNS_FUNCTION
51179 && !Z_ISREF_P(value_ptr)) {
51180 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
51181 ZVAL_COPY(&generator->value, value_ptr);
51182 break;
51183 }
51184 }
51185 if (Z_ISREF_P(value_ptr)) {
51186 Z_ADDREF_P(value_ptr);
51187 } else {
51188 ZVAL_MAKE_REF_EX(value_ptr, 2);
51189 }
51190 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
51191 } while (0);
51192
51193 }
51194 } else {
51195 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51196
51197 /* Consts, temporary variables and references need copying */
51198 if (IS_CV == IS_CONST) {
51199 ZVAL_COPY_VALUE(&generator->value, value);
51200 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
51201 Z_ADDREF(generator->value);
51202 }
51203 } else if (IS_CV == IS_TMP_VAR) {
51204 ZVAL_COPY_VALUE(&generator->value, value);
51205 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
51206 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
51207
51208 } else {
51209 ZVAL_COPY_VALUE(&generator->value, value);
51210 if (IS_CV == IS_CV) {
51211 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
51212 }
51213 }
51214 }
51215 } else {
51216 /* If no value was specified yield null */
51217 ZVAL_NULL(&generator->value);
51218 }
51219
51220 /* Set the new yielded key */
51221 if (IS_UNUSED != IS_UNUSED) {
51222 zval *key = NULL;
51223 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
51224 key = Z_REFVAL_P(key);
51225 }
51226 ZVAL_COPY(&generator->key, key);
51227
51228 if (Z_TYPE(generator->key) == IS_LONG
51229 && Z_LVAL(generator->key) > generator->largest_used_integer_key
51230 ) {
51231 generator->largest_used_integer_key = Z_LVAL(generator->key);
51232 }
51233 } else {
51234 /* If no key was specified we use auto-increment keys */
51235 generator->largest_used_integer_key++;
51236 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
51237 }
51238
51239 if (RETURN_VALUE_USED(opline)) {
51240 /* If the return value of yield is used set the send
51241 * target and initialize it to NULL */
51242 generator->send_target = EX_VAR(opline->result.var);
51243 ZVAL_NULL(generator->send_target);
51244 } else {
51245 generator->send_target = NULL;
51246 }
51247
51248 /* The GOTO VM uses a local opline variable. We need to set the opline
51249 * variable in execute_data so we don't resume at an old position. */
51250 SAVE_OPLINE();
51251
51252 ZEND_VM_RETURN();
51253}
51254
51255static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51256{
51257 USE_OPLINE
51258 zval *op1 = EX_VAR(opline->op1.var);
51259
51260 if (UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
51261 SAVE_OPLINE();
51262 ZVAL_UNDEFINED_OP1();
51263 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51264 }
51265 ZEND_VM_NEXT_OPCODE();
51266}
51267
51268static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51269{
51270 USE_OPLINE
51271 zval *op1 = EX_VAR(opline->op1.var);
51272
51273 if (IS_CV == IS_CV) {
51274 if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51275 ZVAL_NEW_EMPTY_REF(op1);
51276 Z_SET_REFCOUNT_P(op1, 2);
51277 ZVAL_NULL(Z_REFVAL_P(op1));
51278 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51279 } else {
51280 if (Z_ISREF_P(op1)) {
51281 Z_ADDREF_P(op1);
51282 } else {
51283 ZVAL_MAKE_REF_EX(op1, 2);
51284 }
51285 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51286 }
51287 } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
51288 op1 = Z_INDIRECT_P(op1);
51289 if (EXPECTED(!Z_ISREF_P(op1))) {
51290 ZVAL_MAKE_REF_EX(op1, 2);
51291 } else {
51292 GC_ADDREF(Z_REF_P(op1));
51293 }
51294 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51295 } else {
51296 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
51297 }
51298 ZEND_VM_NEXT_OPCODE();
51299}
51300
51301static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51302{
51303 USE_OPLINE
51304 zval *op1;
51305 zend_long count;
51306
51307 SAVE_OPLINE();
51308 op1 = EX_VAR(opline->op1.var);
51309
51310 while (1) {
51311 if (Z_TYPE_P(op1) == IS_ARRAY) {
51312 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
51313 break;
51314 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
51315 zend_object *zobj = Z_OBJ_P(op1);
51316
51317 /* first, we check if the handler is defined */
51318 if (zobj->handlers->count_elements) {
51319 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
51320 break;
51321 }
51322 if (UNEXPECTED(EG(exception))) {
51323 count = 0;
51324 break;
51325 }
51326 }
51327
51328 /* if not and the object implements Countable we call its count() method */
51329 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
51330 zval retval;
51331
51332 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
51333 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
51334 count = zval_get_long(&retval);
51335 zval_ptr_dtor(&retval);
51336 break;
51337 }
51338
51339 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
51340 } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
51341 op1 = Z_REFVAL_P(op1);
51342 continue;
51343 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51344 ZVAL_UNDEFINED_OP1();
51345 }
51346 count = 0;
51347 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));
51348 break;
51349 }
51350
51351 ZVAL_LONG(EX_VAR(opline->result.var), count);
51352
51353 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51354}
51355
51356static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51357{
51358 USE_OPLINE
51359 zend_array *ht = Z_ARRVAL_P(EX_VAR(opline->op1.var));
51360 ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
51361 if (IS_CV & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
51362 SAVE_OPLINE();
51363 zend_array_destroy(ht);
51364 if (EG(exception)) {
51365 HANDLE_EXCEPTION();
51366 }
51367 }
51368 ZEND_VM_NEXT_OPCODE();
51369}
51370
51371static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51372{
51373 USE_OPLINE
51374
51375 if (IS_CV == IS_UNUSED) {
51376 SAVE_OPLINE();
51377 if (UNEXPECTED(!EX(func)->common.scope)) {
51378 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
51379 ZVAL_UNDEF(EX_VAR(opline->result.var));
51380 HANDLE_EXCEPTION();
51381 } else {
51382 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
51383 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
51384 if (UNEXPECTED(EG(exception))) {
51385 HANDLE_EXCEPTION();
51386 }
51387 ZEND_VM_NEXT_OPCODE();
51388 }
51389 } else {
51390 zval *op1;
51391
51392 SAVE_OPLINE();
51393 op1 = EX_VAR(opline->op1.var);
51394 while (1) {
51395 if (Z_TYPE_P(op1) == IS_OBJECT) {
51396 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
51397 } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
51398 op1 = Z_REFVAL_P(op1);
51399 continue;
51400 } else {
51401 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51402 ZVAL_UNDEFINED_OP1();
51403 }
51404 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
51405 ZVAL_UNDEF(EX_VAR(opline->result.var));
51406 }
51407 break;
51408 }
51409
51410 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51411 }
51412}
51413
51414static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51415{
51416 USE_OPLINE
51417 zval *op1;
51418 zend_string *type;
51419
51420 SAVE_OPLINE();
51421 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51422 type = zend_zval_get_legacy_type(op1);
51423 if (EXPECTED(type)) {
51424 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
51425 } else {
51426 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
51427 }
51428
51429 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51430}
51431
51432static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51433{
51434 USE_OPLINE
51435 zval *varptr, *arg;
51436 uint32_t arg_num = opline->op2.num;
51437
51438 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
51439 ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51440 }
51441
51442 varptr = EX_VAR(opline->op1.var);
51443 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
51444
51445 if (IS_CV == IS_CV) {
51446 ZVAL_COPY(arg, varptr);
51447 } else /* if (IS_CV == IS_VAR) */ {
51448 ZVAL_COPY_VALUE(arg, varptr);
51449 }
51450
51451 ZEND_VM_NEXT_OPCODE();
51452}
51453
51454static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51455{
51456 USE_OPLINE
51457 zval *op1, *op2;
51458
51459 SAVE_OPLINE();
51460 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51461 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51462 div_function(EX_VAR(opline->result.var), op1, op2);
51463
51464
51465 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51466}
51467
51468static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51469{
51470 USE_OPLINE
51471 zval *op1, *op2;
51472
51473 SAVE_OPLINE();
51474 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51475 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51476 pow_function(EX_VAR(opline->result.var), op1, op2);
51477
51478
51479 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51480}
51481
51482static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51483{
51484 USE_OPLINE
51485 zval *op1, *op2;
51486
51487 op1 = EX_VAR(opline->op1.var);
51488 op2 = EX_VAR(opline->op2.var);
51489
51490 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
51491 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
51492 zend_string *op1_str = Z_STR_P(op1);
51493 zend_string *op2_str = Z_STR_P(op2);
51494 zend_string *str;
51495 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
51496
51497 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
51498 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
51499 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
51500 } else {
51501 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
51502 }
51503 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51504 zend_string_release_ex(op1_str, 0);
51505 }
51506 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
51507 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
51508 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
51509 } else {
51510 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
51511 }
51512 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51513 zend_string_release_ex(op2_str, 0);
51514 }
51515 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
51516 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
51517 size_t len = ZSTR_LEN(op1_str);
51518
51519 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
51520 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
51521 }
51522 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
51523 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
51524 GC_ADD_FLAGS(str, flags);
51525 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
51526 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51527 zend_string_release_ex(op2_str, 0);
51528 }
51529 } else {
51530 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
51531 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
51532 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
51533 GC_ADD_FLAGS(str, flags);
51534 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
51535 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51536 zend_string_release_ex(op1_str, 0);
51537 }
51538 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51539 zend_string_release_ex(op2_str, 0);
51540 }
51541 }
51542 ZEND_VM_NEXT_OPCODE();
51543 } else {
51544 SAVE_OPLINE();
51545
51546 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51547 op1 = ZVAL_UNDEFINED_OP1();
51548 }
51549 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
51550 op2 = ZVAL_UNDEFINED_OP2();
51551 }
51552 concat_function(EX_VAR(opline->result.var), op1, op2);
51553
51554
51555 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51556 }
51557}
51558
51559static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51560{
51561 USE_OPLINE
51562 zval *op1, *op2;
51563 bool result;
51564
51565 SAVE_OPLINE();
51566 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51567 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51568 result = fast_is_identical_function(op1, op2);
51569
51570
51571 ZEND_VM_SMART_BRANCH(result, 1);
51572}
51573
51574static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51575{
51576 USE_OPLINE
51577 zval *op1, *op2;
51578 bool result;
51579
51580 SAVE_OPLINE();
51581 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51582 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51583 result = fast_is_not_identical_function(op1, op2);
51584
51585
51586 ZEND_VM_SMART_BRANCH(result, 1);
51587}
51588
51589static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51590{
51591 USE_OPLINE
51592 zval *op1, *op2;
51593 double d1, d2;
51594
51595 op1 = EX_VAR(opline->op1.var);
51596 op2 = EX_VAR(opline->op2.var);
51597 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51598 /* pass */
51599 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51600 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51601 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51602is_equal_true:
51603 ZEND_VM_SMART_BRANCH_TRUE_NONE();
51604 } else {
51605is_equal_false:
51606 ZEND_VM_SMART_BRANCH_FALSE_NONE();
51607 }
51608 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51609 d1 = (double)Z_LVAL_P(op1);
51610 d2 = Z_DVAL_P(op2);
51611 goto is_equal_double;
51612 }
51613 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51614 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51615 d1 = Z_DVAL_P(op1);
51616 d2 = Z_DVAL_P(op2);
51617is_equal_double:
51618 if (d1 == d2) {
51619 goto is_equal_true;
51620 } else {
51621 goto is_equal_false;
51622 }
51623 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51624 d1 = Z_DVAL_P(op1);
51625 d2 = (double)Z_LVAL_P(op2);
51626 goto is_equal_double;
51627 }
51628 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51629 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51630 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51631 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51632 zval_ptr_dtor_str(op1);
51633 }
51634 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51635 zval_ptr_dtor_str(op2);
51636 }
51637 if (result) {
51638 goto is_equal_true;
51639 } else {
51640 goto is_equal_false;
51641 }
51642 }
51643 }
51644 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51645}
51646
51647static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51648{
51649 USE_OPLINE
51650 zval *op1, *op2;
51651 double d1, d2;
51652
51653 op1 = EX_VAR(opline->op1.var);
51654 op2 = EX_VAR(opline->op2.var);
51655 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51656 /* pass */
51657 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51658 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51659 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51660is_equal_true:
51661 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
51662 } else {
51663is_equal_false:
51664 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
51665 }
51666 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51667 d1 = (double)Z_LVAL_P(op1);
51668 d2 = Z_DVAL_P(op2);
51669 goto is_equal_double;
51670 }
51671 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51672 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51673 d1 = Z_DVAL_P(op1);
51674 d2 = Z_DVAL_P(op2);
51675is_equal_double:
51676 if (d1 == d2) {
51677 goto is_equal_true;
51678 } else {
51679 goto is_equal_false;
51680 }
51681 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51682 d1 = Z_DVAL_P(op1);
51683 d2 = (double)Z_LVAL_P(op2);
51684 goto is_equal_double;
51685 }
51686 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51687 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51688 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51689 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51690 zval_ptr_dtor_str(op1);
51691 }
51692 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51693 zval_ptr_dtor_str(op2);
51694 }
51695 if (result) {
51696 goto is_equal_true;
51697 } else {
51698 goto is_equal_false;
51699 }
51700 }
51701 }
51702 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51703}
51704
51705static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51706{
51707 USE_OPLINE
51708 zval *op1, *op2;
51709 double d1, d2;
51710
51711 op1 = EX_VAR(opline->op1.var);
51712 op2 = EX_VAR(opline->op2.var);
51713 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51714 /* pass */
51715 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51716 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51717 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51718is_equal_true:
51719 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
51720 } else {
51721is_equal_false:
51722 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
51723 }
51724 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51725 d1 = (double)Z_LVAL_P(op1);
51726 d2 = Z_DVAL_P(op2);
51727 goto is_equal_double;
51728 }
51729 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51730 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51731 d1 = Z_DVAL_P(op1);
51732 d2 = Z_DVAL_P(op2);
51733is_equal_double:
51734 if (d1 == d2) {
51735 goto is_equal_true;
51736 } else {
51737 goto is_equal_false;
51738 }
51739 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51740 d1 = Z_DVAL_P(op1);
51741 d2 = (double)Z_LVAL_P(op2);
51742 goto is_equal_double;
51743 }
51744 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51745 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51746 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51747 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51748 zval_ptr_dtor_str(op1);
51749 }
51750 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51751 zval_ptr_dtor_str(op2);
51752 }
51753 if (result) {
51754 goto is_equal_true;
51755 } else {
51756 goto is_equal_false;
51757 }
51758 }
51759 }
51760 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51761}
51762
51763static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51764{
51765 USE_OPLINE
51766 zval *op1, *op2;
51767 double d1, d2;
51768
51769 op1 = EX_VAR(opline->op1.var);
51770 op2 = EX_VAR(opline->op2.var);
51771 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51772 /* pass */
51773 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51774 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51775 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51776is_not_equal_true:
51777 ZEND_VM_SMART_BRANCH_TRUE_NONE();
51778 } else {
51779is_not_equal_false:
51780 ZEND_VM_SMART_BRANCH_FALSE_NONE();
51781 }
51782 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51783 d1 = (double)Z_LVAL_P(op1);
51784 d2 = Z_DVAL_P(op2);
51785 goto is_not_equal_double;
51786 }
51787 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51788 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51789 d1 = Z_DVAL_P(op1);
51790 d2 = Z_DVAL_P(op2);
51791is_not_equal_double:
51792 if (d1 != d2) {
51793 goto is_not_equal_true;
51794 } else {
51795 goto is_not_equal_false;
51796 }
51797 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51798 d1 = Z_DVAL_P(op1);
51799 d2 = (double)Z_LVAL_P(op2);
51800 goto is_not_equal_double;
51801 }
51802 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51803 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51804 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51805 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51806 zval_ptr_dtor_str(op1);
51807 }
51808 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51809 zval_ptr_dtor_str(op2);
51810 }
51811 if (!result) {
51812 goto is_not_equal_true;
51813 } else {
51814 goto is_not_equal_false;
51815 }
51816 }
51817 }
51818 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51819}
51820
51821static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51822{
51823 USE_OPLINE
51824 zval *op1, *op2;
51825 double d1, d2;
51826
51827 op1 = EX_VAR(opline->op1.var);
51828 op2 = EX_VAR(opline->op2.var);
51829 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51830 /* pass */
51831 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51832 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51833 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51834is_not_equal_true:
51835 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
51836 } else {
51837is_not_equal_false:
51838 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
51839 }
51840 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51841 d1 = (double)Z_LVAL_P(op1);
51842 d2 = Z_DVAL_P(op2);
51843 goto is_not_equal_double;
51844 }
51845 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51846 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51847 d1 = Z_DVAL_P(op1);
51848 d2 = Z_DVAL_P(op2);
51849is_not_equal_double:
51850 if (d1 != d2) {
51851 goto is_not_equal_true;
51852 } else {
51853 goto is_not_equal_false;
51854 }
51855 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51856 d1 = Z_DVAL_P(op1);
51857 d2 = (double)Z_LVAL_P(op2);
51858 goto is_not_equal_double;
51859 }
51860 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51861 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51862 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51863 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51864 zval_ptr_dtor_str(op1);
51865 }
51866 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51867 zval_ptr_dtor_str(op2);
51868 }
51869 if (!result) {
51870 goto is_not_equal_true;
51871 } else {
51872 goto is_not_equal_false;
51873 }
51874 }
51875 }
51876 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51877}
51878
51879static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51880{
51881 USE_OPLINE
51882 zval *op1, *op2;
51883 double d1, d2;
51884
51885 op1 = EX_VAR(opline->op1.var);
51886 op2 = EX_VAR(opline->op2.var);
51887 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51888 /* pass */
51889 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51890 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51891 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51892is_not_equal_true:
51893 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
51894 } else {
51895is_not_equal_false:
51896 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
51897 }
51898 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51899 d1 = (double)Z_LVAL_P(op1);
51900 d2 = Z_DVAL_P(op2);
51901 goto is_not_equal_double;
51902 }
51903 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51904 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51905 d1 = Z_DVAL_P(op1);
51906 d2 = Z_DVAL_P(op2);
51907is_not_equal_double:
51908 if (d1 != d2) {
51909 goto is_not_equal_true;
51910 } else {
51911 goto is_not_equal_false;
51912 }
51913 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51914 d1 = Z_DVAL_P(op1);
51915 d2 = (double)Z_LVAL_P(op2);
51916 goto is_not_equal_double;
51917 }
51918 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51919 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51920 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51921 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51922 zval_ptr_dtor_str(op1);
51923 }
51924 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51925 zval_ptr_dtor_str(op2);
51926 }
51927 if (!result) {
51928 goto is_not_equal_true;
51929 } else {
51930 goto is_not_equal_false;
51931 }
51932 }
51933 }
51934 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51935}
51936
51937static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51938{
51939 USE_OPLINE
51940 zval *op1, *op2;
51941
51942 SAVE_OPLINE();
51943 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51944 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51945 compare_function(EX_VAR(opline->result.var), op1, op2);
51946
51947
51948 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51949}
51950
51951static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51952{
51953 USE_OPLINE
51954 zval *op1, *op2;
51955
51956 SAVE_OPLINE();
51957 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51958 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51959 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
51960
51961
51962 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51963}
51964
51965static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51966{
51967 USE_OPLINE
51968 zval *object;
51969 zval *property;
51970 zval *value;
51971 zval *zptr;
51972 void *_cache_slot[3] = {0};
51973 void **cache_slot;
51974 zend_property_info *prop_info;
51975 zend_object *zobj;
51976 zend_string *name, *tmp_name;
51977
51978 SAVE_OPLINE();
51979 object = EX_VAR(opline->op1.var);
51980 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51981
51982 do {
51983 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
51984
51985 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
51986 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
51987 object = Z_REFVAL_P(object);
51988 goto assign_op_object;
51989 }
51990 if (IS_CV == IS_CV
51991 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
51992 ZVAL_UNDEFINED_OP1();
51993 }
51994 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
51995 break;
51996 }
51997
51998assign_op_object:
51999 /* here we are sure we are dealing with an object */
52000 zobj = Z_OBJ_P(object);
52001 if (IS_CV == IS_CONST) {
52002 name = Z_STR_P(property);
52003 } else {
52004 name = zval_try_get_tmp_string(property, &tmp_name);
52005 if (UNEXPECTED(!name)) {
52006 UNDEF_RESULT();
52007 break;
52008 }
52009 }
52010 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
52011 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
52012 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
52013 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52014 ZVAL_NULL(EX_VAR(opline->result.var));
52015 }
52016 } else {
52017 zend_reference *ref;
52018
52019 do {
52020 if (UNEXPECTED(Z_ISREF_P(zptr))) {
52021 ref = Z_REF_P(zptr);
52022 zptr = Z_REFVAL_P(zptr);
52023 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
52024 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
52025 break;
52026 }
52027 }
52028
52029 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
52030 if (prop_info) {
52031 /* special case for typed properties */
52032 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
52033 } else {
52034 zend_binary_op(zptr, zptr, value OPLINE_CC);
52035 }
52036 } while (0);
52037
52038 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52039 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
52040 }
52041 }
52042 } else {
52043 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
52044 }
52045 if (IS_CV != IS_CONST) {
52046 zend_tmp_string_release(tmp_name);
52047 }
52048 } while (0);
52049
52050 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52051
52052
52053 /* assign_obj has two opcodes! */
52054 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52055}
52056
52057/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
52058static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52059{
52060 USE_OPLINE
52061 zval *var_ptr;
52062 zval *value, *container, *dim;
52063 HashTable *ht;
52064
52065 SAVE_OPLINE();
52066 container = EX_VAR(opline->op1.var);
52067
52068 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52069assign_dim_op_array:
52070 SEPARATE_ARRAY(container);
52071 ht = Z_ARRVAL_P(container);
52072assign_dim_op_new_array:
52073 dim = EX_VAR(opline->op2.var);
52074 if (IS_CV == IS_UNUSED) {
52075 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
52076 if (UNEXPECTED(!var_ptr)) {
52077 zend_cannot_add_element();
52078 goto assign_dim_op_ret_null;
52079 }
52080 } else {
52081 if (IS_CV == IS_CONST) {
52082 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
52083 } else {
52084 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
52085 }
52086 if (UNEXPECTED(!var_ptr)) {
52087 goto assign_dim_op_ret_null;
52088 }
52089 }
52090
52091 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
52092
52093 do {
52094 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
52095 zend_reference *ref = Z_REF_P(var_ptr);
52096 var_ptr = Z_REFVAL_P(var_ptr);
52097 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
52098 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
52099 break;
52100 }
52101 }
52102 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
52103 } while (0);
52104
52105 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52106 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
52107 }
52108 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52109 } else {
52110 if (EXPECTED(Z_ISREF_P(container))) {
52111 container = Z_REFVAL_P(container);
52112 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52113 goto assign_dim_op_array;
52114 }
52115 }
52116
52117 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52118 zend_object *obj = Z_OBJ_P(container);
52119
52120 dim = EX_VAR(opline->op2.var);
52121 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52122 dim++;
52123 }
52124 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
52125 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
52126 uint8_t old_type;
52127
52128 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
52129 ZVAL_UNDEFINED_OP1();
52130 }
52131 ht = zend_new_array(8);
52132 old_type = Z_TYPE_P(container);
52133 ZVAL_ARR(container, ht);
52134 if (UNEXPECTED(old_type == IS_FALSE)) {
52135 GC_ADDREF(ht);
52136 zend_false_to_array_deprecated();
52137 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52138 zend_array_destroy(ht);
52139 goto assign_dim_op_ret_null;
52140 }
52141 }
52142 goto assign_dim_op_new_array;
52143 } else {
52144 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52145 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
52146assign_dim_op_ret_null:
52147 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52148 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52149 ZVAL_NULL(EX_VAR(opline->result.var));
52150 }
52151 }
52152 }
52153
52154
52155 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52156}
52157
52158static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52159{
52160 USE_OPLINE
52161 zval *var_ptr;
52162 zval *value;
52163
52164 SAVE_OPLINE();
52165 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52166 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
52167
52168 do {
52169 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
52170 zend_reference *ref = Z_REF_P(var_ptr);
52171 var_ptr = Z_REFVAL_P(var_ptr);
52172 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
52173 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
52174 break;
52175 }
52176 }
52177 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
52178 } while (0);
52179
52180 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52181 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
52182 }
52183
52184
52185 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52186}
52187
52188static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52189{
52190 USE_OPLINE
52191 zval *object;
52192 zval *property;
52193 zval *zptr;
52194 void *_cache_slot[3] = {0};
52195 void **cache_slot;
52196 zend_property_info *prop_info;
52197 zend_object *zobj;
52198 zend_string *name, *tmp_name;
52199
52200 SAVE_OPLINE();
52201 object = EX_VAR(opline->op1.var);
52202 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52203
52204 do {
52205 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52206 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52207 object = Z_REFVAL_P(object);
52208 goto pre_incdec_object;
52209 }
52210 if (IS_CV == IS_CV
52211 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52212 ZVAL_UNDEFINED_OP1();
52213 }
52214 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
52215 break;
52216 }
52217
52218pre_incdec_object:
52219 /* here we are sure we are dealing with an object */
52220 zobj = Z_OBJ_P(object);
52221 if (IS_CV == IS_CONST) {
52222 name = Z_STR_P(property);
52223 } else {
52224 name = zval_try_get_tmp_string(property, &tmp_name);
52225 if (UNEXPECTED(!name)) {
52226 UNDEF_RESULT();
52227 break;
52228 }
52229 }
52230 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
52231 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
52232 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
52233 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52234 ZVAL_NULL(EX_VAR(opline->result.var));
52235 }
52236 } else {
52237 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
52238 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
52239 }
52240 } else {
52241 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
52242 }
52243 if (IS_CV != IS_CONST) {
52244 zend_tmp_string_release(tmp_name);
52245 }
52246 } while (0);
52247
52248
52249 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52250}
52251
52252static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52253{
52254 USE_OPLINE
52255 zval *object;
52256 zval *property;
52257 zval *zptr;
52258 void *_cache_slot[3] = {0};
52259 void **cache_slot;
52260 zend_property_info *prop_info;
52261 zend_object *zobj;
52262 zend_string *name, *tmp_name;
52263
52264 SAVE_OPLINE();
52265 object = EX_VAR(opline->op1.var);
52266 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52267
52268 do {
52269 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52270 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52271 object = Z_REFVAL_P(object);
52272 goto post_incdec_object;
52273 }
52274 if (IS_CV == IS_CV
52275 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52276 ZVAL_UNDEFINED_OP1();
52277 }
52278 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
52279 break;
52280 }
52281
52282post_incdec_object:
52283 /* here we are sure we are dealing with an object */
52284 zobj = Z_OBJ_P(object);
52285 if (IS_CV == IS_CONST) {
52286 name = Z_STR_P(property);
52287 } else {
52288 name = zval_try_get_tmp_string(property, &tmp_name);
52289 if (UNEXPECTED(!name)) {
52290 ZVAL_UNDEF(EX_VAR(opline->result.var));
52291 break;
52292 }
52293 }
52294 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
52295 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
52296 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
52297 ZVAL_NULL(EX_VAR(opline->result.var));
52298 } else {
52299 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
52300 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
52301 }
52302 } else {
52303 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
52304 }
52305 if (IS_CV != IS_CONST) {
52306 zend_tmp_string_release(tmp_name);
52307 }
52308 } while (0);
52309
52310
52311 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52312}
52313
52314static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52315{
52316 USE_OPLINE
52317 zval *container, *dim, *value;
52318
52319 SAVE_OPLINE();
52320 container = EX_VAR(opline->op1.var);
52321 dim = EX_VAR(opline->op2.var);
52322 if (IS_CV != IS_CONST) {
52323 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52324fetch_dim_r_array:
52325 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
52326 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
52327 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
52328 container = Z_REFVAL_P(container);
52329 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52330 goto fetch_dim_r_array;
52331 } else {
52332 goto fetch_dim_r_slow;
52333 }
52334 } else {
52335fetch_dim_r_slow:
52336 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52337 dim++;
52338 }
52339 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
52340 }
52341 } else {
52342 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
52343 }
52344
52345
52346 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52347}
52348
52349static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52350{
52351 USE_OPLINE
52352 zval *container;
52353
52354 SAVE_OPLINE();
52355 container = EX_VAR(opline->op1.var);
52356 zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52357
52358 if (IS_CV == IS_VAR) {
52359 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52360 }
52361 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52362}
52363
52364static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52365{
52366 USE_OPLINE
52367 zval *container;
52368
52369 SAVE_OPLINE();
52370 container = EX_VAR(opline->op1.var);
52371 zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52372
52373 if (IS_CV == IS_VAR) {
52374 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52375 }
52376 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52377}
52378
52379static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52380{
52381 USE_OPLINE
52382 zval *container;
52383
52384 SAVE_OPLINE();
52385 container = EX_VAR(opline->op1.var);
52386 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52387
52388
52389 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52390}
52391
52392static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52393{
52394#if 0
52395 USE_OPLINE
52396#endif
52397
52398 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
52399 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
52400 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52401 }
52402 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52403 } else {
52404 if (IS_CV == IS_UNUSED) {
52405 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52406 }
52407 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52408 }
52409}
52410
52411static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52412{
52413 USE_OPLINE
52414 zval *container;
52415
52416 SAVE_OPLINE();
52417 container = EX_VAR(opline->op1.var);
52418 zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52419
52420 if (IS_CV == IS_VAR) {
52421 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52422 }
52423 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52424}
52425
52426static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52427{
52428 USE_OPLINE
52429 zval *container;
52430 void **cache_slot = NULL;
52431
52432 SAVE_OPLINE();
52433 container = EX_VAR(opline->op1.var);
52434
52435 if (IS_CV == IS_CONST ||
52436 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
52437 do {
52438 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
52439 container = Z_REFVAL_P(container);
52440 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52441 break;
52442 }
52443 }
52444 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
52445 ZVAL_UNDEFINED_OP1();
52446 }
52447 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52448 ZVAL_NULL(EX_VAR(opline->result.var));
52449 goto fetch_obj_r_finish;
52450 } while (0);
52451 }
52452
52453 /* here we are sure we are dealing with an object */
52454 do {
52455 zend_object *zobj = Z_OBJ_P(container);
52456 zend_string *name, *tmp_name;
52457 zval *retval;
52458
52459 if (IS_CV == IS_CONST) {
52460 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
52461
52462 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
52463 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52464
52465 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52466fetch_obj_r_simple:
52467 retval = OBJ_PROP(zobj, prop_offset);
52468 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
52469 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52470 goto fetch_obj_r_copy;
52471 } else {
52472fetch_obj_r_fast_copy:
52473 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52474 ZEND_VM_NEXT_OPCODE();
52475 }
52476 }
52477 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
52478 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
52479 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
52480 prop_offset = prop_info->offset;
52481 goto fetch_obj_r_simple;
52482 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
52483 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
52484 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
52485 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
52486
52487 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
52488 if (IS_CV & IS_CV) {
52489 GC_ADDREF(zobj);
52490 }
52491 if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
52492 call_info |= ZEND_CALL_RELEASE_THIS;
52493 }
52494 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
52495 call->prev_execute_data = execute_data;
52496 call->call = NULL;
52497 call->return_value = EX_VAR(opline->result.var);
52498 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
52499
52500 execute_data = call;
52501 EG(current_execute_data) = execute_data;
52502 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
52503
52504#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
52505 opline = hook->op_array.opcodes;
52506#else
52507 EX(opline) = hook->op_array.opcodes;
52508#endif
52509 LOAD_OPLINE_EX();
52510
52511
52512 ZEND_VM_ENTER_EX();
52513 }
52514 /* Fall through to read_property for hooks. */
52515 } else if (EXPECTED(zobj->properties != NULL)) {
52516 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
52517 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52518 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
52519 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
52520
52521 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
52522 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
52523
52524 if (EXPECTED(p->key == name) ||
52525 (EXPECTED(p->h == ZSTR_H(name)) &&
52526 EXPECTED(p->key != NULL) &&
52527 EXPECTED(zend_string_equal_content(p->key, name)))) {
52528 retval = &p->val;
52529 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52530 goto fetch_obj_r_copy;
52531 } else {
52532 goto fetch_obj_r_fast_copy;
52533 }
52534 }
52535 }
52536 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
52537 }
52538 retval = zend_hash_find_known_hash(zobj->properties, name);
52539 if (EXPECTED(retval)) {
52540 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
52541 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
52542 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52543 goto fetch_obj_r_copy;
52544 } else {
52545 goto fetch_obj_r_fast_copy;
52546 }
52547 }
52548 }
52549 }
52550 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52551 } else {
52552 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52553 if (UNEXPECTED(!name)) {
52554 ZVAL_UNDEF(EX_VAR(opline->result.var));
52555 break;
52556 }
52557 }
52558
52559#if ZEND_DEBUG
52560 /* For non-standard object handlers, verify a declared property type in debug builds.
52561 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
52562 zend_property_info *prop_info = NULL;
52563 if (zobj->handlers->read_property != zend_std_read_property) {
52564 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
52565 }
52566#endif
52567 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
52568#if ZEND_DEBUG
52569 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
52570 && ZEND_TYPE_IS_SET(prop_info->type)) {
52571 ZVAL_OPT_DEREF(retval);
52572 zend_verify_property_type(prop_info, retval, /* strict */ true);
52573 }
52574#endif
52575
52576 if (IS_CV != IS_CONST) {
52577 zend_tmp_string_release(tmp_name);
52578 }
52579
52580 if (retval != EX_VAR(opline->result.var)) {
52581fetch_obj_r_copy:
52582 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52583 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
52584 zend_unwrap_reference(retval);
52585 }
52586 } while (0);
52587
52588fetch_obj_r_finish:
52589
52590
52591 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52592}
52593
52594static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52595{
52596 USE_OPLINE
52597 zval *property, *container, *result;
52598
52599 SAVE_OPLINE();
52600
52601 container = EX_VAR(opline->op1.var);
52602 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52603 result = EX_VAR(opline->result.var);
52604 zend_fetch_property_address(
52605 result, container, IS_CV, property, IS_CV,
52606 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
52607 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
52608
52609 if (IS_CV == IS_VAR) {
52610 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52611 }
52612 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52613}
52614
52615static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52616{
52617 USE_OPLINE
52618 zval *property, *container, *result;
52619
52620 SAVE_OPLINE();
52621 container = EX_VAR(opline->op1.var);
52622 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52623 result = EX_VAR(opline->result.var);
52624 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);
52625
52626 if (IS_CV == IS_VAR) {
52627 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52628 }
52629 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52630}
52631
52632static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52633{
52634 USE_OPLINE
52635 zval *container;
52636 void **cache_slot = NULL;
52637
52638 SAVE_OPLINE();
52639 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
52640
52641 if (IS_CV == IS_CONST ||
52642 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
52643 do {
52644 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
52645 container = Z_REFVAL_P(container);
52646 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52647 break;
52648 }
52649 }
52650 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
52651 ZVAL_UNDEFINED_OP2();
52652 }
52653 ZVAL_NULL(EX_VAR(opline->result.var));
52654 goto fetch_obj_is_finish;
52655 } while (0);
52656 }
52657
52658 /* here we are sure we are dealing with an object */
52659 do {
52660 zend_object *zobj = Z_OBJ_P(container);
52661 zend_string *name, *tmp_name;
52662 zval *retval;
52663
52664 if (IS_CV == IS_CONST) {
52665 cache_slot = CACHE_ADDR(opline->extended_value);
52666
52667 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
52668 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52669
52670 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52671fetch_obj_is_simple:
52672 retval = OBJ_PROP(zobj, prop_offset);
52673 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
52674 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52675 goto fetch_obj_is_copy;
52676 } else {
52677fetch_obj_is_fast_copy:
52678 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52679 ZEND_VM_NEXT_OPCODE();
52680 }
52681 }
52682 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
52683 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
52684 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
52685 prop_offset = prop_info->offset;
52686 goto fetch_obj_is_simple;
52687 }
52688 /* Fall through to read_property for hooks. */
52689 } else if (EXPECTED(zobj->properties != NULL)) {
52690 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
52691 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52692 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
52693 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
52694
52695 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
52696 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
52697
52698 if (EXPECTED(p->key == name) ||
52699 (EXPECTED(p->h == ZSTR_H(name)) &&
52700 EXPECTED(p->key != NULL) &&
52701 EXPECTED(zend_string_equal_content(p->key, name)))) {
52702 retval = &p->val;
52703 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52704 goto fetch_obj_is_copy;
52705 } else {
52706 goto fetch_obj_is_fast_copy;
52707 }
52708 }
52709 }
52710 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
52711 }
52712 retval = zend_hash_find_known_hash(zobj->properties, name);
52713 if (EXPECTED(retval)) {
52714 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
52715 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
52716 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52717 goto fetch_obj_is_copy;
52718 } else {
52719 goto fetch_obj_is_fast_copy;
52720 }
52721 }
52722 }
52723 }
52724 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52725 } else {
52726 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52727 if (UNEXPECTED(!name)) {
52728 ZVAL_UNDEF(EX_VAR(opline->result.var));
52729 break;
52730 }
52731 }
52732
52733 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
52734
52735 if (IS_CV != IS_CONST) {
52736 zend_tmp_string_release(tmp_name);
52737 }
52738
52739 if (retval != EX_VAR(opline->result.var)) {
52740fetch_obj_is_copy:
52741 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52742 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
52743 zend_unwrap_reference(retval);
52744 }
52745 } while (0);
52746
52747fetch_obj_is_finish:
52748
52749
52750 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52751}
52752
52753static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52754{
52755#if 0
52756 USE_OPLINE
52757#endif
52758
52759 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
52760 /* Behave like FETCH_OBJ_W */
52761 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
52762 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52763 }
52764 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52765 } else {
52766 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52767 }
52768}
52769
52770static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52771{
52772 USE_OPLINE
52773 zval *container, *property, *result;
52774
52775 SAVE_OPLINE();
52776 container = EX_VAR(opline->op1.var);
52777 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52778 result = EX_VAR(opline->result.var);
52779 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);
52780
52781 if (IS_CV == IS_VAR) {
52782 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52783 }
52784 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52785}
52786
52787static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52788{
52789 USE_OPLINE
52790 zval *object, *value, tmp;
52791 zend_object *zobj;
52792 zend_string *name, *tmp_name;
52793 zend_refcounted *garbage = NULL;
52794
52795 SAVE_OPLINE();
52796 object = EX_VAR(opline->op1.var);
52797 value = RT_CONSTANT((opline+1), (opline+1)->op1);
52798
52799 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52800 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52801 object = Z_REFVAL_P(object);
52802 goto assign_object;
52803 }
52804 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
52805 value = &EG(uninitialized_zval);
52806 goto free_and_exit_assign_obj;
52807 }
52808
52809assign_object:
52810 zobj = Z_OBJ_P(object);
52811 if (IS_CV == IS_CONST) {
52812 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
52813 void **cache_slot = CACHE_ADDR(opline->extended_value);
52814 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52815 zval *property_val;
52816 zend_property_info *prop_info;
52817
52818 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52819 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
52820
52821assign_obj_simple:
52822 property_val = OBJ_PROP(zobj, prop_offset);
52823 if (Z_TYPE_P(property_val) != IS_UNDEF) {
52824 if (prop_info != NULL) {
52825 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
52826 goto free_and_exit_assign_obj;
52827 } else {
52828fast_assign_obj:
52829 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
52830 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52831 ZVAL_COPY(EX_VAR(opline->result.var), value);
52832 }
52833 goto exit_assign_obj;
52834 }
52835 }
52836 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
52837 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52838 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
52839 zobj = zend_lazy_object_init(zobj);
52840 if (!zobj) {
52841 value = &EG(uninitialized_zval);
52842 goto free_and_exit_assign_obj;
52843 }
52844 }
52845 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
52846 rebuild_object_properties_internal(zobj);
52847 }
52848 if (EXPECTED(zobj->properties != NULL)) {
52849 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
52850 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
52851 GC_DELREF(zobj->properties);
52852 }
52853 zobj->properties = zend_array_dup(zobj->properties);
52854 }
52855 property_val = zend_hash_find_known_hash(zobj->properties, name);
52856 if (property_val) {
52857 goto fast_assign_obj;
52858 }
52859 }
52860
52861 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
52862 if (IS_CONST == IS_CONST) {
52863 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
52864 Z_ADDREF_P(value);
52865 }
52866 } else if (IS_CONST != IS_TMP_VAR) {
52867 if (Z_ISREF_P(value)) {
52868 if (IS_CONST == IS_VAR) {
52869 zend_reference *ref = Z_REF_P(value);
52870 if (GC_DELREF(ref) == 0) {
52871 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
52872 efree_size(ref, sizeof(zend_reference));
52873 value = &tmp;
52874 } else {
52875 value = Z_REFVAL_P(value);
52876 Z_TRY_ADDREF_P(value);
52877 }
52878 } else {
52879 value = Z_REFVAL_P(value);
52880 Z_TRY_ADDREF_P(value);
52881 }
52882 } else if (IS_CONST == IS_CV) {
52883 Z_TRY_ADDREF_P(value);
52884 }
52885 }
52886 zend_hash_add_new(zobj->properties, name, value);
52887 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52888 ZVAL_COPY(EX_VAR(opline->result.var), value);
52889 }
52890 goto exit_assign_obj;
52891 }
52892 } else {
52893 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
52894 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
52895 prop_info = CACHED_PTR_EX(cache_slot + 2);
52896 prop_offset = prop_info->offset;
52897 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
52898 prop_info = NULL;
52899 }
52900 goto assign_obj_simple;
52901 }
52902 /* Fall through to write_property for hooks. */
52903 }
52904 }
52905 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52906 } else {
52907 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52908 if (UNEXPECTED(!name)) {
52909
52910 UNDEF_RESULT();
52911 goto exit_assign_obj;
52912 }
52913 }
52914
52915 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
52916 ZVAL_DEREF(value);
52917 }
52918
52919 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
52920
52921 if (IS_CV != IS_CONST) {
52922 zend_tmp_string_release(tmp_name);
52923 }
52924
52925free_and_exit_assign_obj:
52926 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
52927 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
52928 }
52929
52930exit_assign_obj:
52931 if (garbage) {
52932 GC_DTOR_NO_REF(garbage);
52933 }
52934
52935
52936 /* assign_obj has two opcodes! */
52937 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52938}
52939
52940/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
52941static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52942{
52943 USE_OPLINE
52944 zval *object, *value, tmp;
52945 zend_object *zobj;
52946 zend_string *name, *tmp_name;
52947 zend_refcounted *garbage = NULL;
52948
52949 SAVE_OPLINE();
52950 object = EX_VAR(opline->op1.var);
52951 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
52952
52953 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52954 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52955 object = Z_REFVAL_P(object);
52956 goto assign_object;
52957 }
52958 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
52959 value = &EG(uninitialized_zval);
52960 goto free_and_exit_assign_obj;
52961 }
52962
52963assign_object:
52964 zobj = Z_OBJ_P(object);
52965 if (IS_CV == IS_CONST) {
52966 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
52967 void **cache_slot = CACHE_ADDR(opline->extended_value);
52968 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52969 zval *property_val;
52970 zend_property_info *prop_info;
52971
52972 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52973 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
52974
52975assign_obj_simple:
52976 property_val = OBJ_PROP(zobj, prop_offset);
52977 if (Z_TYPE_P(property_val) != IS_UNDEF) {
52978 if (prop_info != NULL) {
52979 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
52980 goto free_and_exit_assign_obj;
52981 } else {
52982fast_assign_obj:
52983 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
52984 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52985 ZVAL_COPY(EX_VAR(opline->result.var), value);
52986 }
52987 goto exit_assign_obj;
52988 }
52989 }
52990 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
52991 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52992 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
52993 zobj = zend_lazy_object_init(zobj);
52994 if (!zobj) {
52995 value = &EG(uninitialized_zval);
52996 goto free_and_exit_assign_obj;
52997 }
52998 }
52999 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53000 rebuild_object_properties_internal(zobj);
53001 }
53002 if (EXPECTED(zobj->properties != NULL)) {
53003 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
53004 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
53005 GC_DELREF(zobj->properties);
53006 }
53007 zobj->properties = zend_array_dup(zobj->properties);
53008 }
53009 property_val = zend_hash_find_known_hash(zobj->properties, name);
53010 if (property_val) {
53011 goto fast_assign_obj;
53012 }
53013 }
53014
53015 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53016 if (IS_TMP_VAR == IS_CONST) {
53017 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
53018 Z_ADDREF_P(value);
53019 }
53020 } else if (IS_TMP_VAR != IS_TMP_VAR) {
53021 if (Z_ISREF_P(value)) {
53022 if (IS_TMP_VAR == IS_VAR) {
53023 zend_reference *ref = Z_REF_P(value);
53024 if (GC_DELREF(ref) == 0) {
53025 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
53026 efree_size(ref, sizeof(zend_reference));
53027 value = &tmp;
53028 } else {
53029 value = Z_REFVAL_P(value);
53030 Z_TRY_ADDREF_P(value);
53031 }
53032 } else {
53033 value = Z_REFVAL_P(value);
53034 Z_TRY_ADDREF_P(value);
53035 }
53036 } else if (IS_TMP_VAR == IS_CV) {
53037 Z_TRY_ADDREF_P(value);
53038 }
53039 }
53040 zend_hash_add_new(zobj->properties, name, value);
53041 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53042 ZVAL_COPY(EX_VAR(opline->result.var), value);
53043 }
53044 goto exit_assign_obj;
53045 }
53046 } else {
53047 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
53048 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
53049 prop_info = CACHED_PTR_EX(cache_slot + 2);
53050 prop_offset = prop_info->offset;
53051 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
53052 prop_info = NULL;
53053 }
53054 goto assign_obj_simple;
53055 }
53056 /* Fall through to write_property for hooks. */
53057 }
53058 }
53059 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53060 } else {
53061 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53062 if (UNEXPECTED(!name)) {
53063 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53064 UNDEF_RESULT();
53065 goto exit_assign_obj;
53066 }
53067 }
53068
53069 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
53070 ZVAL_DEREF(value);
53071 }
53072
53073 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53074
53075 if (IS_CV != IS_CONST) {
53076 zend_tmp_string_release(tmp_name);
53077 }
53078
53079free_and_exit_assign_obj:
53080 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53081 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53082 }
53083 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53084exit_assign_obj:
53085 if (garbage) {
53086 GC_DTOR_NO_REF(garbage);
53087 }
53088
53089
53090 /* assign_obj has two opcodes! */
53091 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53092}
53093
53094/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
53095static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53096{
53097 USE_OPLINE
53098 zval *object, *value, tmp;
53099 zend_object *zobj;
53100 zend_string *name, *tmp_name;
53101 zend_refcounted *garbage = NULL;
53102
53103 SAVE_OPLINE();
53104 object = EX_VAR(opline->op1.var);
53105 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53106
53107 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
53108 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
53109 object = Z_REFVAL_P(object);
53110 goto assign_object;
53111 }
53112 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
53113 value = &EG(uninitialized_zval);
53114 goto free_and_exit_assign_obj;
53115 }
53116
53117assign_object:
53118 zobj = Z_OBJ_P(object);
53119 if (IS_CV == IS_CONST) {
53120 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
53121 void **cache_slot = CACHE_ADDR(opline->extended_value);
53122 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
53123 zval *property_val;
53124 zend_property_info *prop_info;
53125
53126 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
53127 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
53128
53129assign_obj_simple:
53130 property_val = OBJ_PROP(zobj, prop_offset);
53131 if (Z_TYPE_P(property_val) != IS_UNDEF) {
53132 if (prop_info != NULL) {
53133 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53134 goto free_and_exit_assign_obj;
53135 } else {
53136fast_assign_obj:
53137 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
53138 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53139 ZVAL_COPY(EX_VAR(opline->result.var), value);
53140 }
53141 goto exit_assign_obj;
53142 }
53143 }
53144 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
53145 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53146 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
53147 zobj = zend_lazy_object_init(zobj);
53148 if (!zobj) {
53149 value = &EG(uninitialized_zval);
53150 goto free_and_exit_assign_obj;
53151 }
53152 }
53153 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53154 rebuild_object_properties_internal(zobj);
53155 }
53156 if (EXPECTED(zobj->properties != NULL)) {
53157 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
53158 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
53159 GC_DELREF(zobj->properties);
53160 }
53161 zobj->properties = zend_array_dup(zobj->properties);
53162 }
53163 property_val = zend_hash_find_known_hash(zobj->properties, name);
53164 if (property_val) {
53165 goto fast_assign_obj;
53166 }
53167 }
53168
53169 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53170 if (IS_VAR == IS_CONST) {
53171 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
53172 Z_ADDREF_P(value);
53173 }
53174 } else if (IS_VAR != IS_TMP_VAR) {
53175 if (Z_ISREF_P(value)) {
53176 if (IS_VAR == IS_VAR) {
53177 zend_reference *ref = Z_REF_P(value);
53178 if (GC_DELREF(ref) == 0) {
53179 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
53180 efree_size(ref, sizeof(zend_reference));
53181 value = &tmp;
53182 } else {
53183 value = Z_REFVAL_P(value);
53184 Z_TRY_ADDREF_P(value);
53185 }
53186 } else {
53187 value = Z_REFVAL_P(value);
53188 Z_TRY_ADDREF_P(value);
53189 }
53190 } else if (IS_VAR == IS_CV) {
53191 Z_TRY_ADDREF_P(value);
53192 }
53193 }
53194 zend_hash_add_new(zobj->properties, name, value);
53195 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53196 ZVAL_COPY(EX_VAR(opline->result.var), value);
53197 }
53198 goto exit_assign_obj;
53199 }
53200 } else {
53201 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
53202 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
53203 prop_info = CACHED_PTR_EX(cache_slot + 2);
53204 prop_offset = prop_info->offset;
53205 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
53206 prop_info = NULL;
53207 }
53208 goto assign_obj_simple;
53209 }
53210 /* Fall through to write_property for hooks. */
53211 }
53212 }
53213 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53214 } else {
53215 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53216 if (UNEXPECTED(!name)) {
53217 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53218 UNDEF_RESULT();
53219 goto exit_assign_obj;
53220 }
53221 }
53222
53223 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
53224 ZVAL_DEREF(value);
53225 }
53226
53227 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53228
53229 if (IS_CV != IS_CONST) {
53230 zend_tmp_string_release(tmp_name);
53231 }
53232
53233free_and_exit_assign_obj:
53234 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53235 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53236 }
53237 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53238exit_assign_obj:
53239 if (garbage) {
53240 GC_DTOR_NO_REF(garbage);
53241 }
53242
53243
53244 /* assign_obj has two opcodes! */
53245 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53246}
53247
53248/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
53249static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53250{
53251 USE_OPLINE
53252 zval *object, *value, tmp;
53253 zend_object *zobj;
53254 zend_string *name, *tmp_name;
53255 zend_refcounted *garbage = NULL;
53256
53257 SAVE_OPLINE();
53258 object = EX_VAR(opline->op1.var);
53259 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
53260
53261 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
53262 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
53263 object = Z_REFVAL_P(object);
53264 goto assign_object;
53265 }
53266 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
53267 value = &EG(uninitialized_zval);
53268 goto free_and_exit_assign_obj;
53269 }
53270
53271assign_object:
53272 zobj = Z_OBJ_P(object);
53273 if (IS_CV == IS_CONST) {
53274 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
53275 void **cache_slot = CACHE_ADDR(opline->extended_value);
53276 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
53277 zval *property_val;
53278 zend_property_info *prop_info;
53279
53280 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
53281 prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
53282
53283assign_obj_simple:
53284 property_val = OBJ_PROP(zobj, prop_offset);
53285 if (Z_TYPE_P(property_val) != IS_UNDEF) {
53286 if (prop_info != NULL) {
53287 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53288 goto free_and_exit_assign_obj;
53289 } else {
53290fast_assign_obj:
53291 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
53292 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53293 ZVAL_COPY(EX_VAR(opline->result.var), value);
53294 }
53295 goto exit_assign_obj;
53296 }
53297 }
53298 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
53299 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53300 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
53301 zobj = zend_lazy_object_init(zobj);
53302 if (!zobj) {
53303 value = &EG(uninitialized_zval);
53304 goto free_and_exit_assign_obj;
53305 }
53306 }
53307 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53308 rebuild_object_properties_internal(zobj);
53309 }
53310 if (EXPECTED(zobj->properties != NULL)) {
53311 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
53312 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
53313 GC_DELREF(zobj->properties);
53314 }
53315 zobj->properties = zend_array_dup(zobj->properties);
53316 }
53317 property_val = zend_hash_find_known_hash(zobj->properties, name);
53318 if (property_val) {
53319 goto fast_assign_obj;
53320 }
53321 }
53322
53323 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53324 if (IS_CV == IS_CONST) {
53325 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
53326 Z_ADDREF_P(value);
53327 }
53328 } else if (IS_CV != IS_TMP_VAR) {
53329 if (Z_ISREF_P(value)) {
53330 if (IS_CV == IS_VAR) {
53331 zend_reference *ref = Z_REF_P(value);
53332 if (GC_DELREF(ref) == 0) {
53333 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
53334 efree_size(ref, sizeof(zend_reference));
53335 value = &tmp;
53336 } else {
53337 value = Z_REFVAL_P(value);
53338 Z_TRY_ADDREF_P(value);
53339 }
53340 } else {
53341 value = Z_REFVAL_P(value);
53342 Z_TRY_ADDREF_P(value);
53343 }
53344 } else if (IS_CV == IS_CV) {
53345 Z_TRY_ADDREF_P(value);
53346 }
53347 }
53348 zend_hash_add_new(zobj->properties, name, value);
53349 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53350 ZVAL_COPY(EX_VAR(opline->result.var), value);
53351 }
53352 goto exit_assign_obj;
53353 }
53354 } else {
53355 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
53356 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
53357 prop_info = CACHED_PTR_EX(cache_slot + 2);
53358 prop_offset = prop_info->offset;
53359 if (!ZEND_TYPE_IS_SET(prop_info->type)) {
53360 prop_info = NULL;
53361 }
53362 goto assign_obj_simple;
53363 }
53364 /* Fall through to write_property for hooks. */
53365 }
53366 }
53367 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53368 } else {
53369 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53370 if (UNEXPECTED(!name)) {
53371
53372 UNDEF_RESULT();
53373 goto exit_assign_obj;
53374 }
53375 }
53376
53377 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
53378 ZVAL_DEREF(value);
53379 }
53380
53381 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53382
53383 if (IS_CV != IS_CONST) {
53384 zend_tmp_string_release(tmp_name);
53385 }
53386
53387free_and_exit_assign_obj:
53388 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53389 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53390 }
53391
53392exit_assign_obj:
53393 if (garbage) {
53394 GC_DTOR_NO_REF(garbage);
53395 }
53396
53397
53398 /* assign_obj has two opcodes! */
53399 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53400}
53401
53402/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
53403static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53404{
53405 USE_OPLINE
53406 zval *object_ptr, *orig_object_ptr;
53407 zval *value;
53408 zval *variable_ptr;
53409 zval *dim;
53410 zend_refcounted *garbage = NULL;
53411
53412 SAVE_OPLINE();
53413 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53414
53415 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53416try_assign_dim_array:
53417 SEPARATE_ARRAY(object_ptr);
53418 if (IS_CV == IS_UNUSED) {
53419 value = RT_CONSTANT((opline+1), (opline+1)->op1);
53420 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53421 HashTable *ht = Z_ARRVAL_P(object_ptr);
53422 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53423 GC_ADDREF(ht);
53424 }
53425 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53426 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53427 zend_array_destroy(ht);
53428 goto assign_dim_error;
53429 }
53430 }
53431 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
53432 ZVAL_DEREF(value);
53433 }
53434 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53435 if (UNEXPECTED(value == NULL)) {
53436 zend_cannot_add_element();
53437 goto assign_dim_error;
53438 } else if (IS_CONST == IS_CV) {
53439 if (Z_REFCOUNTED_P(value)) {
53440 Z_ADDREF_P(value);
53441 }
53442 } else if (IS_CONST == IS_VAR) {
53443 zval *free_op_data = EX_VAR((opline+1)->op1.var);
53444 if (Z_ISREF_P(free_op_data)) {
53445 if (Z_REFCOUNTED_P(value)) {
53446 Z_ADDREF_P(value);
53447 }
53448 zval_ptr_dtor_nogc(free_op_data);
53449 }
53450 } else if (IS_CONST == IS_CONST) {
53451 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53452 Z_ADDREF_P(value);
53453 }
53454 }
53455 } else {
53456 dim = EX_VAR(opline->op2.var);
53457 if (IS_CV == IS_CONST) {
53458 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53459 } else {
53460 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53461 }
53462 if (UNEXPECTED(variable_ptr == NULL)) {
53463 goto assign_dim_error;
53464 }
53465 value = RT_CONSTANT((opline+1), (opline+1)->op1);
53466 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
53467 }
53468 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53469 ZVAL_COPY(EX_VAR(opline->result.var), value);
53470 }
53471 if (garbage) {
53472 GC_DTOR_NO_REF(garbage);
53473 }
53474 } else {
53475 if (EXPECTED(Z_ISREF_P(object_ptr))) {
53476 object_ptr = Z_REFVAL_P(object_ptr);
53477 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53478 goto try_assign_dim_array;
53479 }
53480 }
53481 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53482 zend_object *obj = Z_OBJ_P(object_ptr);
53483
53484 GC_ADDREF(obj);
53485 dim = EX_VAR(opline->op2.var);
53486 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53487 dim = ZVAL_UNDEFINED_OP2();
53488 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53489 dim++;
53490 }
53491
53492 value = RT_CONSTANT((opline+1), (opline+1)->op1);
53493 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53494 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53495 } else if (IS_CONST & (IS_CV|IS_VAR)) {
53496 ZVAL_DEREF(value);
53497 }
53498
53499 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53500
53501 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53502 zend_objects_store_del(obj);
53503 }
53504 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53505 if (IS_CV == IS_UNUSED) {
53506 zend_use_new_element_for_string();
53507
53508 UNDEF_RESULT();
53509 } else {
53510 dim = EX_VAR(opline->op2.var);
53511 value = RT_CONSTANT((opline+1), (opline+1)->op1);
53512 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53513
53514 }
53515 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53516 if (Z_ISREF_P(orig_object_ptr)
53517 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53518 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53519 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53520
53521 UNDEF_RESULT();
53522 } else {
53523 HashTable *ht = zend_new_array(8);
53524 uint8_t old_type = Z_TYPE_P(object_ptr);
53525
53526 ZVAL_ARR(object_ptr, ht);
53527 if (UNEXPECTED(old_type == IS_FALSE)) {
53528 GC_ADDREF(ht);
53529 zend_false_to_array_deprecated();
53530 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53531 zend_array_destroy(ht);
53532 goto assign_dim_error;
53533 }
53534 }
53535 goto try_assign_dim_array;
53536 }
53537 } else {
53538 zend_use_scalar_as_array();
53539 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53540assign_dim_error:
53541
53542 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53543 ZVAL_NULL(EX_VAR(opline->result.var));
53544 }
53545 }
53546 }
53547 if (IS_CV != IS_UNUSED) {
53548
53549 }
53550
53551 /* assign_dim has two opcodes! */
53552 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53553}
53554
53555static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53556{
53557 USE_OPLINE
53558 zval *object_ptr, *orig_object_ptr;
53559 zval *value;
53560 zval *variable_ptr;
53561 zval *dim;
53562 zend_refcounted *garbage = NULL;
53563
53564 SAVE_OPLINE();
53565 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53566
53567 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53568try_assign_dim_array:
53569 SEPARATE_ARRAY(object_ptr);
53570 if (IS_CV == IS_UNUSED) {
53571 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53572 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53573 HashTable *ht = Z_ARRVAL_P(object_ptr);
53574 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53575 GC_ADDREF(ht);
53576 }
53577 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53578 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53579 zend_array_destroy(ht);
53580 goto assign_dim_error;
53581 }
53582 }
53583 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
53584 ZVAL_DEREF(value);
53585 }
53586 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53587 if (UNEXPECTED(value == NULL)) {
53588 zend_cannot_add_element();
53589 goto assign_dim_error;
53590 } else if (IS_TMP_VAR == IS_CV) {
53591 if (Z_REFCOUNTED_P(value)) {
53592 Z_ADDREF_P(value);
53593 }
53594 } else if (IS_TMP_VAR == IS_VAR) {
53595 zval *free_op_data = EX_VAR((opline+1)->op1.var);
53596 if (Z_ISREF_P(free_op_data)) {
53597 if (Z_REFCOUNTED_P(value)) {
53598 Z_ADDREF_P(value);
53599 }
53600 zval_ptr_dtor_nogc(free_op_data);
53601 }
53602 } else if (IS_TMP_VAR == IS_CONST) {
53603 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53604 Z_ADDREF_P(value);
53605 }
53606 }
53607 } else {
53608 dim = EX_VAR(opline->op2.var);
53609 if (IS_CV == IS_CONST) {
53610 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53611 } else {
53612 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53613 }
53614 if (UNEXPECTED(variable_ptr == NULL)) {
53615 goto assign_dim_error;
53616 }
53617 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53618 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
53619 }
53620 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53621 ZVAL_COPY(EX_VAR(opline->result.var), value);
53622 }
53623 if (garbage) {
53624 GC_DTOR_NO_REF(garbage);
53625 }
53626 } else {
53627 if (EXPECTED(Z_ISREF_P(object_ptr))) {
53628 object_ptr = Z_REFVAL_P(object_ptr);
53629 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53630 goto try_assign_dim_array;
53631 }
53632 }
53633 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53634 zend_object *obj = Z_OBJ_P(object_ptr);
53635
53636 GC_ADDREF(obj);
53637 dim = EX_VAR(opline->op2.var);
53638 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53639 dim = ZVAL_UNDEFINED_OP2();
53640 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53641 dim++;
53642 }
53643
53644 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53645 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53646 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53647 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
53648 ZVAL_DEREF(value);
53649 }
53650
53651 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53652
53653 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53654 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53655 zend_objects_store_del(obj);
53656 }
53657 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53658 if (IS_CV == IS_UNUSED) {
53659 zend_use_new_element_for_string();
53660 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53661 UNDEF_RESULT();
53662 } else {
53663 dim = EX_VAR(opline->op2.var);
53664 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53665 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53666 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53667 }
53668 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53669 if (Z_ISREF_P(orig_object_ptr)
53670 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53671 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53672 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53673 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53674 UNDEF_RESULT();
53675 } else {
53676 HashTable *ht = zend_new_array(8);
53677 uint8_t old_type = Z_TYPE_P(object_ptr);
53678
53679 ZVAL_ARR(object_ptr, ht);
53680 if (UNEXPECTED(old_type == IS_FALSE)) {
53681 GC_ADDREF(ht);
53682 zend_false_to_array_deprecated();
53683 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53684 zend_array_destroy(ht);
53685 goto assign_dim_error;
53686 }
53687 }
53688 goto try_assign_dim_array;
53689 }
53690 } else {
53691 zend_use_scalar_as_array();
53692 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53693assign_dim_error:
53694 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53695 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53696 ZVAL_NULL(EX_VAR(opline->result.var));
53697 }
53698 }
53699 }
53700 if (IS_CV != IS_UNUSED) {
53701
53702 }
53703
53704 /* assign_dim has two opcodes! */
53705 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53706}
53707
53708static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53709{
53710 USE_OPLINE
53711 zval *object_ptr, *orig_object_ptr;
53712 zval *value;
53713 zval *variable_ptr;
53714 zval *dim;
53715 zend_refcounted *garbage = NULL;
53716
53717 SAVE_OPLINE();
53718 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53719
53720 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53721try_assign_dim_array:
53722 SEPARATE_ARRAY(object_ptr);
53723 if (IS_CV == IS_UNUSED) {
53724 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53725 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53726 HashTable *ht = Z_ARRVAL_P(object_ptr);
53727 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53728 GC_ADDREF(ht);
53729 }
53730 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53731 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53732 zend_array_destroy(ht);
53733 goto assign_dim_error;
53734 }
53735 }
53736 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
53737 ZVAL_DEREF(value);
53738 }
53739 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53740 if (UNEXPECTED(value == NULL)) {
53741 zend_cannot_add_element();
53742 goto assign_dim_error;
53743 } else if (IS_VAR == IS_CV) {
53744 if (Z_REFCOUNTED_P(value)) {
53745 Z_ADDREF_P(value);
53746 }
53747 } else if (IS_VAR == IS_VAR) {
53748 zval *free_op_data = EX_VAR((opline+1)->op1.var);
53749 if (Z_ISREF_P(free_op_data)) {
53750 if (Z_REFCOUNTED_P(value)) {
53751 Z_ADDREF_P(value);
53752 }
53753 zval_ptr_dtor_nogc(free_op_data);
53754 }
53755 } else if (IS_VAR == IS_CONST) {
53756 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53757 Z_ADDREF_P(value);
53758 }
53759 }
53760 } else {
53761 dim = EX_VAR(opline->op2.var);
53762 if (IS_CV == IS_CONST) {
53763 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53764 } else {
53765 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53766 }
53767 if (UNEXPECTED(variable_ptr == NULL)) {
53768 goto assign_dim_error;
53769 }
53770 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53771 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
53772 }
53773 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53774 ZVAL_COPY(EX_VAR(opline->result.var), value);
53775 }
53776 if (garbage) {
53777 GC_DTOR_NO_REF(garbage);
53778 }
53779 } else {
53780 if (EXPECTED(Z_ISREF_P(object_ptr))) {
53781 object_ptr = Z_REFVAL_P(object_ptr);
53782 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53783 goto try_assign_dim_array;
53784 }
53785 }
53786 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53787 zend_object *obj = Z_OBJ_P(object_ptr);
53788
53789 GC_ADDREF(obj);
53790 dim = EX_VAR(opline->op2.var);
53791 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53792 dim = ZVAL_UNDEFINED_OP2();
53793 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53794 dim++;
53795 }
53796
53797 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53798 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53799 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53800 } else if (IS_VAR & (IS_CV|IS_VAR)) {
53801 ZVAL_DEREF(value);
53802 }
53803
53804 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53805
53806 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53807 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53808 zend_objects_store_del(obj);
53809 }
53810 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53811 if (IS_CV == IS_UNUSED) {
53812 zend_use_new_element_for_string();
53813 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53814 UNDEF_RESULT();
53815 } else {
53816 dim = EX_VAR(opline->op2.var);
53817 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53818 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53819 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53820 }
53821 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53822 if (Z_ISREF_P(orig_object_ptr)
53823 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53824 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53825 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53826 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53827 UNDEF_RESULT();
53828 } else {
53829 HashTable *ht = zend_new_array(8);
53830 uint8_t old_type = Z_TYPE_P(object_ptr);
53831
53832 ZVAL_ARR(object_ptr, ht);
53833 if (UNEXPECTED(old_type == IS_FALSE)) {
53834 GC_ADDREF(ht);
53835 zend_false_to_array_deprecated();
53836 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53837 zend_array_destroy(ht);
53838 goto assign_dim_error;
53839 }
53840 }
53841 goto try_assign_dim_array;
53842 }
53843 } else {
53844 zend_use_scalar_as_array();
53845 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53846assign_dim_error:
53847 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53848 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53849 ZVAL_NULL(EX_VAR(opline->result.var));
53850 }
53851 }
53852 }
53853 if (IS_CV != IS_UNUSED) {
53854
53855 }
53856
53857 /* assign_dim has two opcodes! */
53858 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53859}
53860
53861static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53862{
53863 USE_OPLINE
53864 zval *object_ptr, *orig_object_ptr;
53865 zval *value;
53866 zval *variable_ptr;
53867 zval *dim;
53868 zend_refcounted *garbage = NULL;
53869
53870 SAVE_OPLINE();
53871 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53872
53873 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53874try_assign_dim_array:
53875 SEPARATE_ARRAY(object_ptr);
53876 if (IS_CV == IS_UNUSED) {
53877 value = EX_VAR((opline+1)->op1.var);
53878 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53879 HashTable *ht = Z_ARRVAL_P(object_ptr);
53880 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53881 GC_ADDREF(ht);
53882 }
53883 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53884 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53885 zend_array_destroy(ht);
53886 goto assign_dim_error;
53887 }
53888 }
53889 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
53890 ZVAL_DEREF(value);
53891 }
53892 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53893 if (UNEXPECTED(value == NULL)) {
53894 zend_cannot_add_element();
53895 goto assign_dim_error;
53896 } else if (IS_CV == IS_CV) {
53897 if (Z_REFCOUNTED_P(value)) {
53898 Z_ADDREF_P(value);
53899 }
53900 } else if (IS_CV == IS_VAR) {
53901 zval *free_op_data = EX_VAR((opline+1)->op1.var);
53902 if (Z_ISREF_P(free_op_data)) {
53903 if (Z_REFCOUNTED_P(value)) {
53904 Z_ADDREF_P(value);
53905 }
53906 zval_ptr_dtor_nogc(free_op_data);
53907 }
53908 } else if (IS_CV == IS_CONST) {
53909 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53910 Z_ADDREF_P(value);
53911 }
53912 }
53913 } else {
53914 dim = EX_VAR(opline->op2.var);
53915 if (IS_CV == IS_CONST) {
53916 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53917 } else {
53918 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53919 }
53920 if (UNEXPECTED(variable_ptr == NULL)) {
53921 goto assign_dim_error;
53922 }
53923 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
53924 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
53925 }
53926 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53927 ZVAL_COPY(EX_VAR(opline->result.var), value);
53928 }
53929 if (garbage) {
53930 GC_DTOR_NO_REF(garbage);
53931 }
53932 } else {
53933 if (EXPECTED(Z_ISREF_P(object_ptr))) {
53934 object_ptr = Z_REFVAL_P(object_ptr);
53935 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53936 goto try_assign_dim_array;
53937 }
53938 }
53939 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53940 zend_object *obj = Z_OBJ_P(object_ptr);
53941
53942 GC_ADDREF(obj);
53943 dim = EX_VAR(opline->op2.var);
53944 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53945 dim = ZVAL_UNDEFINED_OP2();
53946 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53947 dim++;
53948 }
53949
53950 value = EX_VAR((opline+1)->op1.var);
53951 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53952 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53953 } else if (IS_CV & (IS_CV|IS_VAR)) {
53954 ZVAL_DEREF(value);
53955 }
53956
53957 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53958
53959 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53960 zend_objects_store_del(obj);
53961 }
53962 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53963 if (IS_CV == IS_UNUSED) {
53964 zend_use_new_element_for_string();
53965
53966 UNDEF_RESULT();
53967 } else {
53968 dim = EX_VAR(opline->op2.var);
53969 value = EX_VAR((opline+1)->op1.var);
53970 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53971
53972 }
53973 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53974 if (Z_ISREF_P(orig_object_ptr)
53975 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53976 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53977 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53978
53979 UNDEF_RESULT();
53980 } else {
53981 HashTable *ht = zend_new_array(8);
53982 uint8_t old_type = Z_TYPE_P(object_ptr);
53983
53984 ZVAL_ARR(object_ptr, ht);
53985 if (UNEXPECTED(old_type == IS_FALSE)) {
53986 GC_ADDREF(ht);
53987 zend_false_to_array_deprecated();
53988 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53989 zend_array_destroy(ht);
53990 goto assign_dim_error;
53991 }
53992 }
53993 goto try_assign_dim_array;
53994 }
53995 } else {
53996 zend_use_scalar_as_array();
53997 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53998assign_dim_error:
53999
54000 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
54001 ZVAL_NULL(EX_VAR(opline->result.var));
54002 }
54003 }
54004 }
54005 if (IS_CV != IS_UNUSED) {
54006
54007 }
54008
54009 /* assign_dim has two opcodes! */
54010 ZEND_VM_NEXT_OPCODE_EX(1, 2);
54011}
54012
54013static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54014{
54015 USE_OPLINE
54016 zval *value;
54017 zval *variable_ptr;
54018
54019 SAVE_OPLINE();
54020 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54021 variable_ptr = EX_VAR(opline->op1.var);
54022
54023 if (0 || UNEXPECTED(0)) {
54024 zend_refcounted *garbage = NULL;
54025
54026 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
54027 if (UNEXPECTED(0)) {
54028 ZVAL_COPY(EX_VAR(opline->result.var), value);
54029 }
54030 if (garbage) {
54031 GC_DTOR_NO_REF(garbage);
54032 }
54033 } else {
54034 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
54035 }
54036
54037 /* zend_assign_to_variable() always takes care of op2, never free it! */
54038
54039 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54040}
54041
54042static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54043{
54044 USE_OPLINE
54045 zval *value;
54046 zval *variable_ptr;
54047
54048 SAVE_OPLINE();
54049 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54050 variable_ptr = EX_VAR(opline->op1.var);
54051
54052 if (0 || UNEXPECTED(1)) {
54053 zend_refcounted *garbage = NULL;
54054
54055 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
54056 if (UNEXPECTED(1)) {
54057 ZVAL_COPY(EX_VAR(opline->result.var), value);
54058 }
54059 if (garbage) {
54060 GC_DTOR_NO_REF(garbage);
54061 }
54062 } else {
54063 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
54064 }
54065
54066 /* zend_assign_to_variable() always takes care of op2, never free it! */
54067
54068 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54069}
54070
54071static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54072{
54073 USE_OPLINE
54074 zval *variable_ptr;
54075 zval *value_ptr;
54076 zend_refcounted *garbage = NULL;
54077
54078 SAVE_OPLINE();
54079 value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
54080 variable_ptr = EX_VAR(opline->op1.var);
54081
54082 if (IS_CV == IS_VAR &&
54083 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
54084
54085 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
54086 variable_ptr = &EG(uninitialized_zval);
54087 } else if (IS_CV == IS_VAR &&
54088 opline->extended_value == ZEND_RETURNS_FUNCTION &&
54089 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
54090
54091 variable_ptr = zend_wrong_assign_to_variable_reference(
54092 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
54093 } else {
54094 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
54095 }
54096
54097 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
54098 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
54099 }
54100
54101 if (garbage) {
54102 GC_DTOR(garbage);
54103 }
54104
54105
54106 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54107}
54108
54109static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54110{
54111 USE_OPLINE
54112 zval *property, *container, *value_ptr;
54113
54114 SAVE_OPLINE();
54115
54116 container = EX_VAR(opline->op1.var);
54117 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54118
54119 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
54120
54121 if (1) {
54122 if (IS_CV == IS_UNUSED) {
54123 if (IS_CV == IS_CONST) {
54124 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54125 } else {
54126 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54127 }
54128 } else {
54129 if (IS_CV == IS_CONST) {
54130 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54131 } else {
54132 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54133 }
54134 }
54135 } else {
54136 zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54137 }
54138
54139
54140 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
54141 ZEND_VM_NEXT_OPCODE_EX(1, 2);
54142}
54143
54144/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
54145static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54146{
54147 USE_OPLINE
54148 zval *property, *container, *value_ptr;
54149
54150 SAVE_OPLINE();
54151
54152 container = EX_VAR(opline->op1.var);
54153 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54154
54155 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
54156
54157 if (1) {
54158 if (IS_CV == IS_UNUSED) {
54159 if (IS_CV == IS_CONST) {
54160 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54161 } else {
54162 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54163 }
54164 } else {
54165 if (IS_CV == IS_CONST) {
54166 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54167 } else {
54168 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54169 }
54170 }
54171 } else {
54172 zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54173 }
54174
54175
54176
54177 ZEND_VM_NEXT_OPCODE_EX(1, 2);
54178}
54179
54180/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
54181static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54182{
54183 USE_OPLINE
54184 zval *op1, *op2;
54185 zend_string *op1_str, *op2_str, *str;
54186
54187
54188 op1 = EX_VAR(opline->op1.var);
54189 op2 = EX_VAR(opline->op2.var);
54190 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
54191 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
54192 zend_string *op1_str = Z_STR_P(op1);
54193 zend_string *op2_str = Z_STR_P(op2);
54194 zend_string *str;
54195 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
54196
54197 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
54198 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
54199 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
54200 } else {
54201 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
54202 }
54203 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54204 zend_string_release_ex(op1_str, 0);
54205 }
54206 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
54207 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
54208 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
54209 } else {
54210 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
54211 }
54212 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54213 zend_string_release_ex(op2_str, 0);
54214 }
54215 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
54216 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
54217 size_t len = ZSTR_LEN(op1_str);
54218
54219 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
54220 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54221 GC_ADD_FLAGS(str, flags);
54222 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54223 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54224 zend_string_release_ex(op2_str, 0);
54225 }
54226 } else {
54227 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
54228 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
54229 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54230 GC_ADD_FLAGS(str, flags);
54231 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54232 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54233 zend_string_release_ex(op1_str, 0);
54234 }
54235 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54236 zend_string_release_ex(op2_str, 0);
54237 }
54238 }
54239 ZEND_VM_NEXT_OPCODE();
54240 }
54241
54242 SAVE_OPLINE();
54243 if (IS_CV == IS_CONST) {
54244 op1_str = Z_STR_P(op1);
54245 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
54246 op1_str = zend_string_copy(Z_STR_P(op1));
54247 } else {
54248 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
54249 ZVAL_UNDEFINED_OP1();
54250 }
54251 op1_str = zval_get_string_func(op1);
54252 }
54253 if (IS_CV == IS_CONST) {
54254 op2_str = Z_STR_P(op2);
54255 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
54256 op2_str = zend_string_copy(Z_STR_P(op2));
54257 } else {
54258 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
54259 ZVAL_UNDEFINED_OP2();
54260 }
54261 op2_str = zval_get_string_func(op2);
54262 }
54263 do {
54264 if (IS_CV != IS_CONST) {
54265 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
54266 if (IS_CV == IS_CONST) {
54267 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
54268 GC_ADDREF(op2_str);
54269 }
54270 }
54271 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
54272 zend_string_release_ex(op1_str, 0);
54273 break;
54274 }
54275 }
54276 if (IS_CV != IS_CONST) {
54277 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
54278 if (IS_CV == IS_CONST) {
54279 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
54280 GC_ADDREF(op1_str);
54281 }
54282 }
54283 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
54284 zend_string_release_ex(op2_str, 0);
54285 break;
54286 }
54287 }
54288 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
54289 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
54290 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54291
54292 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
54293 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54294 if (IS_CV != IS_CONST) {
54295 zend_string_release_ex(op1_str, 0);
54296 }
54297 if (IS_CV != IS_CONST) {
54298 zend_string_release_ex(op2_str, 0);
54299 }
54300 } while (0);
54301
54302
54303 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54304}
54305
54306static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54307{
54308 USE_OPLINE
54309 zval *function_name;
54310 zval *object;
54311 zend_function *fbc;
54312 zend_class_entry *called_scope;
54313 zend_object *obj;
54314 zend_execute_data *call;
54315 uint32_t call_info;
54316
54317 SAVE_OPLINE();
54318
54319 object = EX_VAR(opline->op1.var);
54320
54321 if (IS_CV != IS_CONST) {
54322 function_name = EX_VAR(opline->op2.var);
54323 }
54324
54325 if (IS_CV != IS_CONST &&
54326 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
54327 do {
54328 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
54329 function_name = Z_REFVAL_P(function_name);
54330 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
54331 break;
54332 }
54333 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
54334 ZVAL_UNDEFINED_OP2();
54335 if (UNEXPECTED(EG(exception) != NULL)) {
54336
54337 HANDLE_EXCEPTION();
54338 }
54339 }
54340 zend_throw_error(NULL, "Method name must be a string");
54341
54342
54343 HANDLE_EXCEPTION();
54344 } while (0);
54345 }
54346
54347 if (IS_CV == IS_UNUSED) {
54348 obj = Z_OBJ_P(object);
54349 } else {
54350 do {
54351 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
54352 obj = Z_OBJ_P(object);
54353 } else {
54354 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
54355 zend_reference *ref = Z_REF_P(object);
54356
54357 object = &ref->val;
54358 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
54359 obj = Z_OBJ_P(object);
54360 if (IS_CV & IS_VAR) {
54361 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
54362 efree_size(ref, sizeof(zend_reference));
54363 } else {
54364 Z_ADDREF_P(object);
54365 }
54366 }
54367 break;
54368 }
54369 }
54370 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
54371 object = ZVAL_UNDEFINED_OP1();
54372 if (UNEXPECTED(EG(exception) != NULL)) {
54373 if (IS_CV != IS_CONST) {
54374
54375 }
54376 HANDLE_EXCEPTION();
54377 }
54378 }
54379 if (IS_CV == IS_CONST) {
54380 function_name = EX_VAR(opline->op2.var);
54381 }
54382 zend_invalid_method_call(object, function_name);
54383
54384
54385 HANDLE_EXCEPTION();
54386 }
54387 } while (0);
54388 }
54389
54390 called_scope = obj->ce;
54391
54392 if (IS_CV == IS_CONST &&
54393 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
54394 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
54395 } else {
54396 zend_object *orig_obj = obj;
54397
54398 if (IS_CV == IS_CONST) {
54399 function_name = EX_VAR(opline->op2.var);
54400 }
54401
54402 /* First, locate the function. */
54403 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
54404 if (UNEXPECTED(fbc == NULL)) {
54405 if (EXPECTED(!EG(exception))) {
54406 zend_undefined_method(orig_obj->ce, Z_STR_P(function_name));
54407 }
54408
54409 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
54410 zend_objects_store_del(orig_obj);
54411 }
54412 HANDLE_EXCEPTION();
54413 }
54414 if (IS_CV == IS_CONST &&
54415 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
54416 EXPECTED(obj == orig_obj)) {
54417 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
54418 }
54419 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
54420 GC_ADDREF(obj); /* For $this pointer */
54421 if (GC_DELREF(orig_obj) == 0) {
54422 zend_objects_store_del(orig_obj);
54423 }
54424 }
54425 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
54426 init_func_run_time_cache(&fbc->op_array);
54427 }
54428 }
54429
54430 if (IS_CV != IS_CONST) {
54431
54432 }
54433
54434 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
54435 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
54436 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
54437 zend_objects_store_del(obj);
54438 if (UNEXPECTED(EG(exception))) {
54439 HANDLE_EXCEPTION();
54440 }
54441 }
54442 /* call static method */
54443 obj = (zend_object*)called_scope;
54444 call_info = ZEND_CALL_NESTED_FUNCTION;
54445 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
54446 if (IS_CV == IS_CV) {
54447 GC_ADDREF(obj); /* For $this pointer */
54448 }
54449 /* CV may be changed indirectly (e.g. when it's a reference) */
54450 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
54451 }
54452
54453 call = zend_vm_stack_push_call_frame(call_info,
54454 fbc, opline->extended_value, obj);
54455 call->prev_execute_data = EX(call);
54456 EX(call) = call;
54457
54458 ZEND_VM_NEXT_OPCODE();
54459}
54460
54461static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54462{
54463 USE_OPLINE
54464 zval *expr_ptr, new_expr;
54465
54466 SAVE_OPLINE();
54467 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
54468 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
54469 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
54470 if (Z_ISREF_P(expr_ptr)) {
54471 Z_ADDREF_P(expr_ptr);
54472 } else {
54473 ZVAL_MAKE_REF_EX(expr_ptr, 2);
54474 }
54475
54476 } else {
54477 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
54478 if (IS_CV == IS_TMP_VAR) {
54479 /* pass */
54480 } else if (IS_CV == IS_CONST) {
54481 Z_TRY_ADDREF_P(expr_ptr);
54482 } else if (IS_CV == IS_CV) {
54483 ZVAL_DEREF(expr_ptr);
54484 Z_TRY_ADDREF_P(expr_ptr);
54485 } else /* if (IS_CV == IS_VAR) */ {
54486 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
54487 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
54488
54489 expr_ptr = Z_REFVAL_P(expr_ptr);
54490 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
54491 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
54492 expr_ptr = &new_expr;
54493 efree_size(ref, sizeof(zend_reference));
54494 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
54495 Z_ADDREF_P(expr_ptr);
54496 }
54497 }
54498 }
54499 }
54500
54501 if (IS_CV != IS_UNUSED) {
54502 zval *offset = EX_VAR(opline->op2.var);
54503 zend_string *str;
54504 zend_ulong hval;
54505
54506add_again:
54507 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54508 str = Z_STR_P(offset);
54509 if (IS_CV != IS_CONST) {
54510 if (ZEND_HANDLE_NUMERIC(str, hval)) {
54511 goto num_index;
54512 }
54513 }
54514str_index:
54515 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
54516 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54517 hval = Z_LVAL_P(offset);
54518num_index:
54519 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
54520 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
54521 offset = Z_REFVAL_P(offset);
54522 goto add_again;
54523 } else if (Z_TYPE_P(offset) == IS_NULL) {
54524 str = ZSTR_EMPTY_ALLOC();
54525 goto str_index;
54526 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
54527 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
54528 goto num_index;
54529 } else if (Z_TYPE_P(offset) == IS_FALSE) {
54530 hval = 0;
54531 goto num_index;
54532 } else if (Z_TYPE_P(offset) == IS_TRUE) {
54533 hval = 1;
54534 goto num_index;
54535 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
54536 zend_use_resource_as_offset(offset);
54537 hval = Z_RES_HANDLE_P(offset);
54538 goto num_index;
54539 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
54540 ZVAL_UNDEFINED_OP2();
54541 str = ZSTR_EMPTY_ALLOC();
54542 goto str_index;
54543 } else {
54544 zend_illegal_array_offset_access(offset);
54545 zval_ptr_dtor_nogc(expr_ptr);
54546 }
54547
54548 } else {
54549 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
54550 zend_cannot_add_element();
54551 zval_ptr_dtor_nogc(expr_ptr);
54552 }
54553 }
54554 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54555}
54556
54557static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54558{
54559 zval *array;
54560 uint32_t size;
54561 USE_OPLINE
54562
54563 SAVE_OPLINE();
54564 array = EX_VAR(opline->result.var);
54565 if (IS_CV != IS_UNUSED) {
54566 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
54567 ZVAL_ARR(array, zend_new_array(size));
54568 /* Explicitly initialize array as not-packed if flag is set */
54569 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
54570 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
54571 }
54572 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
54573 } else {
54574 ZVAL_ARR(array, zend_new_array(0));
54575 ZEND_VM_NEXT_OPCODE();
54576 }
54577}
54578
54579static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54580{
54581 USE_OPLINE
54582 zval *container;
54583 zval *offset;
54584 zend_ulong hval;
54585 zend_string *key;
54586
54587 SAVE_OPLINE();
54588 container = EX_VAR(opline->op1.var);
54589 offset = EX_VAR(opline->op2.var);
54590
54591 do {
54592 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54593 HashTable *ht;
54594
54595unset_dim_array:
54596 SEPARATE_ARRAY(container);
54597 ht = Z_ARRVAL_P(container);
54598offset_again:
54599 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54600 key = Z_STR_P(offset);
54601 if (IS_CV != IS_CONST) {
54602 if (ZEND_HANDLE_NUMERIC(key, hval)) {
54603 goto num_index_dim;
54604 }
54605 }
54606str_index_dim:
54607 ZEND_ASSERT(ht != &EG(symbol_table));
54608 zend_hash_del(ht, key);
54609 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54610 hval = Z_LVAL_P(offset);
54611num_index_dim:
54612 zend_hash_index_del(ht, hval);
54613 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
54614 offset = Z_REFVAL_P(offset);
54615 goto offset_again;
54616 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
54617 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
54618 goto num_index_dim;
54619 } else if (Z_TYPE_P(offset) == IS_NULL) {
54620 key = ZSTR_EMPTY_ALLOC();
54621 goto str_index_dim;
54622 } else if (Z_TYPE_P(offset) == IS_FALSE) {
54623 hval = 0;
54624 goto num_index_dim;
54625 } else if (Z_TYPE_P(offset) == IS_TRUE) {
54626 hval = 1;
54627 goto num_index_dim;
54628 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
54629 zend_use_resource_as_offset(offset);
54630 hval = Z_RES_HANDLE_P(offset);
54631 goto num_index_dim;
54632 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
54633 ZVAL_UNDEFINED_OP2();
54634 key = ZSTR_EMPTY_ALLOC();
54635 goto str_index_dim;
54636 } else {
54637 zend_illegal_array_offset_unset(offset);
54638 }
54639 break;
54640 } else if (Z_ISREF_P(container)) {
54641 container = Z_REFVAL_P(container);
54642 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54643 goto unset_dim_array;
54644 }
54645 }
54646 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
54647 container = ZVAL_UNDEFINED_OP1();
54648 }
54649 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
54650 offset = ZVAL_UNDEFINED_OP2();
54651 }
54652 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
54653 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
54654 offset++;
54655 }
54656 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
54657 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
54658 zend_throw_error(NULL, "Cannot unset string offsets");
54659 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
54660 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
54661 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
54662 zend_false_to_array_deprecated();
54663 }
54664 } while (0);
54665
54666
54667 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54668}
54669
54670static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54671{
54672 USE_OPLINE
54673 zval *container;
54674 zval *offset;
54675 zend_string *name, *tmp_name;
54676
54677 SAVE_OPLINE();
54678 container = EX_VAR(opline->op1.var);
54679 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54680
54681 do {
54682 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
54683 if (Z_ISREF_P(container)) {
54684 container = Z_REFVAL_P(container);
54685 if (Z_TYPE_P(container) != IS_OBJECT) {
54686 if (IS_CV == IS_CV
54687 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
54688 ZVAL_UNDEFINED_OP1();
54689 }
54690 break;
54691 }
54692 } else {
54693 break;
54694 }
54695 }
54696 if (IS_CV == IS_CONST) {
54697 name = Z_STR_P(offset);
54698 } else {
54699 name = zval_try_get_tmp_string(offset, &tmp_name);
54700 if (UNEXPECTED(!name)) {
54701 break;
54702 }
54703 }
54704 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
54705 if (IS_CV != IS_CONST) {
54706 zend_tmp_string_release(tmp_name);
54707 }
54708 } while (0);
54709
54710
54711 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54712}
54713
54714static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54715{
54716 USE_OPLINE
54717 zval *container;
54718 bool result;
54719 zend_ulong hval;
54720 zval *offset;
54721
54722 SAVE_OPLINE();
54723 container = EX_VAR(opline->op1.var);
54724 offset = EX_VAR(opline->op2.var);
54725
54726 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54727 HashTable *ht;
54728 zval *value;
54729 zend_string *str;
54730
54731isset_dim_obj_array:
54732 ht = Z_ARRVAL_P(container);
54733isset_again:
54734 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54735 str = Z_STR_P(offset);
54736 if (IS_CV != IS_CONST) {
54737 if (ZEND_HANDLE_NUMERIC(str, hval)) {
54738 goto num_index_prop;
54739 }
54740 }
54741 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
54742 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54743 hval = Z_LVAL_P(offset);
54744num_index_prop:
54745 value = zend_hash_index_find(ht, hval);
54746 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
54747 offset = Z_REFVAL_P(offset);
54748 goto isset_again;
54749 } else {
54750 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
54751 if (UNEXPECTED(EG(exception))) {
54752 result = 0;
54753 goto isset_dim_obj_exit;
54754 }
54755 }
54756
54757 if (!(opline->extended_value & ZEND_ISEMPTY)) {
54758 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
54759 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
54760 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
54761
54762 if (IS_CV & (IS_CONST|IS_CV)) {
54763 /* avoid exception check */
54764
54765 ZEND_VM_SMART_BRANCH(result, 0);
54766 }
54767 } else {
54768 result = (value == NULL || !i_zend_is_true(value));
54769 }
54770 goto isset_dim_obj_exit;
54771 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
54772 container = Z_REFVAL_P(container);
54773 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54774 goto isset_dim_obj_array;
54775 }
54776 }
54777
54778 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
54779 offset++;
54780 }
54781 if (!(opline->extended_value & ZEND_ISEMPTY)) {
54782 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
54783 } else {
54784 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
54785 }
54786
54787isset_dim_obj_exit:
54788
54789
54790 ZEND_VM_SMART_BRANCH(result, 1);
54791}
54792
54793static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54794{
54795 USE_OPLINE
54796 zval *container;
54797 int result;
54798 zval *offset;
54799 zend_string *name, *tmp_name;
54800
54801 SAVE_OPLINE();
54802 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
54803 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54804
54805 if (IS_CV == IS_CONST ||
54806 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
54807 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
54808 container = Z_REFVAL_P(container);
54809 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
54810 result = (opline->extended_value & ZEND_ISEMPTY);
54811 goto isset_object_finish;
54812 }
54813 } else {
54814 result = (opline->extended_value & ZEND_ISEMPTY);
54815 goto isset_object_finish;
54816 }
54817 }
54818
54819 if (IS_CV == IS_CONST) {
54820 name = Z_STR_P(offset);
54821 } else {
54822 name = zval_try_get_tmp_string(offset, &tmp_name);
54823 if (UNEXPECTED(!name)) {
54824 result = 0;
54825 goto isset_object_finish;
54826 }
54827 }
54828
54829 result =
54830 (opline->extended_value & ZEND_ISEMPTY) ^
54831 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));
54832
54833 if (IS_CV != IS_CONST) {
54834 zend_tmp_string_release(tmp_name);
54835 }
54836
54837isset_object_finish:
54838
54839
54840 ZEND_VM_SMART_BRANCH(result, 1);
54841}
54842
54843static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54844{
54845 USE_OPLINE
54846
54847 zval *key, *subject;
54848 HashTable *ht;
54849 bool result;
54850
54851 SAVE_OPLINE();
54852
54853 key = EX_VAR(opline->op1.var);
54854 subject = EX_VAR(opline->op2.var);
54855
54856 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
54857array_key_exists_array:
54858 ht = Z_ARRVAL_P(subject);
54859 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
54860 } else {
54861 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
54862 subject = Z_REFVAL_P(subject);
54863 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
54864 goto array_key_exists_array;
54865 }
54866 }
54867 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
54868 result = 0;
54869 }
54870
54871
54872 ZEND_VM_SMART_BRANCH(result, 1);
54873}
54874
54875static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54876{
54877 USE_OPLINE
54878
54879 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
54880
54881 SAVE_OPLINE();
54882 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
54883 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
54884 }
54885
54886 /* Destroy the previously yielded value */
54887 zval_ptr_dtor(&generator->value);
54888
54889 /* Destroy the previously yielded key */
54890 zval_ptr_dtor(&generator->key);
54891
54892 /* Set the new yielded value */
54893 if (IS_CV != IS_UNUSED) {
54894 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
54895 /* Constants and temporary variables aren't yieldable by reference,
54896 * but we still allow them with a notice. */
54897 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
54898 zval *value;
54899
54900 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
54901
54902 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
54903 ZVAL_COPY_VALUE(&generator->value, value);
54904 if (IS_CV == IS_CONST) {
54905 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
54906 Z_ADDREF(generator->value);
54907 }
54908 }
54909 } else {
54910 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
54911
54912 /* If a function call result is yielded and the function did
54913 * not return by reference we throw a notice. */
54914 do {
54915 if (IS_CV == IS_VAR) {
54916 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
54917 if (opline->extended_value == ZEND_RETURNS_FUNCTION
54918 && !Z_ISREF_P(value_ptr)) {
54919 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
54920 ZVAL_COPY(&generator->value, value_ptr);
54921 break;
54922 }
54923 }
54924 if (Z_ISREF_P(value_ptr)) {
54925 Z_ADDREF_P(value_ptr);
54926 } else {
54927 ZVAL_MAKE_REF_EX(value_ptr, 2);
54928 }
54929 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
54930 } while (0);
54931
54932 }
54933 } else {
54934 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
54935
54936 /* Consts, temporary variables and references need copying */
54937 if (IS_CV == IS_CONST) {
54938 ZVAL_COPY_VALUE(&generator->value, value);
54939 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
54940 Z_ADDREF(generator->value);
54941 }
54942 } else if (IS_CV == IS_TMP_VAR) {
54943 ZVAL_COPY_VALUE(&generator->value, value);
54944 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
54945 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
54946
54947 } else {
54948 ZVAL_COPY_VALUE(&generator->value, value);
54949 if (IS_CV == IS_CV) {
54950 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
54951 }
54952 }
54953 }
54954 } else {
54955 /* If no value was specified yield null */
54956 ZVAL_NULL(&generator->value);
54957 }
54958
54959 /* Set the new yielded key */
54960 if (IS_CV != IS_UNUSED) {
54961 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54962 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
54963 key = Z_REFVAL_P(key);
54964 }
54965 ZVAL_COPY(&generator->key, key);
54966
54967 if (Z_TYPE(generator->key) == IS_LONG
54968 && Z_LVAL(generator->key) > generator->largest_used_integer_key
54969 ) {
54970 generator->largest_used_integer_key = Z_LVAL(generator->key);
54971 }
54972 } else {
54973 /* If no key was specified we use auto-increment keys */
54974 generator->largest_used_integer_key++;
54975 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
54976 }
54977
54978 if (RETURN_VALUE_USED(opline)) {
54979 /* If the return value of yield is used set the send
54980 * target and initialize it to NULL */
54981 generator->send_target = EX_VAR(opline->result.var);
54982 ZVAL_NULL(generator->send_target);
54983 } else {
54984 generator->send_target = NULL;
54985 }
54986
54987 /* The GOTO VM uses a local opline variable. We need to set the opline
54988 * variable in execute_data so we don't resume at an old position. */
54989 SAVE_OPLINE();
54990
54991 ZEND_VM_RETURN();
54992}
54993
54994static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54995{
54996 /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
54997 /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
54998 /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
54999 USE_OPLINE
55000 zval *op1, *op2;
55001 bool result;
55002
55003 op1 = EX_VAR(opline->op1.var);
55004 op2 = EX_VAR(opline->op2.var);
55005 result = fast_is_identical_function(op1, op2);
55006 /* Free is a no-op for const/cv */
55007 ZEND_VM_SMART_BRANCH(result, 0);
55008}
55009
55010static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
55011{
55012 USE_OPLINE
55013 zval *op1, *op2;
55014 bool result;
55015
55016 op1 = EX_VAR(opline->op1.var);
55017 op2 = EX_VAR(opline->op2.var);
55018 result = fast_is_identical_function(op1, op2);
55019 /* Free is a no-op for const/cv */
55020 ZEND_VM_SMART_BRANCH(!result, 0);
55021}
55022
55023static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
55024{
55025 USE_OPLINE
55026
55027 SAVE_OPLINE();
55028 zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);
55029 ZEND_VM_NEXT_OPCODE(); /* Never reached */
55030}
55031
55032
55033#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
55034# undef ZEND_VM_TAIL_CALL
55035# undef ZEND_VM_CONTINUE
55036# undef ZEND_VM_RETURN
55037
55038# define ZEND_VM_TAIL_CALL(call) call; ZEND_VM_CONTINUE()
55039# define ZEND_VM_CONTINUE() HYBRID_NEXT()
55040# define ZEND_VM_RETURN() goto HYBRID_HALT_LABEL
55041#endif
55042
55043
55044#if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
55045# pragma GCC push_options
55046# pragma GCC optimize("no-gcse")
55047# pragma GCC optimize("no-ivopts")
55048#endif
55049#ifdef _WIN64
55050/* See save_xmm_x86_64_ms_masm.asm */
55051void execute_ex_real(zend_execute_data *ex)
55052#else
55053ZEND_API void execute_ex(zend_execute_data *ex)
55054#endif
55055{
55056 DCL_OPLINE
55057
55058#if defined(__GNUC__) && defined(__aarch64__)
55059 __asm__ __volatile__ (""::: "v8","v9","v10","v11","v12","v13","v14","v15");
55060#endif
55061
55062#if defined(ZEND_VM_IP_GLOBAL_REG) || defined(ZEND_VM_FP_GLOBAL_REG)
55063 struct {
55064#ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
55065 char hybrid_jit_red_zone[ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE];
55066#endif
55067#ifdef ZEND_VM_IP_GLOBAL_REG
55068 const zend_op *orig_opline;
55069#endif
55070#ifdef ZEND_VM_FP_GLOBAL_REG
55071 zend_execute_data *orig_execute_data;
55072#endif
55073 } vm_stack_data;
55074#endif
55075#ifdef ZEND_VM_IP_GLOBAL_REG
55076 vm_stack_data.orig_opline = opline;
55077#endif
55078#ifdef ZEND_VM_FP_GLOBAL_REG
55079 vm_stack_data.orig_execute_data = execute_data;
55080 execute_data = ex;
55081#else
55082 zend_execute_data *execute_data = ex;
55083#endif
55084
55085#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
55086 if (UNEXPECTED(execute_data == NULL)) {
55087 static const void * const labels[] = {
55088 (void*)&&ZEND_NOP_SPEC_LABEL,
55089 (void*)&&ZEND_ADD_SPEC_CONST_CONST_LABEL,
55090 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55091 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55092 (void*)&&ZEND_NULL_LABEL,
55093 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55094 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55095 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55096 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55097 (void*)&&ZEND_NULL_LABEL,
55098 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55099 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55100 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55101 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55102 (void*)&&ZEND_NULL_LABEL,
55103 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55104 (void*)&&ZEND_NULL_LABEL,
55105 (void*)&&ZEND_NULL_LABEL,
55106 (void*)&&ZEND_NULL_LABEL,
55107 (void*)&&ZEND_NULL_LABEL,
55108 (void*)&&ZEND_NULL_LABEL,
55109 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55110 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55111 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55112 (void*)&&ZEND_NULL_LABEL,
55113 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55114 (void*)&&ZEND_SUB_SPEC_CONST_CONST_LABEL,
55115 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55116 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55117 (void*)&&ZEND_NULL_LABEL,
55118 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55119 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55120 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55121 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55122 (void*)&&ZEND_NULL_LABEL,
55123 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55124 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55125 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55126 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55127 (void*)&&ZEND_NULL_LABEL,
55128 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55129 (void*)&&ZEND_NULL_LABEL,
55130 (void*)&&ZEND_NULL_LABEL,
55131 (void*)&&ZEND_NULL_LABEL,
55132 (void*)&&ZEND_NULL_LABEL,
55133 (void*)&&ZEND_NULL_LABEL,
55134 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55135 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55136 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55137 (void*)&&ZEND_NULL_LABEL,
55138 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55139 (void*)&&ZEND_MUL_SPEC_CONST_CONST_LABEL,
55140 (void*)&&ZEND_NULL_LABEL,
55141 (void*)&&ZEND_NULL_LABEL,
55142 (void*)&&ZEND_NULL_LABEL,
55143 (void*)&&ZEND_NULL_LABEL,
55144 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55145 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55146 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55147 (void*)&&ZEND_NULL_LABEL,
55148 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55149 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55150 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55151 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55152 (void*)&&ZEND_NULL_LABEL,
55153 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55154 (void*)&&ZEND_NULL_LABEL,
55155 (void*)&&ZEND_NULL_LABEL,
55156 (void*)&&ZEND_NULL_LABEL,
55157 (void*)&&ZEND_NULL_LABEL,
55158 (void*)&&ZEND_NULL_LABEL,
55159 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55160 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55161 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55162 (void*)&&ZEND_NULL_LABEL,
55163 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55164 (void*)&&ZEND_DIV_SPEC_CONST_CONST_LABEL,
55165 (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
55166 (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
55167 (void*)&&ZEND_NULL_LABEL,
55168 (void*)&&ZEND_DIV_SPEC_CONST_CV_LABEL,
55169 (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
55170 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55171 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55172 (void*)&&ZEND_NULL_LABEL,
55173 (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
55174 (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
55175 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55176 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55177 (void*)&&ZEND_NULL_LABEL,
55178 (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
55179 (void*)&&ZEND_NULL_LABEL,
55180 (void*)&&ZEND_NULL_LABEL,
55181 (void*)&&ZEND_NULL_LABEL,
55182 (void*)&&ZEND_NULL_LABEL,
55183 (void*)&&ZEND_NULL_LABEL,
55184 (void*)&&ZEND_DIV_SPEC_CV_CONST_LABEL,
55185 (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
55186 (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
55187 (void*)&&ZEND_NULL_LABEL,
55188 (void*)&&ZEND_DIV_SPEC_CV_CV_LABEL,
55189 (void*)&&ZEND_MOD_SPEC_CONST_CONST_LABEL,
55190 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55191 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55192 (void*)&&ZEND_NULL_LABEL,
55193 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55194 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55195 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55196 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55197 (void*)&&ZEND_NULL_LABEL,
55198 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55199 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55200 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55201 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55202 (void*)&&ZEND_NULL_LABEL,
55203 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55204 (void*)&&ZEND_NULL_LABEL,
55205 (void*)&&ZEND_NULL_LABEL,
55206 (void*)&&ZEND_NULL_LABEL,
55207 (void*)&&ZEND_NULL_LABEL,
55208 (void*)&&ZEND_NULL_LABEL,
55209 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55210 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55211 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55212 (void*)&&ZEND_NULL_LABEL,
55213 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55214 (void*)&&ZEND_SL_SPEC_CONST_CONST_LABEL,
55215 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55216 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55217 (void*)&&ZEND_NULL_LABEL,
55218 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55219 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55220 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55221 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55222 (void*)&&ZEND_NULL_LABEL,
55223 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55224 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55225 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55226 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55227 (void*)&&ZEND_NULL_LABEL,
55228 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55229 (void*)&&ZEND_NULL_LABEL,
55230 (void*)&&ZEND_NULL_LABEL,
55231 (void*)&&ZEND_NULL_LABEL,
55232 (void*)&&ZEND_NULL_LABEL,
55233 (void*)&&ZEND_NULL_LABEL,
55234 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55235 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55236 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55237 (void*)&&ZEND_NULL_LABEL,
55238 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55239 (void*)&&ZEND_SR_SPEC_CONST_CONST_LABEL,
55240 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55241 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55242 (void*)&&ZEND_NULL_LABEL,
55243 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55244 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55245 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55246 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55247 (void*)&&ZEND_NULL_LABEL,
55248 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55249 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55250 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55251 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55252 (void*)&&ZEND_NULL_LABEL,
55253 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55254 (void*)&&ZEND_NULL_LABEL,
55255 (void*)&&ZEND_NULL_LABEL,
55256 (void*)&&ZEND_NULL_LABEL,
55257 (void*)&&ZEND_NULL_LABEL,
55258 (void*)&&ZEND_NULL_LABEL,
55259 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55260 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55261 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55262 (void*)&&ZEND_NULL_LABEL,
55263 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55264 (void*)&&ZEND_NULL_LABEL,
55265 (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
55266 (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
55267 (void*)&&ZEND_NULL_LABEL,
55268 (void*)&&ZEND_CONCAT_SPEC_CONST_CV_LABEL,
55269 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
55270 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55271 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55272 (void*)&&ZEND_NULL_LABEL,
55273 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
55274 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
55275 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55276 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55277 (void*)&&ZEND_NULL_LABEL,
55278 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
55279 (void*)&&ZEND_NULL_LABEL,
55280 (void*)&&ZEND_NULL_LABEL,
55281 (void*)&&ZEND_NULL_LABEL,
55282 (void*)&&ZEND_NULL_LABEL,
55283 (void*)&&ZEND_NULL_LABEL,
55284 (void*)&&ZEND_CONCAT_SPEC_CV_CONST_LABEL,
55285 (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
55286 (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
55287 (void*)&&ZEND_NULL_LABEL,
55288 (void*)&&ZEND_CONCAT_SPEC_CV_CV_LABEL,
55289 (void*)&&ZEND_BW_OR_SPEC_CONST_CONST_LABEL,
55290 (void*)&&ZEND_NULL_LABEL,
55291 (void*)&&ZEND_NULL_LABEL,
55292 (void*)&&ZEND_NULL_LABEL,
55293 (void*)&&ZEND_NULL_LABEL,
55294 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55295 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55296 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55297 (void*)&&ZEND_NULL_LABEL,
55298 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55299 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55300 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55301 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55302 (void*)&&ZEND_NULL_LABEL,
55303 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55304 (void*)&&ZEND_NULL_LABEL,
55305 (void*)&&ZEND_NULL_LABEL,
55306 (void*)&&ZEND_NULL_LABEL,
55307 (void*)&&ZEND_NULL_LABEL,
55308 (void*)&&ZEND_NULL_LABEL,
55309 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55310 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55311 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55312 (void*)&&ZEND_NULL_LABEL,
55313 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55314 (void*)&&ZEND_BW_AND_SPEC_CONST_CONST_LABEL,
55315 (void*)&&ZEND_NULL_LABEL,
55316 (void*)&&ZEND_NULL_LABEL,
55317 (void*)&&ZEND_NULL_LABEL,
55318 (void*)&&ZEND_NULL_LABEL,
55319 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55320 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55321 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55322 (void*)&&ZEND_NULL_LABEL,
55323 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55324 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55325 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55326 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55327 (void*)&&ZEND_NULL_LABEL,
55328 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55329 (void*)&&ZEND_NULL_LABEL,
55330 (void*)&&ZEND_NULL_LABEL,
55331 (void*)&&ZEND_NULL_LABEL,
55332 (void*)&&ZEND_NULL_LABEL,
55333 (void*)&&ZEND_NULL_LABEL,
55334 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55335 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55336 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55337 (void*)&&ZEND_NULL_LABEL,
55338 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55339 (void*)&&ZEND_BW_XOR_SPEC_CONST_CONST_LABEL,
55340 (void*)&&ZEND_NULL_LABEL,
55341 (void*)&&ZEND_NULL_LABEL,
55342 (void*)&&ZEND_NULL_LABEL,
55343 (void*)&&ZEND_NULL_LABEL,
55344 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55345 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55346 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55347 (void*)&&ZEND_NULL_LABEL,
55348 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55349 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55350 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55351 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55352 (void*)&&ZEND_NULL_LABEL,
55353 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55354 (void*)&&ZEND_NULL_LABEL,
55355 (void*)&&ZEND_NULL_LABEL,
55356 (void*)&&ZEND_NULL_LABEL,
55357 (void*)&&ZEND_NULL_LABEL,
55358 (void*)&&ZEND_NULL_LABEL,
55359 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55360 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55361 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55362 (void*)&&ZEND_NULL_LABEL,
55363 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55364 (void*)&&ZEND_POW_SPEC_CONST_CONST_LABEL,
55365 (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
55366 (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
55367 (void*)&&ZEND_NULL_LABEL,
55368 (void*)&&ZEND_POW_SPEC_CONST_CV_LABEL,
55369 (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
55370 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55371 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55372 (void*)&&ZEND_NULL_LABEL,
55373 (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
55374 (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
55375 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55376 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55377 (void*)&&ZEND_NULL_LABEL,
55378 (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
55379 (void*)&&ZEND_NULL_LABEL,
55380 (void*)&&ZEND_NULL_LABEL,
55381 (void*)&&ZEND_NULL_LABEL,
55382 (void*)&&ZEND_NULL_LABEL,
55383 (void*)&&ZEND_NULL_LABEL,
55384 (void*)&&ZEND_POW_SPEC_CV_CONST_LABEL,
55385 (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
55386 (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
55387 (void*)&&ZEND_NULL_LABEL,
55388 (void*)&&ZEND_POW_SPEC_CV_CV_LABEL,
55389 (void*)&&ZEND_BW_NOT_SPEC_CONST_LABEL,
55390 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55391 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55392 (void*)&&ZEND_NULL_LABEL,
55393 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55394 (void*)&&ZEND_BOOL_NOT_SPEC_CONST_LABEL,
55395 (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
55396 (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
55397 (void*)&&ZEND_NULL_LABEL,
55398 (void*)&&ZEND_BOOL_NOT_SPEC_CV_LABEL,
55399 (void*)&&ZEND_BOOL_XOR_SPEC_CONST_CONST_LABEL,
55400 (void*)&&ZEND_NULL_LABEL,
55401 (void*)&&ZEND_NULL_LABEL,
55402 (void*)&&ZEND_NULL_LABEL,
55403 (void*)&&ZEND_NULL_LABEL,
55404 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
55405 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55406 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55407 (void*)&&ZEND_NULL_LABEL,
55408 (void*)&&ZEND_NULL_LABEL,
55409 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
55410 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55411 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55412 (void*)&&ZEND_NULL_LABEL,
55413 (void*)&&ZEND_NULL_LABEL,
55414 (void*)&&ZEND_NULL_LABEL,
55415 (void*)&&ZEND_NULL_LABEL,
55416 (void*)&&ZEND_NULL_LABEL,
55417 (void*)&&ZEND_NULL_LABEL,
55418 (void*)&&ZEND_NULL_LABEL,
55419 (void*)&&ZEND_BOOL_XOR_SPEC_CV_CONST_LABEL,
55420 (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
55421 (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
55422 (void*)&&ZEND_NULL_LABEL,
55423 (void*)&&ZEND_BOOL_XOR_SPEC_CV_CV_LABEL,
55424 (void*)&&ZEND_IS_IDENTICAL_SPEC_CONST_CONST_LABEL,
55425 (void*)&&ZEND_NULL_LABEL,
55426 (void*)&&ZEND_NULL_LABEL,
55427 (void*)&&ZEND_NULL_LABEL,
55428 (void*)&&ZEND_NULL_LABEL,
55429 (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_CONST_LABEL,
55430 (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_TMP_LABEL,
55431 (void*)&&ZEND_NULL_LABEL,
55432 (void*)&&ZEND_NULL_LABEL,
55433 (void*)&&ZEND_NULL_LABEL,
55434 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_CONST_LABEL,
55435 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_TMP_LABEL,
55436 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_VAR_LABEL,
55437 (void*)&&ZEND_NULL_LABEL,
55438 (void*)&&ZEND_NULL_LABEL,
55439 (void*)&&ZEND_NULL_LABEL,
55440 (void*)&&ZEND_NULL_LABEL,
55441 (void*)&&ZEND_NULL_LABEL,
55442 (void*)&&ZEND_NULL_LABEL,
55443 (void*)&&ZEND_NULL_LABEL,
55444 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CONST_LABEL,
55445 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_TMP_LABEL,
55446 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_VAR_LABEL,
55447 (void*)&&ZEND_NULL_LABEL,
55448 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CV_LABEL,
55449 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_LABEL,
55450 (void*)&&ZEND_NULL_LABEL,
55451 (void*)&&ZEND_NULL_LABEL,
55452 (void*)&&ZEND_NULL_LABEL,
55453 (void*)&&ZEND_NULL_LABEL,
55454 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_LABEL,
55455 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_LABEL,
55456 (void*)&&ZEND_NULL_LABEL,
55457 (void*)&&ZEND_NULL_LABEL,
55458 (void*)&&ZEND_NULL_LABEL,
55459 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_LABEL,
55460 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_LABEL,
55461 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_LABEL,
55462 (void*)&&ZEND_NULL_LABEL,
55463 (void*)&&ZEND_NULL_LABEL,
55464 (void*)&&ZEND_NULL_LABEL,
55465 (void*)&&ZEND_NULL_LABEL,
55466 (void*)&&ZEND_NULL_LABEL,
55467 (void*)&&ZEND_NULL_LABEL,
55468 (void*)&&ZEND_NULL_LABEL,
55469 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_LABEL,
55470 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_LABEL,
55471 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_LABEL,
55472 (void*)&&ZEND_NULL_LABEL,
55473 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_LABEL,
55474 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55475 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55476 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55477 (void*)&&ZEND_NULL_LABEL,
55478 (void*)&&ZEND_NULL_LABEL,
55479 (void*)&&ZEND_NULL_LABEL,
55480 (void*)&&ZEND_NULL_LABEL,
55481 (void*)&&ZEND_NULL_LABEL,
55482 (void*)&&ZEND_NULL_LABEL,
55483 (void*)&&ZEND_NULL_LABEL,
55484 (void*)&&ZEND_NULL_LABEL,
55485 (void*)&&ZEND_NULL_LABEL,
55486 (void*)&&ZEND_NULL_LABEL,
55487 (void*)&&ZEND_NULL_LABEL,
55488 (void*)&&ZEND_NULL_LABEL,
55489 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55490 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55491 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55492 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55493 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55494 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55495 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55496 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55497 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55505 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55506 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55507 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55508 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55509 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55510 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55511 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55512 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55513 (void*)&&ZEND_NULL_LABEL,
55514 (void*)&&ZEND_NULL_LABEL,
55515 (void*)&&ZEND_NULL_LABEL,
55516 (void*)&&ZEND_NULL_LABEL,
55517 (void*)&&ZEND_NULL_LABEL,
55518 (void*)&&ZEND_NULL_LABEL,
55519 (void*)&&ZEND_NULL_LABEL,
55520 (void*)&&ZEND_NULL_LABEL,
55521 (void*)&&ZEND_NULL_LABEL,
55522 (void*)&&ZEND_NULL_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_NULL_LABEL,
55531 (void*)&&ZEND_NULL_LABEL,
55532 (void*)&&ZEND_NULL_LABEL,
55533 (void*)&&ZEND_NULL_LABEL,
55534 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_LABEL,
55535 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
55536 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
55537 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
55538 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55539 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55540 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
55541 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55542 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55543 (void*)&&ZEND_NULL_LABEL,
55544 (void*)&&ZEND_NULL_LABEL,
55545 (void*)&&ZEND_NULL_LABEL,
55546 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_LABEL,
55547 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
55548 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
55549 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55550 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55551 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55552 (void*)&&ZEND_NULL_LABEL,
55553 (void*)&&ZEND_NULL_LABEL,
55554 (void*)&&ZEND_NULL_LABEL,
55555 (void*)&&ZEND_NULL_LABEL,
55556 (void*)&&ZEND_NULL_LABEL,
55557 (void*)&&ZEND_NULL_LABEL,
55558 (void*)&&ZEND_NULL_LABEL,
55559 (void*)&&ZEND_NULL_LABEL,
55560 (void*)&&ZEND_NULL_LABEL,
55561 (void*)&&ZEND_NULL_LABEL,
55562 (void*)&&ZEND_NULL_LABEL,
55563 (void*)&&ZEND_NULL_LABEL,
55564 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55565 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55566 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55567 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55568 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55569 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55570 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55571 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55572 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55573 (void*)&&ZEND_NULL_LABEL,
55574 (void*)&&ZEND_NULL_LABEL,
55575 (void*)&&ZEND_NULL_LABEL,
55576 (void*)&&ZEND_NULL_LABEL,
55577 (void*)&&ZEND_NULL_LABEL,
55578 (void*)&&ZEND_NULL_LABEL,
55579 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55580 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55581 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55582 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55583 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55584 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55585 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55586 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55587 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55588 (void*)&&ZEND_NULL_LABEL,
55589 (void*)&&ZEND_NULL_LABEL,
55590 (void*)&&ZEND_NULL_LABEL,
55591 (void*)&&ZEND_NULL_LABEL,
55592 (void*)&&ZEND_NULL_LABEL,
55593 (void*)&&ZEND_NULL_LABEL,
55594 (void*)&&ZEND_NULL_LABEL,
55595 (void*)&&ZEND_NULL_LABEL,
55596 (void*)&&ZEND_NULL_LABEL,
55597 (void*)&&ZEND_NULL_LABEL,
55598 (void*)&&ZEND_NULL_LABEL,
55599 (void*)&&ZEND_NULL_LABEL,
55600 (void*)&&ZEND_NULL_LABEL,
55601 (void*)&&ZEND_NULL_LABEL,
55602 (void*)&&ZEND_NULL_LABEL,
55603 (void*)&&ZEND_NULL_LABEL,
55604 (void*)&&ZEND_NULL_LABEL,
55605 (void*)&&ZEND_NULL_LABEL,
55606 (void*)&&ZEND_NULL_LABEL,
55607 (void*)&&ZEND_NULL_LABEL,
55608 (void*)&&ZEND_NULL_LABEL,
55609 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_LABEL,
55610 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
55611 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
55612 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
55613 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55614 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55615 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
55616 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55617 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55618 (void*)&&ZEND_NULL_LABEL,
55619 (void*)&&ZEND_NULL_LABEL,
55620 (void*)&&ZEND_NULL_LABEL,
55621 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_LABEL,
55622 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
55623 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
55624 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55625 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55626 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55627 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55628 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55629 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55630 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55631 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55632 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55633 (void*)&&ZEND_NULL_LABEL,
55634 (void*)&&ZEND_NULL_LABEL,
55635 (void*)&&ZEND_NULL_LABEL,
55636 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55637 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55638 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55639 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55640 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55641 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55642 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55643 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55644 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55645 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55646 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55647 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55648 (void*)&&ZEND_NULL_LABEL,
55649 (void*)&&ZEND_NULL_LABEL,
55650 (void*)&&ZEND_NULL_LABEL,
55651 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55652 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55653 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55654 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55655 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55656 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55657 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55658 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55659 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55660 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55661 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55662 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55663 (void*)&&ZEND_NULL_LABEL,
55664 (void*)&&ZEND_NULL_LABEL,
55665 (void*)&&ZEND_NULL_LABEL,
55666 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55667 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55668 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55669 (void*)&&ZEND_NULL_LABEL,
55670 (void*)&&ZEND_NULL_LABEL,
55671 (void*)&&ZEND_NULL_LABEL,
55672 (void*)&&ZEND_NULL_LABEL,
55673 (void*)&&ZEND_NULL_LABEL,
55674 (void*)&&ZEND_NULL_LABEL,
55675 (void*)&&ZEND_NULL_LABEL,
55676 (void*)&&ZEND_NULL_LABEL,
55677 (void*)&&ZEND_NULL_LABEL,
55678 (void*)&&ZEND_NULL_LABEL,
55679 (void*)&&ZEND_NULL_LABEL,
55680 (void*)&&ZEND_NULL_LABEL,
55681 (void*)&&ZEND_NULL_LABEL,
55682 (void*)&&ZEND_NULL_LABEL,
55683 (void*)&&ZEND_NULL_LABEL,
55684 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55685 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55686 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55687 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55688 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55689 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55690 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55691 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55692 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55693 (void*)&&ZEND_NULL_LABEL,
55694 (void*)&&ZEND_NULL_LABEL,
55695 (void*)&&ZEND_NULL_LABEL,
55696 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55697 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55698 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55699 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55700 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55701 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55702 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55703 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55704 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55705 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55706 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55707 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55708 (void*)&&ZEND_NULL_LABEL,
55709 (void*)&&ZEND_NULL_LABEL,
55710 (void*)&&ZEND_NULL_LABEL,
55711 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55712 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55713 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55714 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55715 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55716 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55717 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55718 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55719 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55720 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55721 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55722 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55723 (void*)&&ZEND_NULL_LABEL,
55724 (void*)&&ZEND_NULL_LABEL,
55725 (void*)&&ZEND_NULL_LABEL,
55726 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55727 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55728 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55729 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55730 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55731 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55732 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55733 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55734 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55735 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55736 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55737 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55738 (void*)&&ZEND_NULL_LABEL,
55739 (void*)&&ZEND_NULL_LABEL,
55740 (void*)&&ZEND_NULL_LABEL,
55741 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55742 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55743 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55744 (void*)&&ZEND_NULL_LABEL,
55745 (void*)&&ZEND_NULL_LABEL,
55746 (void*)&&ZEND_NULL_LABEL,
55747 (void*)&&ZEND_NULL_LABEL,
55748 (void*)&&ZEND_NULL_LABEL,
55749 (void*)&&ZEND_NULL_LABEL,
55750 (void*)&&ZEND_NULL_LABEL,
55751 (void*)&&ZEND_NULL_LABEL,
55752 (void*)&&ZEND_NULL_LABEL,
55753 (void*)&&ZEND_NULL_LABEL,
55754 (void*)&&ZEND_NULL_LABEL,
55755 (void*)&&ZEND_NULL_LABEL,
55756 (void*)&&ZEND_NULL_LABEL,
55757 (void*)&&ZEND_NULL_LABEL,
55758 (void*)&&ZEND_NULL_LABEL,
55759 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55760 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55761 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55762 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55763 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55764 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55765 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55766 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55767 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55768 (void*)&&ZEND_NULL_LABEL,
55769 (void*)&&ZEND_NULL_LABEL,
55770 (void*)&&ZEND_NULL_LABEL,
55771 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55772 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55773 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55774 (void*)&&ZEND_NULL_LABEL,
55775 (void*)&&ZEND_NULL_LABEL,
55776 (void*)&&ZEND_NULL_LABEL,
55777 (void*)&&ZEND_NULL_LABEL,
55778 (void*)&&ZEND_NULL_LABEL,
55779 (void*)&&ZEND_NULL_LABEL,
55780 (void*)&&ZEND_NULL_LABEL,
55781 (void*)&&ZEND_NULL_LABEL,
55782 (void*)&&ZEND_NULL_LABEL,
55783 (void*)&&ZEND_NULL_LABEL,
55784 (void*)&&ZEND_NULL_LABEL,
55785 (void*)&&ZEND_NULL_LABEL,
55786 (void*)&&ZEND_NULL_LABEL,
55787 (void*)&&ZEND_NULL_LABEL,
55788 (void*)&&ZEND_NULL_LABEL,
55789 (void*)&&ZEND_NULL_LABEL,
55790 (void*)&&ZEND_NULL_LABEL,
55791 (void*)&&ZEND_NULL_LABEL,
55792 (void*)&&ZEND_NULL_LABEL,
55793 (void*)&&ZEND_NULL_LABEL,
55794 (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_LABEL,
55795 (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_LABEL,
55796 (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_LABEL,
55797 (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_LABEL,
55798 (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_LABEL,
55799 (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_LABEL,
55800 (void*)&&ZEND_NULL_LABEL,
55801 (void*)&&ZEND_NULL_LABEL,
55802 (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
55803 (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_LABEL,
55804 (void*)&&ZEND_NULL_LABEL,
55805 (void*)&&ZEND_NULL_LABEL,
55806 (void*)&&ZEND_NULL_LABEL,
55807 (void*)&&ZEND_NULL_LABEL,
55808 (void*)&&ZEND_NULL_LABEL,
55809 (void*)&&ZEND_NULL_LABEL,
55810 (void*)&&ZEND_NULL_LABEL,
55811 (void*)&&ZEND_NULL_LABEL,
55812 (void*)&&ZEND_NULL_LABEL,
55813 (void*)&&ZEND_NULL_LABEL,
55814 (void*)&&ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_LABEL,
55815 (void*)&&ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_LABEL,
55816 (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_LABEL,
55817 (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_LABEL,
55818 (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_LABEL,
55819 (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_LABEL,
55820 (void*)&&ZEND_NULL_LABEL,
55821 (void*)&&ZEND_NULL_LABEL,
55822 (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_LABEL,
55823 (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_LABEL,
55824 (void*)&&ZEND_NULL_LABEL,
55825 (void*)&&ZEND_NULL_LABEL,
55826 (void*)&&ZEND_NULL_LABEL,
55827 (void*)&&ZEND_NULL_LABEL,
55828 (void*)&&ZEND_NULL_LABEL,
55829 (void*)&&ZEND_NULL_LABEL,
55830 (void*)&&ZEND_NULL_LABEL,
55831 (void*)&&ZEND_NULL_LABEL,
55832 (void*)&&ZEND_NULL_LABEL,
55833 (void*)&&ZEND_NULL_LABEL,
55834 (void*)&&ZEND_NULL_LABEL,
55835 (void*)&&ZEND_NULL_LABEL,
55836 (void*)&&ZEND_NULL_LABEL,
55837 (void*)&&ZEND_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_NULL_LABEL,
55846 (void*)&&ZEND_NULL_LABEL,
55847 (void*)&&ZEND_NULL_LABEL,
55848 (void*)&&ZEND_NULL_LABEL,
55849 (void*)&&ZEND_NULL_LABEL,
55850 (void*)&&ZEND_NULL_LABEL,
55851 (void*)&&ZEND_NULL_LABEL,
55852 (void*)&&ZEND_NULL_LABEL,
55853 (void*)&&ZEND_NULL_LABEL,
55854 (void*)&&ZEND_NULL_LABEL,
55855 (void*)&&ZEND_NULL_LABEL,
55856 (void*)&&ZEND_NULL_LABEL,
55857 (void*)&&ZEND_NULL_LABEL,
55858 (void*)&&ZEND_NULL_LABEL,
55859 (void*)&&ZEND_NULL_LABEL,
55860 (void*)&&ZEND_NULL_LABEL,
55861 (void*)&&ZEND_NULL_LABEL,
55862 (void*)&&ZEND_NULL_LABEL,
55863 (void*)&&ZEND_NULL_LABEL,
55864 (void*)&&ZEND_NULL_LABEL,
55865 (void*)&&ZEND_NULL_LABEL,
55866 (void*)&&ZEND_NULL_LABEL,
55867 (void*)&&ZEND_NULL_LABEL,
55868 (void*)&&ZEND_NULL_LABEL,
55869 (void*)&&ZEND_NULL_LABEL,
55870 (void*)&&ZEND_NULL_LABEL,
55871 (void*)&&ZEND_NULL_LABEL,
55872 (void*)&&ZEND_NULL_LABEL,
55873 (void*)&&ZEND_NULL_LABEL,
55874 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
55875 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
55876 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
55877 (void*)&&ZEND_NULL_LABEL,
55878 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
55879 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
55880 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
55881 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
55882 (void*)&&ZEND_NULL_LABEL,
55883 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
55884 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
55885 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
55886 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
55887 (void*)&&ZEND_NULL_LABEL,
55888 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
55889 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_LABEL,
55890 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_LABEL,
55891 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_LABEL,
55892 (void*)&&ZEND_NULL_LABEL,
55893 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_LABEL,
55894 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
55895 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
55896 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
55897 (void*)&&ZEND_NULL_LABEL,
55898 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_LABEL,
55899 (void*)&&ZEND_NULL_LABEL,
55900 (void*)&&ZEND_NULL_LABEL,
55901 (void*)&&ZEND_NULL_LABEL,
55902 (void*)&&ZEND_NULL_LABEL,
55903 (void*)&&ZEND_NULL_LABEL,
55904 (void*)&&ZEND_NULL_LABEL,
55905 (void*)&&ZEND_NULL_LABEL,
55906 (void*)&&ZEND_NULL_LABEL,
55907 (void*)&&ZEND_NULL_LABEL,
55908 (void*)&&ZEND_NULL_LABEL,
55909 (void*)&&ZEND_NULL_LABEL,
55910 (void*)&&ZEND_NULL_LABEL,
55911 (void*)&&ZEND_NULL_LABEL,
55912 (void*)&&ZEND_NULL_LABEL,
55913 (void*)&&ZEND_NULL_LABEL,
55914 (void*)&&ZEND_NULL_LABEL,
55915 (void*)&&ZEND_NULL_LABEL,
55916 (void*)&&ZEND_NULL_LABEL,
55917 (void*)&&ZEND_NULL_LABEL,
55918 (void*)&&ZEND_NULL_LABEL,
55919 (void*)&&ZEND_NULL_LABEL,
55920 (void*)&&ZEND_NULL_LABEL,
55921 (void*)&&ZEND_NULL_LABEL,
55922 (void*)&&ZEND_NULL_LABEL,
55923 (void*)&&ZEND_NULL_LABEL,
55924 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
55925 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
55926 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
55927 (void*)&&ZEND_NULL_LABEL,
55928 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_LABEL,
55929 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
55930 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
55931 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
55932 (void*)&&ZEND_NULL_LABEL,
55933 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
55934 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
55935 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
55936 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
55937 (void*)&&ZEND_NULL_LABEL,
55938 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
55939 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_LABEL,
55940 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_LABEL,
55941 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_LABEL,
55942 (void*)&&ZEND_NULL_LABEL,
55943 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_LABEL,
55944 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_LABEL,
55945 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_LABEL,
55946 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_LABEL,
55947 (void*)&&ZEND_NULL_LABEL,
55948 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_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_NULL_LABEL,
55961 (void*)&&ZEND_NULL_LABEL,
55962 (void*)&&ZEND_NULL_LABEL,
55963 (void*)&&ZEND_NULL_LABEL,
55964 (void*)&&ZEND_NULL_LABEL,
55965 (void*)&&ZEND_NULL_LABEL,
55966 (void*)&&ZEND_NULL_LABEL,
55967 (void*)&&ZEND_NULL_LABEL,
55968 (void*)&&ZEND_NULL_LABEL,
55969 (void*)&&ZEND_NULL_LABEL,
55970 (void*)&&ZEND_NULL_LABEL,
55971 (void*)&&ZEND_NULL_LABEL,
55972 (void*)&&ZEND_NULL_LABEL,
55973 (void*)&&ZEND_NULL_LABEL,
55974 (void*)&&ZEND_NULL_LABEL,
55975 (void*)&&ZEND_NULL_LABEL,
55976 (void*)&&ZEND_NULL_LABEL,
55977 (void*)&&ZEND_NULL_LABEL,
55978 (void*)&&ZEND_NULL_LABEL,
55979 (void*)&&ZEND_NULL_LABEL,
55980 (void*)&&ZEND_NULL_LABEL,
55981 (void*)&&ZEND_NULL_LABEL,
55982 (void*)&&ZEND_NULL_LABEL,
55983 (void*)&&ZEND_NULL_LABEL,
55984 (void*)&&ZEND_NULL_LABEL,
55985 (void*)&&ZEND_NULL_LABEL,
55986 (void*)&&ZEND_NULL_LABEL,
55987 (void*)&&ZEND_NULL_LABEL,
55988 (void*)&&ZEND_NULL_LABEL,
55989 (void*)&&ZEND_NULL_LABEL,
55990 (void*)&&ZEND_NULL_LABEL,
55991 (void*)&&ZEND_NULL_LABEL,
55992 (void*)&&ZEND_NULL_LABEL,
55993 (void*)&&ZEND_NULL_LABEL,
55994 (void*)&&ZEND_NULL_LABEL,
55995 (void*)&&ZEND_NULL_LABEL,
55996 (void*)&&ZEND_NULL_LABEL,
55997 (void*)&&ZEND_NULL_LABEL,
55998 (void*)&&ZEND_NULL_LABEL,
55999 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
56000 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
56001 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
56002 (void*)&&ZEND_NULL_LABEL,
56003 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
56004 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
56005 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
56006 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56007 (void*)&&ZEND_NULL_LABEL,
56008 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56009 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
56010 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
56011 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56012 (void*)&&ZEND_NULL_LABEL,
56013 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56014 (void*)&&ZEND_NULL_LABEL,
56015 (void*)&&ZEND_NULL_LABEL,
56016 (void*)&&ZEND_NULL_LABEL,
56017 (void*)&&ZEND_NULL_LABEL,
56018 (void*)&&ZEND_NULL_LABEL,
56019 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
56020 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
56021 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
56022 (void*)&&ZEND_NULL_LABEL,
56023 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_LABEL,
56024 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_LABEL,
56025 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_LABEL,
56026 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
56027 (void*)&&ZEND_NULL_LABEL,
56028 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
56029 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
56030 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
56031 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56032 (void*)&&ZEND_NULL_LABEL,
56033 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56034 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
56035 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
56036 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56037 (void*)&&ZEND_NULL_LABEL,
56038 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_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_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_LABEL,
56045 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_LABEL,
56046 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
56047 (void*)&&ZEND_NULL_LABEL,
56048 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
56049 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
56050 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
56051 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
56052 (void*)&&ZEND_NULL_LABEL,
56053 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_LABEL,
56054 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
56055 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
56056 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56057 (void*)&&ZEND_NULL_LABEL,
56058 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56059 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
56060 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
56061 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56062 (void*)&&ZEND_NULL_LABEL,
56063 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_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_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_LABEL,
56070 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_LABEL,
56071 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_LABEL,
56072 (void*)&&ZEND_NULL_LABEL,
56073 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_LABEL,
56074 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_LABEL,
56075 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_LABEL,
56076 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_LABEL,
56077 (void*)&&ZEND_NULL_LABEL,
56078 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_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_NULL_LABEL,
56086 (void*)&&ZEND_NULL_LABEL,
56087 (void*)&&ZEND_NULL_LABEL,
56088 (void*)&&ZEND_NULL_LABEL,
56089 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CONST_LABEL,
56090 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
56091 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
56092 (void*)&&ZEND_NULL_LABEL,
56093 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CV_LABEL,
56094 (void*)&&ZEND_NULL_LABEL,
56095 (void*)&&ZEND_NULL_LABEL,
56096 (void*)&&ZEND_NULL_LABEL,
56097 (void*)&&ZEND_NULL_LABEL,
56098 (void*)&&ZEND_NULL_LABEL,
56099 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CONST_LABEL,
56100 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
56101 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
56102 (void*)&&ZEND_NULL_LABEL,
56103 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CV_LABEL,
56104 (void*)&&ZEND_NULL_LABEL,
56105 (void*)&&ZEND_NULL_LABEL,
56106 (void*)&&ZEND_NULL_LABEL,
56107 (void*)&&ZEND_NULL_LABEL,
56108 (void*)&&ZEND_NULL_LABEL,
56109 (void*)&&ZEND_NULL_LABEL,
56110 (void*)&&ZEND_NULL_LABEL,
56111 (void*)&&ZEND_NULL_LABEL,
56112 (void*)&&ZEND_NULL_LABEL,
56113 (void*)&&ZEND_NULL_LABEL,
56114 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_LABEL,
56115 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
56116 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
56117 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_LABEL,
56118 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_LABEL,
56119 (void*)&&ZEND_NULL_LABEL,
56120 (void*)&&ZEND_NULL_LABEL,
56121 (void*)&&ZEND_NULL_LABEL,
56122 (void*)&&ZEND_NULL_LABEL,
56123 (void*)&&ZEND_NULL_LABEL,
56124 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_LABEL,
56125 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
56126 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
56127 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_LABEL,
56128 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_LABEL,
56129 (void*)&&ZEND_NULL_LABEL,
56130 (void*)&&ZEND_NULL_LABEL,
56131 (void*)&&ZEND_NULL_LABEL,
56132 (void*)&&ZEND_NULL_LABEL,
56133 (void*)&&ZEND_NULL_LABEL,
56134 (void*)&&ZEND_NULL_LABEL,
56135 (void*)&&ZEND_NULL_LABEL,
56136 (void*)&&ZEND_NULL_LABEL,
56137 (void*)&&ZEND_NULL_LABEL,
56138 (void*)&&ZEND_NULL_LABEL,
56139 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_LABEL,
56140 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
56141 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
56142 (void*)&&ZEND_NULL_LABEL,
56143 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_LABEL,
56144 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_LABEL,
56145 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
56146 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
56147 (void*)&&ZEND_NULL_LABEL,
56148 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_LABEL,
56149 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_LABEL,
56150 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
56151 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
56152 (void*)&&ZEND_NULL_LABEL,
56153 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_LABEL,
56154 (void*)&&ZEND_ASSIGN_STATIC_PROP_OP_SPEC_LABEL,
56155 (void*)&&ZEND_NULL_LABEL,
56156 (void*)&&ZEND_NULL_LABEL,
56157 (void*)&&ZEND_NULL_LABEL,
56158 (void*)&&ZEND_NULL_LABEL,
56159 (void*)&&ZEND_NULL_LABEL,
56160 (void*)&&ZEND_NULL_LABEL,
56161 (void*)&&ZEND_NULL_LABEL,
56162 (void*)&&ZEND_NULL_LABEL,
56163 (void*)&&ZEND_NULL_LABEL,
56164 (void*)&&ZEND_NULL_LABEL,
56165 (void*)&&ZEND_NULL_LABEL,
56166 (void*)&&ZEND_NULL_LABEL,
56167 (void*)&&ZEND_ASSIGN_REF_SPEC_VAR_VAR_LABEL,
56168 (void*)&&ZEND_NULL_LABEL,
56169 (void*)&&ZEND_ASSIGN_REF_SPEC_VAR_CV_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_NULL_LABEL,
56176 (void*)&&ZEND_NULL_LABEL,
56177 (void*)&&ZEND_ASSIGN_REF_SPEC_CV_VAR_LABEL,
56178 (void*)&&ZEND_NULL_LABEL,
56179 (void*)&&ZEND_ASSIGN_REF_SPEC_CV_CV_LABEL,
56180 (void*)&&ZEND_QM_ASSIGN_SPEC_CONST_LABEL,
56181 (void*)&&ZEND_QM_ASSIGN_SPEC_TMP_LABEL,
56182 (void*)&&ZEND_QM_ASSIGN_SPEC_VAR_LABEL,
56183 (void*)&&ZEND_NULL_LABEL,
56184 (void*)&&ZEND_QM_ASSIGN_SPEC_CV_LABEL,
56185 (void*)&&ZEND_NULL_LABEL,
56186 (void*)&&ZEND_NULL_LABEL,
56187 (void*)&&ZEND_NULL_LABEL,
56188 (void*)&&ZEND_NULL_LABEL,
56189 (void*)&&ZEND_NULL_LABEL,
56190 (void*)&&ZEND_NULL_LABEL,
56191 (void*)&&ZEND_NULL_LABEL,
56192 (void*)&&ZEND_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_NULL_LABEL,
56201 (void*)&&ZEND_NULL_LABEL,
56202 (void*)&&ZEND_NULL_LABEL,
56203 (void*)&&ZEND_NULL_LABEL,
56204 (void*)&&ZEND_NULL_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_NULL_LABEL,
56211 (void*)&&ZEND_NULL_LABEL,
56212 (void*)&&ZEND_NULL_LABEL,
56213 (void*)&&ZEND_NULL_LABEL,
56214 (void*)&&ZEND_NULL_LABEL,
56215 (void*)&&ZEND_NULL_LABEL,
56216 (void*)&&ZEND_NULL_LABEL,
56217 (void*)&&ZEND_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_NULL_LABEL,
56226 (void*)&&ZEND_NULL_LABEL,
56227 (void*)&&ZEND_NULL_LABEL,
56228 (void*)&&ZEND_NULL_LABEL,
56229 (void*)&&ZEND_NULL_LABEL,
56230 (void*)&&ZEND_NULL_LABEL,
56231 (void*)&&ZEND_NULL_LABEL,
56232 (void*)&&ZEND_NULL_LABEL,
56233 (void*)&&ZEND_NULL_LABEL,
56234 (void*)&&ZEND_NULL_LABEL,
56235 (void*)&&ZEND_NULL_LABEL,
56236 (void*)&&ZEND_NULL_LABEL,
56237 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
56238 (void*)&&ZEND_NULL_LABEL,
56239 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
56240 (void*)&&ZEND_NULL_LABEL,
56241 (void*)&&ZEND_NULL_LABEL,
56242 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56243 (void*)&&ZEND_NULL_LABEL,
56244 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56245 (void*)&&ZEND_NULL_LABEL,
56246 (void*)&&ZEND_NULL_LABEL,
56247 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56248 (void*)&&ZEND_NULL_LABEL,
56249 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56250 (void*)&&ZEND_NULL_LABEL,
56251 (void*)&&ZEND_NULL_LABEL,
56252 (void*)&&ZEND_NULL_LABEL,
56253 (void*)&&ZEND_NULL_LABEL,
56254 (void*)&&ZEND_NULL_LABEL,
56255 (void*)&&ZEND_NULL_LABEL,
56256 (void*)&&ZEND_NULL_LABEL,
56257 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
56258 (void*)&&ZEND_NULL_LABEL,
56259 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_LABEL,
56260 (void*)&&ZEND_NULL_LABEL,
56261 (void*)&&ZEND_NULL_LABEL,
56262 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
56263 (void*)&&ZEND_NULL_LABEL,
56264 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
56265 (void*)&&ZEND_NULL_LABEL,
56266 (void*)&&ZEND_NULL_LABEL,
56267 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56268 (void*)&&ZEND_NULL_LABEL,
56269 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56270 (void*)&&ZEND_NULL_LABEL,
56271 (void*)&&ZEND_NULL_LABEL,
56272 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56273 (void*)&&ZEND_NULL_LABEL,
56274 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_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_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
56283 (void*)&&ZEND_NULL_LABEL,
56284 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
56285 (void*)&&ZEND_NULL_LABEL,
56286 (void*)&&ZEND_NULL_LABEL,
56287 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
56288 (void*)&&ZEND_NULL_LABEL,
56289 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_LABEL,
56290 (void*)&&ZEND_NULL_LABEL,
56291 (void*)&&ZEND_NULL_LABEL,
56292 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56293 (void*)&&ZEND_NULL_LABEL,
56294 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56295 (void*)&&ZEND_NULL_LABEL,
56296 (void*)&&ZEND_NULL_LABEL,
56297 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56298 (void*)&&ZEND_NULL_LABEL,
56299 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_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_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_LABEL,
56308 (void*)&&ZEND_NULL_LABEL,
56309 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_LABEL,
56310 (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_LABEL,
56311 (void*)&&ZEND_NULL_LABEL,
56312 (void*)&&ZEND_NULL_LABEL,
56313 (void*)&&ZEND_NULL_LABEL,
56314 (void*)&&ZEND_NULL_LABEL,
56315 (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_LABEL,
56316 (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_LABEL,
56317 (void*)&&ZEND_NULL_LABEL,
56318 (void*)&&ZEND_NULL_LABEL,
56319 (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_LABEL,
56320 (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_USED_LABEL,
56321 (void*)&&ZEND_NULL_LABEL,
56322 (void*)&&ZEND_NULL_LABEL,
56323 (void*)&&ZEND_NULL_LABEL,
56324 (void*)&&ZEND_NULL_LABEL,
56325 (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_LABEL,
56326 (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_LABEL,
56327 (void*)&&ZEND_NULL_LABEL,
56328 (void*)&&ZEND_NULL_LABEL,
56329 (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_LABEL,
56330 (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_LABEL,
56331 (void*)&&ZEND_NULL_LABEL,
56332 (void*)&&ZEND_NULL_LABEL,
56333 (void*)&&ZEND_POST_INC_SPEC_VAR_LABEL,
56334 (void*)&&ZEND_NULL_LABEL,
56335 (void*)&&ZEND_POST_INC_SPEC_CV_LABEL,
56336 (void*)&&ZEND_NULL_LABEL,
56337 (void*)&&ZEND_NULL_LABEL,
56338 (void*)&&ZEND_POST_DEC_SPEC_VAR_LABEL,
56339 (void*)&&ZEND_NULL_LABEL,
56340 (void*)&&ZEND_POST_DEC_SPEC_CV_LABEL,
56341 (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_LABEL,
56342 (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_LABEL,
56343 (void*)&&ZEND_JMP_SPEC_LABEL,
56344 (void*)&&ZEND_JMPZ_SPEC_CONST_LABEL,
56345 (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
56346 (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
56347 (void*)&&ZEND_NULL_LABEL,
56348 (void*)&&ZEND_JMPZ_SPEC_CV_LABEL,
56349 (void*)&&ZEND_JMPNZ_SPEC_CONST_LABEL,
56350 (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
56351 (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
56352 (void*)&&ZEND_NULL_LABEL,
56353 (void*)&&ZEND_JMPNZ_SPEC_CV_LABEL,
56354 (void*)&&ZEND_JMPZ_EX_SPEC_CONST_LABEL,
56355 (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
56356 (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
56357 (void*)&&ZEND_NULL_LABEL,
56358 (void*)&&ZEND_JMPZ_EX_SPEC_CV_LABEL,
56359 (void*)&&ZEND_JMPNZ_EX_SPEC_CONST_LABEL,
56360 (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
56361 (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
56362 (void*)&&ZEND_NULL_LABEL,
56363 (void*)&&ZEND_JMPNZ_EX_SPEC_CV_LABEL,
56364 (void*)&&ZEND_CASE_SPEC_TMPVAR_CONST_LABEL,
56365 (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
56366 (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
56367 (void*)&&ZEND_NULL_LABEL,
56368 (void*)&&ZEND_CASE_SPEC_TMPVAR_CV_LABEL,
56369 (void*)&&ZEND_CHECK_VAR_SPEC_CV_UNUSED_LABEL,
56370 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
56371 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
56372 (void*)&&ZEND_NULL_LABEL,
56373 (void*)&&ZEND_NULL_LABEL,
56374 (void*)&&ZEND_NULL_LABEL,
56375 (void*)&&ZEND_NULL_LABEL,
56376 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_LABEL,
56377 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
56378 (void*)&&ZEND_NULL_LABEL,
56379 (void*)&&ZEND_NULL_LABEL,
56380 (void*)&&ZEND_CAST_SPEC_CONST_LABEL,
56381 (void*)&&ZEND_CAST_SPEC_TMP_LABEL,
56382 (void*)&&ZEND_CAST_SPEC_VAR_LABEL,
56383 (void*)&&ZEND_NULL_LABEL,
56384 (void*)&&ZEND_CAST_SPEC_CV_LABEL,
56385 (void*)&&ZEND_BOOL_SPEC_CONST_LABEL,
56386 (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
56387 (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
56388 (void*)&&ZEND_NULL_LABEL,
56389 (void*)&&ZEND_BOOL_SPEC_CV_LABEL,
56390 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CONST_LABEL,
56391 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
56392 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
56393 (void*)&&ZEND_NULL_LABEL,
56394 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CV_LABEL,
56395 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
56396 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56397 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56398 (void*)&&ZEND_NULL_LABEL,
56399 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
56400 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
56401 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56402 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56403 (void*)&&ZEND_NULL_LABEL,
56404 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
56405 (void*)&&ZEND_NULL_LABEL,
56406 (void*)&&ZEND_NULL_LABEL,
56407 (void*)&&ZEND_NULL_LABEL,
56408 (void*)&&ZEND_NULL_LABEL,
56409 (void*)&&ZEND_NULL_LABEL,
56410 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CONST_LABEL,
56411 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
56412 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
56413 (void*)&&ZEND_NULL_LABEL,
56414 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CV_LABEL,
56415 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CONST_LABEL,
56416 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
56417 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
56418 (void*)&&ZEND_NULL_LABEL,
56419 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CV_LABEL,
56420 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CONST_LABEL,
56421 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
56422 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
56423 (void*)&&ZEND_NULL_LABEL,
56424 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CV_LABEL,
56425 (void*)&&ZEND_ROPE_END_SPEC_TMP_CONST_LABEL,
56426 (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
56427 (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
56428 (void*)&&ZEND_NULL_LABEL,
56429 (void*)&&ZEND_ROPE_END_SPEC_TMP_CV_LABEL,
56430 (void*)&&ZEND_BEGIN_SILENCE_SPEC_LABEL,
56431 (void*)&&ZEND_END_SILENCE_SPEC_TMP_LABEL,
56432 (void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_LABEL,
56433 (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_LABEL,
56434 (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_LABEL,
56435 (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
56436 (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
56437 (void*)&&ZEND_INIT_FCALL_SPEC_CONST_LABEL,
56438 (void*)&&ZEND_RETURN_SPEC_CONST_LABEL,
56439 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56440 (void*)&&ZEND_RETURN_SPEC_TMP_LABEL,
56441 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56442 (void*)&&ZEND_RETURN_SPEC_VAR_LABEL,
56443 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56444 (void*)&&ZEND_NULL_LABEL,
56445 (void*)&&ZEND_NULL_LABEL,
56446 (void*)&&ZEND_RETURN_SPEC_CV_LABEL,
56447 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56448 (void*)&&ZEND_RECV_SPEC_UNUSED_LABEL,
56449 (void*)&&ZEND_RECV_INIT_SPEC_CONST_LABEL,
56450 (void*)&&ZEND_SEND_VAL_SPEC_CONST_CONST_LABEL,
56451 (void*)&&ZEND_NULL_LABEL,
56452 (void*)&&ZEND_NULL_LABEL,
56453 (void*)&&ZEND_SEND_VAL_SPEC_CONST_UNUSED_LABEL,
56454 (void*)&&ZEND_NULL_LABEL,
56455 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
56456 (void*)&&ZEND_NULL_LABEL,
56457 (void*)&&ZEND_NULL_LABEL,
56458 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_LABEL,
56459 (void*)&&ZEND_NULL_LABEL,
56460 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
56461 (void*)&&ZEND_NULL_LABEL,
56462 (void*)&&ZEND_NULL_LABEL,
56463 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_LABEL,
56464 (void*)&&ZEND_NULL_LABEL,
56465 (void*)&&ZEND_NULL_LABEL,
56466 (void*)&&ZEND_NULL_LABEL,
56467 (void*)&&ZEND_NULL_LABEL,
56468 (void*)&&ZEND_NULL_LABEL,
56469 (void*)&&ZEND_NULL_LABEL,
56470 (void*)&&ZEND_NULL_LABEL,
56471 (void*)&&ZEND_NULL_LABEL,
56472 (void*)&&ZEND_NULL_LABEL,
56473 (void*)&&ZEND_NULL_LABEL,
56474 (void*)&&ZEND_NULL_LABEL,
56475 (void*)&&ZEND_NULL_LABEL,
56476 (void*)&&ZEND_NULL_LABEL,
56477 (void*)&&ZEND_NULL_LABEL,
56478 (void*)&&ZEND_NULL_LABEL,
56479 (void*)&&ZEND_NULL_LABEL,
56480 (void*)&&ZEND_NULL_LABEL,
56481 (void*)&&ZEND_NULL_LABEL,
56482 (void*)&&ZEND_NULL_LABEL,
56483 (void*)&&ZEND_NULL_LABEL,
56484 (void*)&&ZEND_NULL_LABEL,
56485 (void*)&&ZEND_NULL_LABEL,
56486 (void*)&&ZEND_NULL_LABEL,
56487 (void*)&&ZEND_NULL_LABEL,
56488 (void*)&&ZEND_NULL_LABEL,
56489 (void*)&&ZEND_NULL_LABEL,
56490 (void*)&&ZEND_NULL_LABEL,
56491 (void*)&&ZEND_NULL_LABEL,
56492 (void*)&&ZEND_NULL_LABEL,
56493 (void*)&&ZEND_NULL_LABEL,
56494 (void*)&&ZEND_NULL_LABEL,
56495 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
56496 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
56497 (void*)&&ZEND_NULL_LABEL,
56498 (void*)&&ZEND_NULL_LABEL,
56499 (void*)&&ZEND_NULL_LABEL,
56500 (void*)&&ZEND_NULL_LABEL,
56501 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_LABEL,
56502 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
56503 (void*)&&ZEND_NULL_LABEL,
56504 (void*)&&ZEND_NULL_LABEL,
56505 (void*)&&ZEND_NULL_LABEL,
56506 (void*)&&ZEND_NULL_LABEL,
56507 (void*)&&ZEND_NULL_LABEL,
56508 (void*)&&ZEND_NULL_LABEL,
56509 (void*)&&ZEND_NULL_LABEL,
56510 (void*)&&ZEND_NULL_LABEL,
56511 (void*)&&ZEND_NULL_LABEL,
56512 (void*)&&ZEND_NULL_LABEL,
56513 (void*)&&ZEND_NULL_LABEL,
56514 (void*)&&ZEND_NULL_LABEL,
56515 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
56516 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
56517 (void*)&&ZEND_NULL_LABEL,
56518 (void*)&&ZEND_NULL_LABEL,
56519 (void*)&&ZEND_NULL_LABEL,
56520 (void*)&&ZEND_NULL_LABEL,
56521 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_LABEL,
56522 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_LABEL,
56523 (void*)&&ZEND_NULL_LABEL,
56524 (void*)&&ZEND_NULL_LABEL,
56525 (void*)&&ZEND_NULL_LABEL,
56526 (void*)&&ZEND_NULL_LABEL,
56527 (void*)&&ZEND_NULL_LABEL,
56528 (void*)&&ZEND_NULL_LABEL,
56529 (void*)&&ZEND_NULL_LABEL,
56530 (void*)&&ZEND_NULL_LABEL,
56531 (void*)&&ZEND_NULL_LABEL,
56532 (void*)&&ZEND_NULL_LABEL,
56533 (void*)&&ZEND_NULL_LABEL,
56534 (void*)&&ZEND_NULL_LABEL,
56535 (void*)&&ZEND_SEND_REF_SPEC_VAR_CONST_LABEL,
56536 (void*)&&ZEND_NULL_LABEL,
56537 (void*)&&ZEND_NULL_LABEL,
56538 (void*)&&ZEND_SEND_REF_SPEC_VAR_UNUSED_LABEL,
56539 (void*)&&ZEND_NULL_LABEL,
56540 (void*)&&ZEND_NULL_LABEL,
56541 (void*)&&ZEND_NULL_LABEL,
56542 (void*)&&ZEND_NULL_LABEL,
56543 (void*)&&ZEND_NULL_LABEL,
56544 (void*)&&ZEND_NULL_LABEL,
56545 (void*)&&ZEND_SEND_REF_SPEC_CV_CONST_LABEL,
56546 (void*)&&ZEND_NULL_LABEL,
56547 (void*)&&ZEND_NULL_LABEL,
56548 (void*)&&ZEND_SEND_REF_SPEC_CV_UNUSED_LABEL,
56549 (void*)&&ZEND_NULL_LABEL,
56550 (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_LABEL,
56551 (void*)&&ZEND_NULL_LABEL,
56552 (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_LABEL,
56553 (void*)&&ZEND_NEW_SPEC_UNUSED_UNUSED_LABEL,
56554 (void*)&&ZEND_NULL_LABEL,
56555 (void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_LABEL,
56556 (void*)&&ZEND_FREE_SPEC_TMPVAR_LABEL,
56557 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CONST_LABEL,
56558 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
56559 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
56560 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_LABEL,
56561 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CV_LABEL,
56562 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CONST_LABEL,
56563 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
56564 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
56565 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_LABEL,
56566 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CV_LABEL,
56567 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CONST_LABEL,
56568 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
56569 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
56570 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_LABEL,
56571 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CV_LABEL,
56572 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_LABEL,
56573 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
56574 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
56575 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_LABEL,
56576 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CV_LABEL,
56577 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CONST_LABEL,
56578 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
56579 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
56580 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_UNUSED_LABEL,
56581 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CV_LABEL,
56582 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_LABEL,
56583 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
56584 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
56585 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_LABEL,
56586 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_LABEL,
56587 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_LABEL,
56588 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
56589 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
56590 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_LABEL,
56591 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_LABEL,
56592 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_LABEL,
56593 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
56594 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
56595 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_LABEL,
56596 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_LABEL,
56597 (void*)&&ZEND_NULL_LABEL,
56598 (void*)&&ZEND_NULL_LABEL,
56599 (void*)&&ZEND_NULL_LABEL,
56600 (void*)&&ZEND_NULL_LABEL,
56601 (void*)&&ZEND_NULL_LABEL,
56602 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_LABEL,
56603 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
56604 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
56605 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_LABEL,
56606 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_LABEL,
56607 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CONST_LABEL,
56608 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56609 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
56610 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56611 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
56612 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56613 (void*)&&ZEND_NULL_LABEL,
56614 (void*)&&ZEND_NULL_LABEL,
56615 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CV_LABEL,
56616 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56617 (void*)&&ZEND_UNSET_VAR_SPEC_CONST_UNUSED_LABEL,
56618 (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
56619 (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
56620 (void*)&&ZEND_NULL_LABEL,
56621 (void*)&&ZEND_UNSET_VAR_SPEC_CV_UNUSED_LABEL,
56622 (void*)&&ZEND_NULL_LABEL,
56623 (void*)&&ZEND_NULL_LABEL,
56624 (void*)&&ZEND_NULL_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_NULL_LABEL,
56632 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CONST_LABEL,
56633 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
56634 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
56635 (void*)&&ZEND_NULL_LABEL,
56636 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CV_LABEL,
56637 (void*)&&ZEND_NULL_LABEL,
56638 (void*)&&ZEND_NULL_LABEL,
56639 (void*)&&ZEND_NULL_LABEL,
56640 (void*)&&ZEND_NULL_LABEL,
56641 (void*)&&ZEND_NULL_LABEL,
56642 (void*)&&ZEND_UNSET_DIM_SPEC_CV_CONST_LABEL,
56643 (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
56644 (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
56645 (void*)&&ZEND_NULL_LABEL,
56646 (void*)&&ZEND_UNSET_DIM_SPEC_CV_CV_LABEL,
56647 (void*)&&ZEND_NULL_LABEL,
56648 (void*)&&ZEND_NULL_LABEL,
56649 (void*)&&ZEND_NULL_LABEL,
56650 (void*)&&ZEND_NULL_LABEL,
56651 (void*)&&ZEND_NULL_LABEL,
56652 (void*)&&ZEND_NULL_LABEL,
56653 (void*)&&ZEND_NULL_LABEL,
56654 (void*)&&ZEND_NULL_LABEL,
56655 (void*)&&ZEND_NULL_LABEL,
56656 (void*)&&ZEND_NULL_LABEL,
56657 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CONST_LABEL,
56658 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
56659 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
56660 (void*)&&ZEND_NULL_LABEL,
56661 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CV_LABEL,
56662 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_LABEL,
56663 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
56664 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
56665 (void*)&&ZEND_NULL_LABEL,
56666 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CV_LABEL,
56667 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CONST_LABEL,
56668 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
56669 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
56670 (void*)&&ZEND_NULL_LABEL,
56671 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CV_LABEL,
56672 (void*)&&ZEND_FE_RESET_R_SPEC_CONST_LABEL,
56673 (void*)&&ZEND_FE_RESET_R_SPEC_TMP_LABEL,
56674 (void*)&&ZEND_FE_RESET_R_SPEC_VAR_LABEL,
56675 (void*)&&ZEND_NULL_LABEL,
56676 (void*)&&ZEND_FE_RESET_R_SPEC_CV_LABEL,
56677 (void*)&&ZEND_FE_FETCH_R_SPEC_VAR_LABEL,
56678 (void*)&&ZEND_FETCH_R_SPEC_CONST_UNUSED_LABEL,
56679 (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
56680 (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
56681 (void*)&&ZEND_NULL_LABEL,
56682 (void*)&&ZEND_FETCH_R_SPEC_CV_UNUSED_LABEL,
56683 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CONST_LABEL,
56684 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
56685 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
56686 (void*)&&ZEND_NULL_LABEL,
56687 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CV_LABEL,
56688 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
56689 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56690 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56691 (void*)&&ZEND_NULL_LABEL,
56692 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
56693 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
56694 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56695 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56696 (void*)&&ZEND_NULL_LABEL,
56697 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
56698 (void*)&&ZEND_NULL_LABEL,
56699 (void*)&&ZEND_NULL_LABEL,
56700 (void*)&&ZEND_NULL_LABEL,
56701 (void*)&&ZEND_NULL_LABEL,
56702 (void*)&&ZEND_NULL_LABEL,
56703 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CONST_LABEL,
56704 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
56705 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
56706 (void*)&&ZEND_NULL_LABEL,
56707 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CV_LABEL,
56708 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_LABEL,
56709 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
56710 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
56711 (void*)&&ZEND_NULL_LABEL,
56712 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CV_LABEL,
56713 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
56714 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56715 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56716 (void*)&&ZEND_NULL_LABEL,
56717 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
56718 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
56719 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56720 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56721 (void*)&&ZEND_NULL_LABEL,
56722 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
56723 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_LABEL,
56724 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
56725 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
56726 (void*)&&ZEND_NULL_LABEL,
56727 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_LABEL,
56728 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CONST_LABEL,
56729 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
56730 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
56731 (void*)&&ZEND_NULL_LABEL,
56732 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CV_LABEL,
56733 (void*)&&ZEND_FETCH_W_SPEC_CONST_UNUSED_LABEL,
56734 (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
56735 (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
56736 (void*)&&ZEND_NULL_LABEL,
56737 (void*)&&ZEND_FETCH_W_SPEC_CV_UNUSED_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_NULL_LABEL,
56744 (void*)&&ZEND_NULL_LABEL,
56745 (void*)&&ZEND_NULL_LABEL,
56746 (void*)&&ZEND_NULL_LABEL,
56747 (void*)&&ZEND_NULL_LABEL,
56748 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CONST_LABEL,
56749 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
56750 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
56751 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_LABEL,
56752 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CV_LABEL,
56753 (void*)&&ZEND_NULL_LABEL,
56754 (void*)&&ZEND_NULL_LABEL,
56755 (void*)&&ZEND_NULL_LABEL,
56756 (void*)&&ZEND_NULL_LABEL,
56757 (void*)&&ZEND_NULL_LABEL,
56758 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CONST_LABEL,
56759 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
56760 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
56761 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_LABEL,
56762 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CV_LABEL,
56763 (void*)&&ZEND_NULL_LABEL,
56764 (void*)&&ZEND_NULL_LABEL,
56765 (void*)&&ZEND_NULL_LABEL,
56766 (void*)&&ZEND_NULL_LABEL,
56767 (void*)&&ZEND_NULL_LABEL,
56768 (void*)&&ZEND_NULL_LABEL,
56769 (void*)&&ZEND_NULL_LABEL,
56770 (void*)&&ZEND_NULL_LABEL,
56771 (void*)&&ZEND_NULL_LABEL,
56772 (void*)&&ZEND_NULL_LABEL,
56773 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_LABEL,
56774 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
56775 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
56776 (void*)&&ZEND_NULL_LABEL,
56777 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CV_LABEL,
56778 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_LABEL,
56779 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
56780 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
56781 (void*)&&ZEND_NULL_LABEL,
56782 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_LABEL,
56783 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CONST_LABEL,
56784 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
56785 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
56786 (void*)&&ZEND_NULL_LABEL,
56787 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CV_LABEL,
56788 (void*)&&ZEND_FETCH_RW_SPEC_CONST_UNUSED_LABEL,
56789 (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
56790 (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
56791 (void*)&&ZEND_NULL_LABEL,
56792 (void*)&&ZEND_FETCH_RW_SPEC_CV_UNUSED_LABEL,
56793 (void*)&&ZEND_NULL_LABEL,
56794 (void*)&&ZEND_NULL_LABEL,
56795 (void*)&&ZEND_NULL_LABEL,
56796 (void*)&&ZEND_NULL_LABEL,
56797 (void*)&&ZEND_NULL_LABEL,
56798 (void*)&&ZEND_NULL_LABEL,
56799 (void*)&&ZEND_NULL_LABEL,
56800 (void*)&&ZEND_NULL_LABEL,
56801 (void*)&&ZEND_NULL_LABEL,
56802 (void*)&&ZEND_NULL_LABEL,
56803 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_LABEL,
56804 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
56805 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
56806 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_LABEL,
56807 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CV_LABEL,
56808 (void*)&&ZEND_NULL_LABEL,
56809 (void*)&&ZEND_NULL_LABEL,
56810 (void*)&&ZEND_NULL_LABEL,
56811 (void*)&&ZEND_NULL_LABEL,
56812 (void*)&&ZEND_NULL_LABEL,
56813 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CONST_LABEL,
56814 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
56815 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
56816 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_LABEL,
56817 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CV_LABEL,
56818 (void*)&&ZEND_NULL_LABEL,
56819 (void*)&&ZEND_NULL_LABEL,
56820 (void*)&&ZEND_NULL_LABEL,
56821 (void*)&&ZEND_NULL_LABEL,
56822 (void*)&&ZEND_NULL_LABEL,
56823 (void*)&&ZEND_NULL_LABEL,
56824 (void*)&&ZEND_NULL_LABEL,
56825 (void*)&&ZEND_NULL_LABEL,
56826 (void*)&&ZEND_NULL_LABEL,
56827 (void*)&&ZEND_NULL_LABEL,
56828 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_LABEL,
56829 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
56830 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
56831 (void*)&&ZEND_NULL_LABEL,
56832 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_LABEL,
56833 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_LABEL,
56834 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
56835 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
56836 (void*)&&ZEND_NULL_LABEL,
56837 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_LABEL,
56838 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_LABEL,
56839 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
56840 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
56841 (void*)&&ZEND_NULL_LABEL,
56842 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CV_LABEL,
56843 (void*)&&ZEND_FETCH_IS_SPEC_CONST_UNUSED_LABEL,
56844 (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
56845 (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
56846 (void*)&&ZEND_NULL_LABEL,
56847 (void*)&&ZEND_FETCH_IS_SPEC_CV_UNUSED_LABEL,
56848 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_LABEL,
56849 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
56850 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
56851 (void*)&&ZEND_NULL_LABEL,
56852 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CV_LABEL,
56853 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
56854 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56855 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56856 (void*)&&ZEND_NULL_LABEL,
56857 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
56858 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
56859 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56860 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56861 (void*)&&ZEND_NULL_LABEL,
56862 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
56863 (void*)&&ZEND_NULL_LABEL,
56864 (void*)&&ZEND_NULL_LABEL,
56865 (void*)&&ZEND_NULL_LABEL,
56866 (void*)&&ZEND_NULL_LABEL,
56867 (void*)&&ZEND_NULL_LABEL,
56868 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CONST_LABEL,
56869 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
56870 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
56871 (void*)&&ZEND_NULL_LABEL,
56872 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CV_LABEL,
56873 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_LABEL,
56874 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
56875 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
56876 (void*)&&ZEND_NULL_LABEL,
56877 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_LABEL,
56878 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
56879 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56880 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56881 (void*)&&ZEND_NULL_LABEL,
56882 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
56883 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
56884 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56885 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56886 (void*)&&ZEND_NULL_LABEL,
56887 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
56888 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_LABEL,
56889 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
56890 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
56891 (void*)&&ZEND_NULL_LABEL,
56892 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_LABEL,
56893 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_LABEL,
56894 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
56895 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
56896 (void*)&&ZEND_NULL_LABEL,
56897 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CV_LABEL,
56898 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
56899 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
56900 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
56901 (void*)&&ZEND_NULL_LABEL,
56902 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
56903 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_LABEL,
56904 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56905 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56906 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
56907 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_LABEL,
56908 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_LABEL,
56909 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56910 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56911 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_LABEL,
56912 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_LABEL,
56913 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_LABEL,
56914 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
56915 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
56916 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
56917 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_LABEL,
56918 (void*)&&ZEND_NULL_LABEL,
56919 (void*)&&ZEND_NULL_LABEL,
56920 (void*)&&ZEND_NULL_LABEL,
56921 (void*)&&ZEND_NULL_LABEL,
56922 (void*)&&ZEND_NULL_LABEL,
56923 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_LABEL,
56924 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
56925 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
56926 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
56927 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_LABEL,
56928 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_LABEL,
56929 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56930 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56931 (void*)&&ZEND_NULL_LABEL,
56932 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_LABEL,
56933 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_LABEL,
56934 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56935 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56936 (void*)&&ZEND_NULL_LABEL,
56937 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_LABEL,
56938 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_LABEL,
56939 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
56940 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
56941 (void*)&&ZEND_NULL_LABEL,
56942 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_LABEL,
56943 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
56944 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
56945 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
56946 (void*)&&ZEND_NULL_LABEL,
56947 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_LABEL,
56948 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_LABEL,
56949 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
56950 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
56951 (void*)&&ZEND_NULL_LABEL,
56952 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_LABEL,
56953 (void*)&&ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_LABEL,
56954 (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
56955 (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
56956 (void*)&&ZEND_NULL_LABEL,
56957 (void*)&&ZEND_FETCH_UNSET_SPEC_CV_UNUSED_LABEL,
56958 (void*)&&ZEND_NULL_LABEL,
56959 (void*)&&ZEND_NULL_LABEL,
56960 (void*)&&ZEND_NULL_LABEL,
56961 (void*)&&ZEND_NULL_LABEL,
56962 (void*)&&ZEND_NULL_LABEL,
56963 (void*)&&ZEND_NULL_LABEL,
56964 (void*)&&ZEND_NULL_LABEL,
56965 (void*)&&ZEND_NULL_LABEL,
56966 (void*)&&ZEND_NULL_LABEL,
56967 (void*)&&ZEND_NULL_LABEL,
56968 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_LABEL,
56969 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
56970 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
56971 (void*)&&ZEND_NULL_LABEL,
56972 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_LABEL,
56973 (void*)&&ZEND_NULL_LABEL,
56974 (void*)&&ZEND_NULL_LABEL,
56975 (void*)&&ZEND_NULL_LABEL,
56976 (void*)&&ZEND_NULL_LABEL,
56977 (void*)&&ZEND_NULL_LABEL,
56978 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_LABEL,
56979 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
56980 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
56981 (void*)&&ZEND_NULL_LABEL,
56982 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_LABEL,
56983 (void*)&&ZEND_NULL_LABEL,
56984 (void*)&&ZEND_NULL_LABEL,
56985 (void*)&&ZEND_NULL_LABEL,
56986 (void*)&&ZEND_NULL_LABEL,
56987 (void*)&&ZEND_NULL_LABEL,
56988 (void*)&&ZEND_NULL_LABEL,
56989 (void*)&&ZEND_NULL_LABEL,
56990 (void*)&&ZEND_NULL_LABEL,
56991 (void*)&&ZEND_NULL_LABEL,
56992 (void*)&&ZEND_NULL_LABEL,
56993 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_LABEL,
56994 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
56995 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
56996 (void*)&&ZEND_NULL_LABEL,
56997 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_LABEL,
56998 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_LABEL,
56999 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
57000 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
57001 (void*)&&ZEND_NULL_LABEL,
57002 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_LABEL,
57003 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_LABEL,
57004 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
57005 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
57006 (void*)&&ZEND_NULL_LABEL,
57007 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_LABEL,
57008 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CONST_LABEL,
57009 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
57010 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
57011 (void*)&&ZEND_NULL_LABEL,
57012 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CV_LABEL,
57013 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
57014 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57015 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57016 (void*)&&ZEND_NULL_LABEL,
57017 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
57018 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
57019 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57020 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57021 (void*)&&ZEND_NULL_LABEL,
57022 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
57023 (void*)&&ZEND_NULL_LABEL,
57024 (void*)&&ZEND_NULL_LABEL,
57025 (void*)&&ZEND_NULL_LABEL,
57026 (void*)&&ZEND_NULL_LABEL,
57027 (void*)&&ZEND_NULL_LABEL,
57028 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
57029 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57030 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
57031 (void*)&&ZEND_NULL_LABEL,
57032 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
57033 (void*)&&ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_LABEL,
57034 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
57035 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
57036 (void*)&&ZEND_NULL_LABEL,
57037 (void*)&&ZEND_NULL_LABEL,
57038 (void*)&&ZEND_NULL_LABEL,
57039 (void*)&&ZEND_NULL_LABEL,
57040 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_LABEL,
57041 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_LABEL,
57042 (void*)&&ZEND_NULL_LABEL,
57043 (void*)&&ZEND_NULL_LABEL,
57044 (void*)&&ZEND_EXT_STMT_SPEC_LABEL,
57045 (void*)&&ZEND_EXT_FCALL_BEGIN_SPEC_LABEL,
57046 (void*)&&ZEND_EXT_FCALL_END_SPEC_LABEL,
57047 (void*)&&ZEND_EXT_NOP_SPEC_LABEL,
57048 (void*)&&ZEND_TICKS_SPEC_LABEL,
57049 (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_LABEL,
57050 (void*)&&ZEND_NULL_LABEL,
57051 (void*)&&ZEND_NULL_LABEL,
57052 (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_LABEL,
57053 (void*)&&ZEND_NULL_LABEL,
57054 (void*)&&ZEND_CATCH_SPEC_CONST_LABEL,
57055 (void*)&&ZEND_THROW_SPEC_CONST_LABEL,
57056 (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
57057 (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
57058 (void*)&&ZEND_NULL_LABEL,
57059 (void*)&&ZEND_THROW_SPEC_CV_LABEL,
57060 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_LABEL,
57061 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
57062 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
57063 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57064 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CV_LABEL,
57065 (void*)&&ZEND_CLONE_SPEC_CONST_LABEL,
57066 (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
57067 (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
57068 (void*)&&ZEND_CLONE_SPEC_UNUSED_LABEL,
57069 (void*)&&ZEND_CLONE_SPEC_CV_LABEL,
57070 (void*)&&ZEND_RETURN_BY_REF_SPEC_CONST_LABEL,
57071 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57072 (void*)&&ZEND_RETURN_BY_REF_SPEC_TMP_LABEL,
57073 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57074 (void*)&&ZEND_RETURN_BY_REF_SPEC_VAR_LABEL,
57075 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57076 (void*)&&ZEND_NULL_LABEL,
57077 (void*)&&ZEND_NULL_LABEL,
57078 (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_LABEL,
57079 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57080 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_LABEL,
57081 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57082 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57083 (void*)&&ZEND_NULL_LABEL,
57084 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_LABEL,
57085 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
57086 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57087 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57088 (void*)&&ZEND_NULL_LABEL,
57089 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
57090 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
57091 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57092 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57093 (void*)&&ZEND_NULL_LABEL,
57094 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
57095 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
57096 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57097 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57098 (void*)&&ZEND_NULL_LABEL,
57099 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
57100 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_LABEL,
57101 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
57102 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
57103 (void*)&&ZEND_NULL_LABEL,
57104 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CV_LABEL,
57105 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_LABEL,
57106 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57107 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57108 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_LABEL,
57109 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_LABEL,
57110 (void*)&&ZEND_NULL_LABEL,
57111 (void*)&&ZEND_NULL_LABEL,
57112 (void*)&&ZEND_NULL_LABEL,
57113 (void*)&&ZEND_NULL_LABEL,
57114 (void*)&&ZEND_NULL_LABEL,
57115 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_LABEL,
57116 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
57117 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
57118 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_LABEL,
57119 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_LABEL,
57120 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
57121 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57122 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57123 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_LABEL,
57124 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
57125 (void*)&&ZEND_NULL_LABEL,
57126 (void*)&&ZEND_NULL_LABEL,
57127 (void*)&&ZEND_NULL_LABEL,
57128 (void*)&&ZEND_NULL_LABEL,
57129 (void*)&&ZEND_NULL_LABEL,
57130 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_LABEL,
57131 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
57132 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
57133 (void*)&&ZEND_NULL_LABEL,
57134 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_LABEL,
57135 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_LABEL,
57136 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
57137 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
57138 (void*)&&ZEND_NULL_LABEL,
57139 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_LABEL,
57140 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
57141 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57142 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57143 (void*)&&ZEND_NULL_LABEL,
57144 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
57145 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
57146 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57147 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57148 (void*)&&ZEND_NULL_LABEL,
57149 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
57150 (void*)&&ZEND_NULL_LABEL,
57151 (void*)&&ZEND_NULL_LABEL,
57152 (void*)&&ZEND_NULL_LABEL,
57153 (void*)&&ZEND_NULL_LABEL,
57154 (void*)&&ZEND_NULL_LABEL,
57155 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_LABEL,
57156 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
57157 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
57158 (void*)&&ZEND_NULL_LABEL,
57159 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_LABEL,
57160 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
57161 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
57162 (void*)&&ZEND_NULL_LABEL,
57163 (void*)&&ZEND_NULL_LABEL,
57164 (void*)&&ZEND_NULL_LABEL,
57165 (void*)&&ZEND_NULL_LABEL,
57166 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_LABEL,
57167 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_LABEL,
57168 (void*)&&ZEND_NULL_LABEL,
57169 (void*)&&ZEND_NULL_LABEL,
57170 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
57171 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
57172 (void*)&&ZEND_NULL_LABEL,
57173 (void*)&&ZEND_NULL_LABEL,
57174 (void*)&&ZEND_NULL_LABEL,
57175 (void*)&&ZEND_NULL_LABEL,
57176 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_LABEL,
57177 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_LABEL,
57178 (void*)&&ZEND_NULL_LABEL,
57179 (void*)&&ZEND_NULL_LABEL,
57180 (void*)&&ZEND_NULL_LABEL,
57181 (void*)&&ZEND_NULL_LABEL,
57182 (void*)&&ZEND_NULL_LABEL,
57183 (void*)&&ZEND_NULL_LABEL,
57184 (void*)&&ZEND_NULL_LABEL,
57185 (void*)&&ZEND_NULL_LABEL,
57186 (void*)&&ZEND_NULL_LABEL,
57187 (void*)&&ZEND_NULL_LABEL,
57188 (void*)&&ZEND_NULL_LABEL,
57189 (void*)&&ZEND_NULL_LABEL,
57190 (void*)&&ZEND_NULL_LABEL,
57191 (void*)&&ZEND_NULL_LABEL,
57192 (void*)&&ZEND_NULL_LABEL,
57193 (void*)&&ZEND_NULL_LABEL,
57194 (void*)&&ZEND_NULL_LABEL,
57195 (void*)&&ZEND_NULL_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_NULL_LABEL,
57202 (void*)&&ZEND_NULL_LABEL,
57203 (void*)&&ZEND_NULL_LABEL,
57204 (void*)&&ZEND_NULL_LABEL,
57205 (void*)&&ZEND_NULL_LABEL,
57206 (void*)&&ZEND_NULL_LABEL,
57207 (void*)&&ZEND_NULL_LABEL,
57208 (void*)&&ZEND_NULL_LABEL,
57209 (void*)&&ZEND_NULL_LABEL,
57210 (void*)&&ZEND_NULL_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_NULL_LABEL,
57217 (void*)&&ZEND_NULL_LABEL,
57218 (void*)&&ZEND_NULL_LABEL,
57219 (void*)&&ZEND_NULL_LABEL,
57220 (void*)&&ZEND_SEND_VAR_SPEC_VAR_CONST_LABEL,
57221 (void*)&&ZEND_NULL_LABEL,
57222 (void*)&&ZEND_NULL_LABEL,
57223 (void*)&&ZEND_SEND_VAR_SPEC_VAR_UNUSED_LABEL,
57224 (void*)&&ZEND_NULL_LABEL,
57225 (void*)&&ZEND_NULL_LABEL,
57226 (void*)&&ZEND_NULL_LABEL,
57227 (void*)&&ZEND_NULL_LABEL,
57228 (void*)&&ZEND_NULL_LABEL,
57229 (void*)&&ZEND_NULL_LABEL,
57230 (void*)&&ZEND_SEND_VAR_SPEC_CV_CONST_LABEL,
57231 (void*)&&ZEND_NULL_LABEL,
57232 (void*)&&ZEND_NULL_LABEL,
57233 (void*)&&ZEND_SEND_VAR_SPEC_CV_UNUSED_LABEL,
57234 (void*)&&ZEND_NULL_LABEL,
57235 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_LABEL,
57236 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
57237 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
57238 (void*)&&ZEND_NULL_LABEL,
57239 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_LABEL,
57240 (void*)&&ZEND_SEND_ARRAY_SPEC_LABEL,
57241 (void*)&&ZEND_SEND_USER_SPEC_CONST_LABEL,
57242 (void*)&&ZEND_SEND_USER_SPEC_TMP_LABEL,
57243 (void*)&&ZEND_SEND_USER_SPEC_VAR_LABEL,
57244 (void*)&&ZEND_NULL_LABEL,
57245 (void*)&&ZEND_SEND_USER_SPEC_CV_LABEL,
57246 (void*)&&ZEND_STRLEN_SPEC_CONST_LABEL,
57247 (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
57248 (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
57249 (void*)&&ZEND_NULL_LABEL,
57250 (void*)&&ZEND_STRLEN_SPEC_CV_LABEL,
57251 (void*)&&ZEND_DEFINED_SPEC_CONST_LABEL,
57252 (void*)&&ZEND_TYPE_CHECK_SPEC_CONST_LABEL,
57253 (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
57254 (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
57255 (void*)&&ZEND_NULL_LABEL,
57256 (void*)&&ZEND_TYPE_CHECK_SPEC_CV_LABEL,
57257 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_LABEL,
57258 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_LABEL,
57259 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_LABEL,
57260 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_LABEL,
57261 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_LABEL,
57262 (void*)&&ZEND_FE_RESET_RW_SPEC_CONST_LABEL,
57263 (void*)&&ZEND_FE_RESET_RW_SPEC_TMP_LABEL,
57264 (void*)&&ZEND_FE_RESET_RW_SPEC_VAR_LABEL,
57265 (void*)&&ZEND_NULL_LABEL,
57266 (void*)&&ZEND_FE_RESET_RW_SPEC_CV_LABEL,
57267 (void*)&&ZEND_FE_FETCH_RW_SPEC_VAR_LABEL,
57268 (void*)&&ZEND_FE_FREE_SPEC_TMPVAR_LABEL,
57269 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_LABEL,
57270 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
57271 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
57272 (void*)&&ZEND_NULL_LABEL,
57273 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CV_LABEL,
57274 (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_LABEL,
57275 (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_USED_LABEL,
57276 (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
57277 (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
57278 (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_LABEL,
57279 (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_USED_LABEL,
57280 (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
57281 (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
57282 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_LABEL,
57283 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_LABEL,
57284 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_LABEL,
57285 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_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_PRE_INC_OBJ_SPEC_VAR_CONST_LABEL,
57297 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57298 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57299 (void*)&&ZEND_NULL_LABEL,
57300 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CV_LABEL,
57301 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
57302 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57303 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57304 (void*)&&ZEND_NULL_LABEL,
57305 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_LABEL,
57306 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CONST_LABEL,
57307 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57308 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57309 (void*)&&ZEND_NULL_LABEL,
57310 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CV_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_NULL_LABEL,
57317 (void*)&&ZEND_NULL_LABEL,
57318 (void*)&&ZEND_NULL_LABEL,
57319 (void*)&&ZEND_NULL_LABEL,
57320 (void*)&&ZEND_NULL_LABEL,
57321 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CONST_LABEL,
57322 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57323 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57324 (void*)&&ZEND_NULL_LABEL,
57325 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CV_LABEL,
57326 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
57327 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57328 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57329 (void*)&&ZEND_NULL_LABEL,
57330 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_LABEL,
57331 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CONST_LABEL,
57332 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57333 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57334 (void*)&&ZEND_NULL_LABEL,
57335 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CV_LABEL,
57336 (void*)&&ZEND_ECHO_SPEC_CONST_LABEL,
57337 (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
57338 (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
57339 (void*)&&ZEND_NULL_LABEL,
57340 (void*)&&ZEND_ECHO_SPEC_CV_LABEL,
57341 (void*)&&ZEND_NULL_LABEL,
57342 (void*)&&ZEND_NULL_LABEL,
57343 (void*)&&ZEND_NULL_LABEL,
57344 (void*)&&ZEND_NULL_LABEL,
57345 (void*)&&ZEND_NULL_LABEL,
57346 (void*)&&ZEND_NULL_LABEL,
57347 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
57348 (void*)&&ZEND_NULL_LABEL,
57349 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
57350 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
57351 (void*)&&ZEND_NULL_LABEL,
57352 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
57353 (void*)&&ZEND_NULL_LABEL,
57354 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
57355 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
57356 (void*)&&ZEND_NULL_LABEL,
57357 (void*)&&ZEND_NULL_LABEL,
57358 (void*)&&ZEND_NULL_LABEL,
57359 (void*)&&ZEND_NULL_LABEL,
57360 (void*)&&ZEND_NULL_LABEL,
57361 (void*)&&ZEND_NULL_LABEL,
57362 (void*)&&ZEND_INSTANCEOF_SPEC_CV_CONST_LABEL,
57363 (void*)&&ZEND_NULL_LABEL,
57364 (void*)&&ZEND_INSTANCEOF_SPEC_CV_VAR_LABEL,
57365 (void*)&&ZEND_INSTANCEOF_SPEC_CV_UNUSED_LABEL,
57366 (void*)&&ZEND_NULL_LABEL,
57367 (void*)&&ZEND_GENERATOR_CREATE_SPEC_LABEL,
57368 (void*)&&ZEND_NULL_LABEL,
57369 (void*)&&ZEND_NULL_LABEL,
57370 (void*)&&ZEND_MAKE_REF_SPEC_VAR_UNUSED_LABEL,
57371 (void*)&&ZEND_NULL_LABEL,
57372 (void*)&&ZEND_MAKE_REF_SPEC_CV_UNUSED_LABEL,
57373 (void*)&&ZEND_DECLARE_FUNCTION_SPEC_LABEL,
57374 (void*)&&ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_LABEL,
57375 (void*)&&ZEND_DECLARE_CONST_SPEC_CONST_CONST_LABEL,
57376 (void*)&&ZEND_DECLARE_CLASS_SPEC_CONST_LABEL,
57377 (void*)&&ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_LABEL,
57378 (void*)&&ZEND_DECLARE_ANON_CLASS_SPEC_LABEL,
57379 (void*)&&ZEND_ADD_ARRAY_UNPACK_SPEC_LABEL,
57380 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_LABEL,
57381 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
57382 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
57383 (void*)&&ZEND_NULL_LABEL,
57384 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_LABEL,
57385 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
57386 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57387 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57388 (void*)&&ZEND_NULL_LABEL,
57389 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
57390 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
57391 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57392 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57393 (void*)&&ZEND_NULL_LABEL,
57394 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
57395 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_LABEL,
57396 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57397 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57398 (void*)&&ZEND_NULL_LABEL,
57399 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_LABEL,
57400 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_LABEL,
57401 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
57402 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
57403 (void*)&&ZEND_NULL_LABEL,
57404 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_LABEL,
57405 (void*)&&ZEND_HANDLE_EXCEPTION_SPEC_LABEL,
57406 (void*)&&ZEND_USER_OPCODE_SPEC_LABEL,
57407 (void*)&&ZEND_ASSERT_CHECK_SPEC_LABEL,
57408 (void*)&&ZEND_JMP_SET_SPEC_CONST_LABEL,
57409 (void*)&&ZEND_JMP_SET_SPEC_TMP_LABEL,
57410 (void*)&&ZEND_JMP_SET_SPEC_VAR_LABEL,
57411 (void*)&&ZEND_NULL_LABEL,
57412 (void*)&&ZEND_JMP_SET_SPEC_CV_LABEL,
57413 (void*)&&ZEND_UNSET_CV_SPEC_CV_UNUSED_LABEL,
57414 (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_LABEL,
57415 (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_LABEL,
57416 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CONST_LABEL,
57417 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
57418 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
57419 (void*)&&ZEND_NULL_LABEL,
57420 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CV_LABEL,
57421 (void*)&&ZEND_SEPARATE_SPEC_VAR_UNUSED_LABEL,
57422 (void*)&&ZEND_NULL_LABEL,
57423 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
57424 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
57425 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_LABEL,
57426 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_CV_LABEL,
57427 (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_LABEL,
57428 (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_LABEL,
57429 (void*)&&ZEND_DISCARD_EXCEPTION_SPEC_LABEL,
57430 (void*)&&ZEND_YIELD_SPEC_CONST_CONST_LABEL,
57431 (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
57432 (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
57433 (void*)&&ZEND_YIELD_SPEC_CONST_UNUSED_LABEL,
57434 (void*)&&ZEND_YIELD_SPEC_CONST_CV_LABEL,
57435 (void*)&&ZEND_YIELD_SPEC_TMP_CONST_LABEL,
57436 (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
57437 (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
57438 (void*)&&ZEND_YIELD_SPEC_TMP_UNUSED_LABEL,
57439 (void*)&&ZEND_YIELD_SPEC_TMP_CV_LABEL,
57440 (void*)&&ZEND_YIELD_SPEC_VAR_CONST_LABEL,
57441 (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
57442 (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
57443 (void*)&&ZEND_YIELD_SPEC_VAR_UNUSED_LABEL,
57444 (void*)&&ZEND_YIELD_SPEC_VAR_CV_LABEL,
57445 (void*)&&ZEND_YIELD_SPEC_UNUSED_CONST_LABEL,
57446 (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
57447 (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
57448 (void*)&&ZEND_YIELD_SPEC_UNUSED_UNUSED_LABEL,
57449 (void*)&&ZEND_YIELD_SPEC_UNUSED_CV_LABEL,
57450 (void*)&&ZEND_YIELD_SPEC_CV_CONST_LABEL,
57451 (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
57452 (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
57453 (void*)&&ZEND_YIELD_SPEC_CV_UNUSED_LABEL,
57454 (void*)&&ZEND_YIELD_SPEC_CV_CV_LABEL,
57455 (void*)&&ZEND_GENERATOR_RETURN_SPEC_CONST_LABEL,
57456 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57457 (void*)&&ZEND_GENERATOR_RETURN_SPEC_TMP_LABEL,
57458 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57459 (void*)&&ZEND_GENERATOR_RETURN_SPEC_VAR_LABEL,
57460 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57461 (void*)&&ZEND_NULL_LABEL,
57462 (void*)&&ZEND_NULL_LABEL,
57463 (void*)&&ZEND_GENERATOR_RETURN_SPEC_CV_LABEL,
57464 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57465 (void*)&&ZEND_FAST_CALL_SPEC_LABEL,
57466 (void*)&&ZEND_FAST_RET_SPEC_LABEL,
57467 (void*)&&ZEND_RECV_VARIADIC_SPEC_UNUSED_LABEL,
57468 (void*)&&ZEND_SEND_UNPACK_SPEC_LABEL,
57469 (void*)&&ZEND_YIELD_FROM_SPEC_CONST_LABEL,
57470 (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
57471 (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
57472 (void*)&&ZEND_NULL_LABEL,
57473 (void*)&&ZEND_YIELD_FROM_SPEC_CV_LABEL,
57474 (void*)&&ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_LABEL,
57475 (void*)&&ZEND_BIND_GLOBAL_SPEC_CV_CONST_LABEL,
57476 (void*)&&ZEND_COALESCE_SPEC_CONST_LABEL,
57477 (void*)&&ZEND_COALESCE_SPEC_TMP_LABEL,
57478 (void*)&&ZEND_COALESCE_SPEC_VAR_LABEL,
57479 (void*)&&ZEND_NULL_LABEL,
57480 (void*)&&ZEND_COALESCE_SPEC_CV_LABEL,
57481 (void*)&&ZEND_SPACESHIP_SPEC_CONST_CONST_LABEL,
57482 (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
57483 (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
57484 (void*)&&ZEND_NULL_LABEL,
57485 (void*)&&ZEND_SPACESHIP_SPEC_CONST_CV_LABEL,
57486 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
57487 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57488 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57489 (void*)&&ZEND_NULL_LABEL,
57490 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
57491 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
57492 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57493 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57494 (void*)&&ZEND_NULL_LABEL,
57495 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
57496 (void*)&&ZEND_NULL_LABEL,
57497 (void*)&&ZEND_NULL_LABEL,
57498 (void*)&&ZEND_NULL_LABEL,
57499 (void*)&&ZEND_NULL_LABEL,
57500 (void*)&&ZEND_NULL_LABEL,
57501 (void*)&&ZEND_SPACESHIP_SPEC_CV_CONST_LABEL,
57502 (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
57503 (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
57504 (void*)&&ZEND_NULL_LABEL,
57505 (void*)&&ZEND_SPACESHIP_SPEC_CV_CV_LABEL,
57506 (void*)&&ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57507 (void*)&&ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_LABEL,
57508 (void*)&&ZEND_NULL_LABEL,
57509 (void*)&&ZEND_NULL_LABEL,
57510 (void*)&&ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57511 (void*)&&ZEND_NULL_LABEL,
57512 (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_LABEL,
57513 (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_LABEL,
57514 (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_LABEL,
57515 (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_LABEL,
57516 (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_LABEL,
57517 (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_LABEL,
57518 (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_LABEL,
57519 (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_LABEL,
57520 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_LABEL,
57521 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57522 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57523 (void*)&&ZEND_NULL_LABEL,
57524 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57525 (void*)&&ZEND_NULL_LABEL,
57526 (void*)&&ZEND_NULL_LABEL,
57527 (void*)&&ZEND_NULL_LABEL,
57528 (void*)&&ZEND_NULL_LABEL,
57529 (void*)&&ZEND_NULL_LABEL,
57530 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_LABEL,
57531 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57532 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57533 (void*)&&ZEND_NULL_LABEL,
57534 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57535 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_LABEL,
57536 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57537 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57538 (void*)&&ZEND_NULL_LABEL,
57539 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57540 (void*)&&ZEND_NULL_LABEL,
57541 (void*)&&ZEND_NULL_LABEL,
57542 (void*)&&ZEND_NULL_LABEL,
57543 (void*)&&ZEND_NULL_LABEL,
57544 (void*)&&ZEND_NULL_LABEL,
57545 (void*)&&ZEND_BIND_LEXICAL_SPEC_TMP_CV_LABEL,
57546 (void*)&&ZEND_BIND_STATIC_SPEC_CV_LABEL,
57547 (void*)&&ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_LABEL,
57548 (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_LABEL,
57549 (void*)&&ZEND_NULL_LABEL,
57550 (void*)&&ZEND_NULL_LABEL,
57551 (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
57552 (void*)&&ZEND_NULL_LABEL,
57553 (void*)&&ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_LABEL,
57554 (void*)&&ZEND_SWITCH_LONG_SPEC_CONST_CONST_LABEL,
57555 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57556 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57557 (void*)&&ZEND_NULL_LABEL,
57558 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57559 (void*)&&ZEND_SWITCH_STRING_SPEC_CONST_CONST_LABEL,
57560 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57561 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57562 (void*)&&ZEND_NULL_LABEL,
57563 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57564 (void*)&&ZEND_IN_ARRAY_SPEC_CONST_CONST_LABEL,
57565 (void*)&&ZEND_IN_ARRAY_SPEC_TMP_CONST_LABEL,
57566 (void*)&&ZEND_IN_ARRAY_SPEC_VAR_CONST_LABEL,
57567 (void*)&&ZEND_NULL_LABEL,
57568 (void*)&&ZEND_IN_ARRAY_SPEC_CV_CONST_LABEL,
57569 (void*)&&ZEND_COUNT_SPEC_CONST_UNUSED_LABEL,
57570 (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
57571 (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
57572 (void*)&&ZEND_NULL_LABEL,
57573 (void*)&&ZEND_COUNT_SPEC_CV_UNUSED_LABEL,
57574 (void*)&&ZEND_GET_CLASS_SPEC_CONST_UNUSED_LABEL,
57575 (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
57576 (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
57577 (void*)&&ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57578 (void*)&&ZEND_GET_CLASS_SPEC_CV_UNUSED_LABEL,
57579 (void*)&&ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57580 (void*)&&ZEND_GET_TYPE_SPEC_CONST_UNUSED_LABEL,
57581 (void*)&&ZEND_GET_TYPE_SPEC_TMP_UNUSED_LABEL,
57582 (void*)&&ZEND_GET_TYPE_SPEC_VAR_UNUSED_LABEL,
57583 (void*)&&ZEND_NULL_LABEL,
57584 (void*)&&ZEND_GET_TYPE_SPEC_CV_UNUSED_LABEL,
57585 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_LABEL,
57586 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
57587 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
57588 (void*)&&ZEND_NULL_LABEL,
57589 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_LABEL,
57590 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
57591 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57592 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57593 (void*)&&ZEND_NULL_LABEL,
57594 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
57595 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
57596 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57597 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57598 (void*)&&ZEND_NULL_LABEL,
57599 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
57600 (void*)&&ZEND_NULL_LABEL,
57601 (void*)&&ZEND_NULL_LABEL,
57602 (void*)&&ZEND_NULL_LABEL,
57603 (void*)&&ZEND_NULL_LABEL,
57604 (void*)&&ZEND_NULL_LABEL,
57605 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_LABEL,
57606 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
57607 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
57608 (void*)&&ZEND_NULL_LABEL,
57609 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL,
57610 (void*)&&ZEND_MATCH_SPEC_CONST_CONST_LABEL,
57611 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57612 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57613 (void*)&&ZEND_NULL_LABEL,
57614 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57615 (void*)&&ZEND_NULL_LABEL,
57616 (void*)&&ZEND_NULL_LABEL,
57617 (void*)&&ZEND_NULL_LABEL,
57618 (void*)&&ZEND_NULL_LABEL,
57619 (void*)&&ZEND_NULL_LABEL,
57620 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CONST_LABEL,
57621 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_TMP_LABEL,
57622 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_VAR_LABEL,
57623 (void*)&&ZEND_NULL_LABEL,
57624 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CV_LABEL,
57625 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CONST_LABEL,
57626 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_TMP_LABEL,
57627 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_VAR_LABEL,
57628 (void*)&&ZEND_NULL_LABEL,
57629 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CV_LABEL,
57630 (void*)&&ZEND_NULL_LABEL,
57631 (void*)&&ZEND_NULL_LABEL,
57632 (void*)&&ZEND_NULL_LABEL,
57633 (void*)&&ZEND_NULL_LABEL,
57634 (void*)&&ZEND_NULL_LABEL,
57635 (void*)&&ZEND_NULL_LABEL,
57636 (void*)&&ZEND_NULL_LABEL,
57637 (void*)&&ZEND_NULL_LABEL,
57638 (void*)&&ZEND_NULL_LABEL,
57639 (void*)&&ZEND_NULL_LABEL,
57640 (void*)&&ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_LABEL,
57641 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57642 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57643 (void*)&&ZEND_NULL_LABEL,
57644 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57645 (void*)&&ZEND_JMP_NULL_SPEC_CONST_LABEL,
57646 (void*)&&ZEND_JMP_NULL_SPEC_TMP_LABEL,
57647 (void*)&&ZEND_JMP_NULL_SPEC_VAR_LABEL,
57648 (void*)&&ZEND_NULL_LABEL,
57649 (void*)&&ZEND_JMP_NULL_SPEC_CV_LABEL,
57650 (void*)&&ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57651 (void*)&&ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_LABEL,
57652 (void*)&&ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_LABEL,
57653 (void*)&&ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_LABEL,
57654 (void*)&&ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_LABEL,
57655 (void*)&&ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_LABEL,
57656 (void*)&&ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_LABEL,
57657 (void*)&&ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_LABEL,
57658 (void*)&&ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_LABEL,
57659 (void*)&&ZEND_FRAMELESS_ICALL_2_SPEC_LABEL,
57660 (void*)&&ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_LABEL,
57661 (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_LABEL,
57662 (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_LABEL,
57663 (void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL,
57664 (void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL,
57665 (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL,
57666 (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL,
57667 (void*)&&ZEND_NULL_LABEL,
57668 (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
57669 (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
57670 (void*)&&ZEND_NULL_LABEL,
57671 (void*)&&ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_LABEL,
57672 (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL,
57673 (void*)&&ZEND_NULL_LABEL,
57674 (void*)&&ZEND_NULL_LABEL,
57675 (void*)&&ZEND_NULL_LABEL,
57676 (void*)&&ZEND_NULL_LABEL,
57677 (void*)&&ZEND_NULL_LABEL,
57678 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57679 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57680 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57681 (void*)&&ZEND_NULL_LABEL,
57682 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57683 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57684 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57685 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57686 (void*)&&ZEND_NULL_LABEL,
57687 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57688 (void*)&&ZEND_NULL_LABEL,
57689 (void*)&&ZEND_NULL_LABEL,
57690 (void*)&&ZEND_NULL_LABEL,
57691 (void*)&&ZEND_NULL_LABEL,
57692 (void*)&&ZEND_NULL_LABEL,
57693 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57694 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57695 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57696 (void*)&&ZEND_NULL_LABEL,
57697 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57698 (void*)&&ZEND_NULL_LABEL,
57699 (void*)&&ZEND_NULL_LABEL,
57700 (void*)&&ZEND_NULL_LABEL,
57701 (void*)&&ZEND_NULL_LABEL,
57702 (void*)&&ZEND_NULL_LABEL,
57703 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57704 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57705 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57706 (void*)&&ZEND_NULL_LABEL,
57707 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57708 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57709 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57710 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57711 (void*)&&ZEND_NULL_LABEL,
57712 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57713 (void*)&&ZEND_NULL_LABEL,
57714 (void*)&&ZEND_NULL_LABEL,
57715 (void*)&&ZEND_NULL_LABEL,
57716 (void*)&&ZEND_NULL_LABEL,
57717 (void*)&&ZEND_NULL_LABEL,
57718 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57719 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57720 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57721 (void*)&&ZEND_NULL_LABEL,
57722 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57723 (void*)&&ZEND_NULL_LABEL,
57724 (void*)&&ZEND_NULL_LABEL,
57725 (void*)&&ZEND_NULL_LABEL,
57726 (void*)&&ZEND_NULL_LABEL,
57727 (void*)&&ZEND_NULL_LABEL,
57728 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57729 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57730 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57731 (void*)&&ZEND_NULL_LABEL,
57732 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57733 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57734 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57735 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57736 (void*)&&ZEND_NULL_LABEL,
57737 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57738 (void*)&&ZEND_NULL_LABEL,
57739 (void*)&&ZEND_NULL_LABEL,
57740 (void*)&&ZEND_NULL_LABEL,
57741 (void*)&&ZEND_NULL_LABEL,
57742 (void*)&&ZEND_NULL_LABEL,
57743 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57744 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57745 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57746 (void*)&&ZEND_NULL_LABEL,
57747 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57748 (void*)&&ZEND_NULL_LABEL,
57749 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57750 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57751 (void*)&&ZEND_NULL_LABEL,
57752 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57753 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57754 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57755 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57756 (void*)&&ZEND_NULL_LABEL,
57757 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57758 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57759 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57760 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57761 (void*)&&ZEND_NULL_LABEL,
57762 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57763 (void*)&&ZEND_NULL_LABEL,
57764 (void*)&&ZEND_NULL_LABEL,
57765 (void*)&&ZEND_NULL_LABEL,
57766 (void*)&&ZEND_NULL_LABEL,
57767 (void*)&&ZEND_NULL_LABEL,
57768 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57769 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57770 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57771 (void*)&&ZEND_NULL_LABEL,
57772 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57773 (void*)&&ZEND_NULL_LABEL,
57774 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57775 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57776 (void*)&&ZEND_NULL_LABEL,
57777 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57778 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57779 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57780 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57781 (void*)&&ZEND_NULL_LABEL,
57782 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57783 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57784 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57785 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57786 (void*)&&ZEND_NULL_LABEL,
57787 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57788 (void*)&&ZEND_NULL_LABEL,
57789 (void*)&&ZEND_NULL_LABEL,
57790 (void*)&&ZEND_NULL_LABEL,
57791 (void*)&&ZEND_NULL_LABEL,
57792 (void*)&&ZEND_NULL_LABEL,
57793 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57794 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57795 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57796 (void*)&&ZEND_NULL_LABEL,
57797 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57798 (void*)&&ZEND_NULL_LABEL,
57799 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57800 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57801 (void*)&&ZEND_NULL_LABEL,
57802 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57803 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57804 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57805 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57806 (void*)&&ZEND_NULL_LABEL,
57807 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57808 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57809 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57810 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57811 (void*)&&ZEND_NULL_LABEL,
57812 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57813 (void*)&&ZEND_NULL_LABEL,
57814 (void*)&&ZEND_NULL_LABEL,
57815 (void*)&&ZEND_NULL_LABEL,
57816 (void*)&&ZEND_NULL_LABEL,
57817 (void*)&&ZEND_NULL_LABEL,
57818 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57819 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57820 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57821 (void*)&&ZEND_NULL_LABEL,
57822 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57823 (void*)&&ZEND_NULL_LABEL,
57824 (void*)&&ZEND_NULL_LABEL,
57825 (void*)&&ZEND_NULL_LABEL,
57826 (void*)&&ZEND_NULL_LABEL,
57827 (void*)&&ZEND_NULL_LABEL,
57828 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57829 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57830 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57831 (void*)&&ZEND_NULL_LABEL,
57832 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57833 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57834 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57835 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57836 (void*)&&ZEND_NULL_LABEL,
57837 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57838 (void*)&&ZEND_NULL_LABEL,
57839 (void*)&&ZEND_NULL_LABEL,
57840 (void*)&&ZEND_NULL_LABEL,
57841 (void*)&&ZEND_NULL_LABEL,
57842 (void*)&&ZEND_NULL_LABEL,
57843 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57844 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57845 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57846 (void*)&&ZEND_NULL_LABEL,
57847 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57848 (void*)&&ZEND_NULL_LABEL,
57849 (void*)&&ZEND_NULL_LABEL,
57850 (void*)&&ZEND_NULL_LABEL,
57851 (void*)&&ZEND_NULL_LABEL,
57852 (void*)&&ZEND_NULL_LABEL,
57853 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57854 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57855 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57856 (void*)&&ZEND_NULL_LABEL,
57857 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57858 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57859 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57860 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57861 (void*)&&ZEND_NULL_LABEL,
57862 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57863 (void*)&&ZEND_NULL_LABEL,
57864 (void*)&&ZEND_NULL_LABEL,
57865 (void*)&&ZEND_NULL_LABEL,
57866 (void*)&&ZEND_NULL_LABEL,
57867 (void*)&&ZEND_NULL_LABEL,
57868 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57869 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57870 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57871 (void*)&&ZEND_NULL_LABEL,
57872 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57873 (void*)&&ZEND_NULL_LABEL,
57874 (void*)&&ZEND_NULL_LABEL,
57875 (void*)&&ZEND_NULL_LABEL,
57876 (void*)&&ZEND_NULL_LABEL,
57877 (void*)&&ZEND_NULL_LABEL,
57878 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57879 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57880 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57881 (void*)&&ZEND_NULL_LABEL,
57882 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57883 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57884 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57885 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57886 (void*)&&ZEND_NULL_LABEL,
57887 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57888 (void*)&&ZEND_NULL_LABEL,
57889 (void*)&&ZEND_NULL_LABEL,
57890 (void*)&&ZEND_NULL_LABEL,
57891 (void*)&&ZEND_NULL_LABEL,
57892 (void*)&&ZEND_NULL_LABEL,
57893 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57894 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57895 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57896 (void*)&&ZEND_NULL_LABEL,
57897 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57898 (void*)&&ZEND_NULL_LABEL,
57899 (void*)&&ZEND_NULL_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_NULL_LABEL,
57906 (void*)&&ZEND_NULL_LABEL,
57907 (void*)&&ZEND_NULL_LABEL,
57908 (void*)&&ZEND_NULL_LABEL,
57909 (void*)&&ZEND_NULL_LABEL,
57910 (void*)&&ZEND_NULL_LABEL,
57911 (void*)&&ZEND_NULL_LABEL,
57912 (void*)&&ZEND_NULL_LABEL,
57913 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57914 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57915 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57916 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57917 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57918 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57919 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57920 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57921 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57922 (void*)&&ZEND_NULL_LABEL,
57923 (void*)&&ZEND_NULL_LABEL,
57924 (void*)&&ZEND_NULL_LABEL,
57925 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57926 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57927 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57928 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57929 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57930 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57931 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57932 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57933 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57934 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57935 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57936 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57937 (void*)&&ZEND_NULL_LABEL,
57938 (void*)&&ZEND_NULL_LABEL,
57939 (void*)&&ZEND_NULL_LABEL,
57940 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57941 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57942 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57943 (void*)&&ZEND_NULL_LABEL,
57944 (void*)&&ZEND_NULL_LABEL,
57945 (void*)&&ZEND_NULL_LABEL,
57946 (void*)&&ZEND_NULL_LABEL,
57947 (void*)&&ZEND_NULL_LABEL,
57948 (void*)&&ZEND_NULL_LABEL,
57949 (void*)&&ZEND_NULL_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_NULL_LABEL,
57956 (void*)&&ZEND_NULL_LABEL,
57957 (void*)&&ZEND_NULL_LABEL,
57958 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57959 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57960 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57961 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57962 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57963 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57964 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57965 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57966 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57967 (void*)&&ZEND_NULL_LABEL,
57968 (void*)&&ZEND_NULL_LABEL,
57969 (void*)&&ZEND_NULL_LABEL,
57970 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57971 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57972 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57973 (void*)&&ZEND_NULL_LABEL,
57974 (void*)&&ZEND_NULL_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_NULL_LABEL,
57981 (void*)&&ZEND_NULL_LABEL,
57982 (void*)&&ZEND_NULL_LABEL,
57983 (void*)&&ZEND_NULL_LABEL,
57984 (void*)&&ZEND_NULL_LABEL,
57985 (void*)&&ZEND_NULL_LABEL,
57986 (void*)&&ZEND_NULL_LABEL,
57987 (void*)&&ZEND_NULL_LABEL,
57988 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57989 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57990 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57991 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57992 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57993 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57994 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57995 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57996 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57997 (void*)&&ZEND_NULL_LABEL,
57998 (void*)&&ZEND_NULL_LABEL,
57999 (void*)&&ZEND_NULL_LABEL,
58000 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58001 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58002 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58003 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58004 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58005 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58006 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58007 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58008 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58009 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58010 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58011 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58012 (void*)&&ZEND_NULL_LABEL,
58013 (void*)&&ZEND_NULL_LABEL,
58014 (void*)&&ZEND_NULL_LABEL,
58015 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58016 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58017 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58018 (void*)&&ZEND_NULL_LABEL,
58019 (void*)&&ZEND_NULL_LABEL,
58020 (void*)&&ZEND_NULL_LABEL,
58021 (void*)&&ZEND_NULL_LABEL,
58022 (void*)&&ZEND_NULL_LABEL,
58023 (void*)&&ZEND_NULL_LABEL,
58024 (void*)&&ZEND_NULL_LABEL,
58025 (void*)&&ZEND_NULL_LABEL,
58026 (void*)&&ZEND_NULL_LABEL,
58027 (void*)&&ZEND_NULL_LABEL,
58028 (void*)&&ZEND_NULL_LABEL,
58029 (void*)&&ZEND_NULL_LABEL,
58030 (void*)&&ZEND_NULL_LABEL,
58031 (void*)&&ZEND_NULL_LABEL,
58032 (void*)&&ZEND_NULL_LABEL,
58033 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58034 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58035 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58036 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58037 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58038 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58039 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58040 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58041 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58042 (void*)&&ZEND_NULL_LABEL,
58043 (void*)&&ZEND_NULL_LABEL,
58044 (void*)&&ZEND_NULL_LABEL,
58045 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58046 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58047 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58048 (void*)&&ZEND_NULL_LABEL,
58049 (void*)&&ZEND_NULL_LABEL,
58050 (void*)&&ZEND_NULL_LABEL,
58051 (void*)&&ZEND_NULL_LABEL,
58052 (void*)&&ZEND_NULL_LABEL,
58053 (void*)&&ZEND_NULL_LABEL,
58054 (void*)&&ZEND_NULL_LABEL,
58055 (void*)&&ZEND_NULL_LABEL,
58056 (void*)&&ZEND_NULL_LABEL,
58057 (void*)&&ZEND_NULL_LABEL,
58058 (void*)&&ZEND_NULL_LABEL,
58059 (void*)&&ZEND_NULL_LABEL,
58060 (void*)&&ZEND_NULL_LABEL,
58061 (void*)&&ZEND_NULL_LABEL,
58062 (void*)&&ZEND_NULL_LABEL,
58063 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58064 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58065 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58066 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58067 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58068 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58069 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58070 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58071 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58072 (void*)&&ZEND_NULL_LABEL,
58073 (void*)&&ZEND_NULL_LABEL,
58074 (void*)&&ZEND_NULL_LABEL,
58075 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58076 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58077 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58078 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58079 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58080 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58081 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58082 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58083 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58084 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58085 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58086 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58087 (void*)&&ZEND_NULL_LABEL,
58088 (void*)&&ZEND_NULL_LABEL,
58089 (void*)&&ZEND_NULL_LABEL,
58090 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58091 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58092 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58093 (void*)&&ZEND_NULL_LABEL,
58094 (void*)&&ZEND_NULL_LABEL,
58095 (void*)&&ZEND_NULL_LABEL,
58096 (void*)&&ZEND_NULL_LABEL,
58097 (void*)&&ZEND_NULL_LABEL,
58098 (void*)&&ZEND_NULL_LABEL,
58099 (void*)&&ZEND_NULL_LABEL,
58100 (void*)&&ZEND_NULL_LABEL,
58101 (void*)&&ZEND_NULL_LABEL,
58102 (void*)&&ZEND_NULL_LABEL,
58103 (void*)&&ZEND_NULL_LABEL,
58104 (void*)&&ZEND_NULL_LABEL,
58105 (void*)&&ZEND_NULL_LABEL,
58106 (void*)&&ZEND_NULL_LABEL,
58107 (void*)&&ZEND_NULL_LABEL,
58108 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58109 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58110 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58111 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58112 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58113 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58114 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58115 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58116 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58117 (void*)&&ZEND_NULL_LABEL,
58118 (void*)&&ZEND_NULL_LABEL,
58119 (void*)&&ZEND_NULL_LABEL,
58120 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58121 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58122 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58123 (void*)&&ZEND_NULL_LABEL,
58124 (void*)&&ZEND_NULL_LABEL,
58125 (void*)&&ZEND_NULL_LABEL,
58126 (void*)&&ZEND_NULL_LABEL,
58127 (void*)&&ZEND_NULL_LABEL,
58128 (void*)&&ZEND_NULL_LABEL,
58129 (void*)&&ZEND_NULL_LABEL,
58130 (void*)&&ZEND_NULL_LABEL,
58131 (void*)&&ZEND_NULL_LABEL,
58132 (void*)&&ZEND_NULL_LABEL,
58133 (void*)&&ZEND_NULL_LABEL,
58134 (void*)&&ZEND_NULL_LABEL,
58135 (void*)&&ZEND_NULL_LABEL,
58136 (void*)&&ZEND_NULL_LABEL,
58137 (void*)&&ZEND_NULL_LABEL,
58138 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58139 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58140 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58141 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58142 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58143 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58144 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58145 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58146 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58147 (void*)&&ZEND_NULL_LABEL,
58148 (void*)&&ZEND_NULL_LABEL,
58149 (void*)&&ZEND_NULL_LABEL,
58150 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58151 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58152 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58153 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58154 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58155 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58156 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58157 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58158 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58159 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58160 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58161 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58162 (void*)&&ZEND_NULL_LABEL,
58163 (void*)&&ZEND_NULL_LABEL,
58164 (void*)&&ZEND_NULL_LABEL,
58165 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58166 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58167 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58168 (void*)&&ZEND_NULL_LABEL,
58169 (void*)&&ZEND_NULL_LABEL,
58170 (void*)&&ZEND_NULL_LABEL,
58171 (void*)&&ZEND_NULL_LABEL,
58172 (void*)&&ZEND_NULL_LABEL,
58173 (void*)&&ZEND_NULL_LABEL,
58174 (void*)&&ZEND_NULL_LABEL,
58175 (void*)&&ZEND_NULL_LABEL,
58176 (void*)&&ZEND_NULL_LABEL,
58177 (void*)&&ZEND_NULL_LABEL,
58178 (void*)&&ZEND_NULL_LABEL,
58179 (void*)&&ZEND_NULL_LABEL,
58180 (void*)&&ZEND_NULL_LABEL,
58181 (void*)&&ZEND_NULL_LABEL,
58182 (void*)&&ZEND_NULL_LABEL,
58183 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58184 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58185 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58186 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58187 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58188 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58189 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58190 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58191 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58192 (void*)&&ZEND_NULL_LABEL,
58193 (void*)&&ZEND_NULL_LABEL,
58194 (void*)&&ZEND_NULL_LABEL,
58195 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58196 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58197 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58198 (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
58199 (void*)&&ZEND_NULL_LABEL,
58200 (void*)&&ZEND_NULL_LABEL,
58201 (void*)&&ZEND_NULL_LABEL,
58202 (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
58203 (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
58204 (void*)&&ZEND_NULL_LABEL,
58205 (void*)&&ZEND_NULL_LABEL,
58206 (void*)&&ZEND_NULL_LABEL,
58207 (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
58208 (void*)&&ZEND_NULL_LABEL,
58209 (void*)&&ZEND_NULL_LABEL,
58210 (void*)&&ZEND_NULL_LABEL,
58211 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58212 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58213 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58214 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58215 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58216 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58217 (void*)&&ZEND_NULL_LABEL,
58218 (void*)&&ZEND_NULL_LABEL,
58219 (void*)&&ZEND_NULL_LABEL,
58220 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58221 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58222 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58223 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58224 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58225 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58226 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58227 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58228 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58229 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58230 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58231 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58232 (void*)&&ZEND_NULL_LABEL,
58233 (void*)&&ZEND_NULL_LABEL,
58234 (void*)&&ZEND_NULL_LABEL,
58235 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58236 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58237 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58238 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58239 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58240 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58241 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58242 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58243 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58244 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58245 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58246 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58247 (void*)&&ZEND_NULL_LABEL,
58248 (void*)&&ZEND_NULL_LABEL,
58249 (void*)&&ZEND_NULL_LABEL,
58250 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58251 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58252 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58253 (void*)&&ZEND_NULL_LABEL,
58254 (void*)&&ZEND_NULL_LABEL,
58255 (void*)&&ZEND_NULL_LABEL,
58256 (void*)&&ZEND_NULL_LABEL,
58257 (void*)&&ZEND_NULL_LABEL,
58258 (void*)&&ZEND_NULL_LABEL,
58259 (void*)&&ZEND_NULL_LABEL,
58260 (void*)&&ZEND_NULL_LABEL,
58261 (void*)&&ZEND_NULL_LABEL,
58262 (void*)&&ZEND_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_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58269 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58270 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58271 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58272 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58273 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58274 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58275 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58276 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58277 (void*)&&ZEND_NULL_LABEL,
58278 (void*)&&ZEND_NULL_LABEL,
58279 (void*)&&ZEND_NULL_LABEL,
58280 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58281 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58282 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58283 (void*)&&ZEND_NULL_LABEL,
58284 (void*)&&ZEND_NULL_LABEL,
58285 (void*)&&ZEND_NULL_LABEL,
58286 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58287 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58288 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58289 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58290 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58291 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58292 (void*)&&ZEND_NULL_LABEL,
58293 (void*)&&ZEND_NULL_LABEL,
58294 (void*)&&ZEND_NULL_LABEL,
58295 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58296 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58297 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58298 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58299 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58300 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58301 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58302 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58303 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58304 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58305 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58306 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58307 (void*)&&ZEND_NULL_LABEL,
58308 (void*)&&ZEND_NULL_LABEL,
58309 (void*)&&ZEND_NULL_LABEL,
58310 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58311 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58312 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58313 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58314 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58315 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58316 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58317 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58318 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58319 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58320 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58321 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58322 (void*)&&ZEND_NULL_LABEL,
58323 (void*)&&ZEND_NULL_LABEL,
58324 (void*)&&ZEND_NULL_LABEL,
58325 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58326 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58327 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58328 (void*)&&ZEND_NULL_LABEL,
58329 (void*)&&ZEND_NULL_LABEL,
58330 (void*)&&ZEND_NULL_LABEL,
58331 (void*)&&ZEND_NULL_LABEL,
58332 (void*)&&ZEND_NULL_LABEL,
58333 (void*)&&ZEND_NULL_LABEL,
58334 (void*)&&ZEND_NULL_LABEL,
58335 (void*)&&ZEND_NULL_LABEL,
58336 (void*)&&ZEND_NULL_LABEL,
58337 (void*)&&ZEND_NULL_LABEL,
58338 (void*)&&ZEND_NULL_LABEL,
58339 (void*)&&ZEND_NULL_LABEL,
58340 (void*)&&ZEND_NULL_LABEL,
58341 (void*)&&ZEND_NULL_LABEL,
58342 (void*)&&ZEND_NULL_LABEL,
58343 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58344 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58345 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58346 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58347 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58348 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58349 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58350 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58351 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58352 (void*)&&ZEND_NULL_LABEL,
58353 (void*)&&ZEND_NULL_LABEL,
58354 (void*)&&ZEND_NULL_LABEL,
58355 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58356 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58357 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58358 (void*)&&ZEND_NULL_LABEL,
58359 (void*)&&ZEND_NULL_LABEL,
58360 (void*)&&ZEND_NULL_LABEL,
58361 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58362 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58363 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58364 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58365 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58366 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58367 (void*)&&ZEND_NULL_LABEL,
58368 (void*)&&ZEND_NULL_LABEL,
58369 (void*)&&ZEND_NULL_LABEL,
58370 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58371 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58372 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58373 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58374 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58375 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58376 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58377 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58378 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58379 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58380 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58381 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58382 (void*)&&ZEND_NULL_LABEL,
58383 (void*)&&ZEND_NULL_LABEL,
58384 (void*)&&ZEND_NULL_LABEL,
58385 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58386 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58387 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58388 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58389 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58390 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58391 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58392 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58393 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58394 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58395 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58396 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58397 (void*)&&ZEND_NULL_LABEL,
58398 (void*)&&ZEND_NULL_LABEL,
58399 (void*)&&ZEND_NULL_LABEL,
58400 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58401 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58402 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58403 (void*)&&ZEND_NULL_LABEL,
58404 (void*)&&ZEND_NULL_LABEL,
58405 (void*)&&ZEND_NULL_LABEL,
58406 (void*)&&ZEND_NULL_LABEL,
58407 (void*)&&ZEND_NULL_LABEL,
58408 (void*)&&ZEND_NULL_LABEL,
58409 (void*)&&ZEND_NULL_LABEL,
58410 (void*)&&ZEND_NULL_LABEL,
58411 (void*)&&ZEND_NULL_LABEL,
58412 (void*)&&ZEND_NULL_LABEL,
58413 (void*)&&ZEND_NULL_LABEL,
58414 (void*)&&ZEND_NULL_LABEL,
58415 (void*)&&ZEND_NULL_LABEL,
58416 (void*)&&ZEND_NULL_LABEL,
58417 (void*)&&ZEND_NULL_LABEL,
58418 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58419 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58420 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58421 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58422 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58423 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58424 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58425 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58426 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58427 (void*)&&ZEND_NULL_LABEL,
58428 (void*)&&ZEND_NULL_LABEL,
58429 (void*)&&ZEND_NULL_LABEL,
58430 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58431 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58432 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58433 (void*)&&ZEND_NULL_LABEL,
58434 (void*)&&ZEND_NULL_LABEL,
58435 (void*)&&ZEND_NULL_LABEL,
58436 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58437 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58438 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58439 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58440 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58441 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58442 (void*)&&ZEND_NULL_LABEL,
58443 (void*)&&ZEND_NULL_LABEL,
58444 (void*)&&ZEND_NULL_LABEL,
58445 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58446 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58447 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58448 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58449 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58450 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58451 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58452 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58453 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58454 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58455 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58456 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58457 (void*)&&ZEND_NULL_LABEL,
58458 (void*)&&ZEND_NULL_LABEL,
58459 (void*)&&ZEND_NULL_LABEL,
58460 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58461 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58462 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58463 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58464 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58465 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58466 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58467 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58468 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58469 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58470 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58471 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58472 (void*)&&ZEND_NULL_LABEL,
58473 (void*)&&ZEND_NULL_LABEL,
58474 (void*)&&ZEND_NULL_LABEL,
58475 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58476 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58477 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58478 (void*)&&ZEND_NULL_LABEL,
58479 (void*)&&ZEND_NULL_LABEL,
58480 (void*)&&ZEND_NULL_LABEL,
58481 (void*)&&ZEND_NULL_LABEL,
58482 (void*)&&ZEND_NULL_LABEL,
58483 (void*)&&ZEND_NULL_LABEL,
58484 (void*)&&ZEND_NULL_LABEL,
58485 (void*)&&ZEND_NULL_LABEL,
58486 (void*)&&ZEND_NULL_LABEL,
58487 (void*)&&ZEND_NULL_LABEL,
58488 (void*)&&ZEND_NULL_LABEL,
58489 (void*)&&ZEND_NULL_LABEL,
58490 (void*)&&ZEND_NULL_LABEL,
58491 (void*)&&ZEND_NULL_LABEL,
58492 (void*)&&ZEND_NULL_LABEL,
58493 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58494 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58495 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58496 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58497 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58498 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58499 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58500 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58501 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58502 (void*)&&ZEND_NULL_LABEL,
58503 (void*)&&ZEND_NULL_LABEL,
58504 (void*)&&ZEND_NULL_LABEL,
58505 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58506 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58507 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58508 (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
58509 (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
58510 (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
58511 (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_LABEL,
58512 (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
58513 (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
58514 (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
58515 (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_LABEL,
58516 (void*)&&ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
58517 (void*)&&ZEND_POST_INC_LONG_SPEC_CV_LABEL,
58518 (void*)&&ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
58519 (void*)&&ZEND_POST_DEC_LONG_SPEC_CV_LABEL,
58520 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_CONST_LABEL,
58521 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58522 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58523 (void*)&&ZEND_NULL_LABEL,
58524 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58525 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_LABEL,
58526 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58527 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58528 (void*)&&ZEND_NULL_LABEL,
58529 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58530 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_CONST_LABEL,
58531 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58532 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58533 (void*)&&ZEND_NULL_LABEL,
58534 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58535 (void*)&&ZEND_NULL_LABEL,
58536 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58537 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58538 (void*)&&ZEND_NULL_LABEL,
58539 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58540 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
58541 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58542 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58543 (void*)&&ZEND_NULL_LABEL,
58544 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58545 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
58546 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58547 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58548 (void*)&&ZEND_NULL_LABEL,
58549 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58550 (void*)&&ZEND_NULL_LABEL,
58551 (void*)&&ZEND_NULL_LABEL,
58552 (void*)&&ZEND_NULL_LABEL,
58553 (void*)&&ZEND_NULL_LABEL,
58554 (void*)&&ZEND_NULL_LABEL,
58555 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_LABEL,
58556 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58557 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58558 (void*)&&ZEND_NULL_LABEL,
58559 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58560 (void*)&&ZEND_NULL_LABEL,
58561 (void*)&&ZEND_NULL_LABEL,
58562 (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_VAR_LABEL,
58563 (void*)&&ZEND_NULL_LABEL,
58564 (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_CV_LABEL,
58565 (void*)&&ZEND_NULL_LABEL,
58566 (void*)&&ZEND_NULL_LABEL,
58567 (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_LABEL,
58568 (void*)&&ZEND_NULL_LABEL,
58569 (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_LABEL,
58570 (void*)&&ZEND_SEND_VAL_SIMPLE_SPEC_CONST_LABEL,
58571 (void*)&&ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_LABEL,
58572 (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
58573 (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_LABEL,
58574 (void*)&&ZEND_NULL_LABEL
58575 };
58576 zend_opcode_handlers = (const void **) labels;
58577 zend_handlers_count = sizeof(labels) / sizeof(void*);
58578 memset(&hybrid_halt_op, 0, sizeof(hybrid_halt_op));
58579 hybrid_halt_op.handler = (void*)&&HYBRID_HALT_LABEL;
58580#ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
58581 memset(vm_stack_data.hybrid_jit_red_zone, 0, ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE);
58582#endif
58583 if (zend_touch_vm_stack_data) {
58584 zend_touch_vm_stack_data(&vm_stack_data);
58585 }
58586 goto HYBRID_HALT_LABEL;
58587 }
58588#endif
58589
58590 LOAD_OPLINE();
58591 ZEND_VM_LOOP_INTERRUPT_CHECK();
58592
58593#ifdef ZEND_CHECK_STACK_LIMIT
58594 if (UNEXPECTED(zend_call_stack_overflowed(EG(stack_limit)))) {
58595 zend_call_stack_size_error();
58596 /* No opline was executed before exception */
58597 EG(opline_before_exception) = NULL;
58598 LOAD_OPLINE();
58599 /* Fall through to handle exception below. */
58600 }
58601#endif /* ZEND_CHECK_STACK_LIMIT */
58602
58603 while (1) {
58604#if !defined(ZEND_VM_FP_GLOBAL_REG) || !defined(ZEND_VM_IP_GLOBAL_REG)
58605 int ret;
58606#endif
58607#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
58608 HYBRID_SWITCH() {
58609#else
58610#if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
58611 ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58612 if (UNEXPECTED(!OPLINE)) {
58613#else
58614 if (UNEXPECTED((ret = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)) != 0)) {
58615#endif
58616#endif
58617#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
58618 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC):
58619 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
58620 ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58621 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
58622 HYBRID_BREAK();
58623 HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC):
58624 VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC)
58625 ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58626 VM_TRACE_OP_END(ZEND_PRE_INC_STATIC_PROP_SPEC)
58627 HYBRID_BREAK();
58628 HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC):
58629 VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC)
58630 ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58631 VM_TRACE_OP_END(ZEND_POST_INC_STATIC_PROP_SPEC)
58632 HYBRID_BREAK();
58633 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC):
58634 VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC)
58635 ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58636 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_R_SPEC)
58637 HYBRID_BREAK();
58638 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_W_SPEC):
58639 VM_TRACE(ZEND_FETCH_STATIC_PROP_W_SPEC)
58640 ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58641 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_W_SPEC)
58642 HYBRID_BREAK();
58643 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_RW_SPEC):
58644 VM_TRACE(ZEND_FETCH_STATIC_PROP_RW_SPEC)
58645 ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58646 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_RW_SPEC)
58647 HYBRID_BREAK();
58648 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC):
58649 VM_TRACE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
58650 ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58651 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
58652 HYBRID_BREAK();
58653 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC):
58654 VM_TRACE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
58655 ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58656 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
58657 HYBRID_BREAK();
58658 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_IS_SPEC):
58659 VM_TRACE(ZEND_FETCH_STATIC_PROP_IS_SPEC)
58660 ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58661 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_IS_SPEC)
58662 HYBRID_BREAK();
58663 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST):
58664 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
58665 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58666 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
58667 HYBRID_BREAK();
58668 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP):
58669 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
58670 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58671 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
58672 HYBRID_BREAK();
58673 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR):
58674 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
58675 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58676 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
58677 HYBRID_BREAK();
58678 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV):
58679 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
58680 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58681 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
58682 HYBRID_BREAK();
58683 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC):
58684 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
58685 ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58686 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
58687 HYBRID_BREAK();
58688zend_leave_helper_SPEC_LABEL:
58689{
58690 zend_execute_data *old_execute_data;
58691 uint32_t call_info = EX_CALL_INFO();
58692 SAVE_OPLINE();
58693
58694 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)) {
58695 EG(current_execute_data) = EX(prev_execute_data);
58696 i_free_compiled_variables(execute_data);
58697
58698#ifdef ZEND_PREFER_RELOAD
58699 call_info = EX_CALL_INFO();
58700#endif
58701 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
58702 OBJ_RELEASE(Z_OBJ(execute_data->This));
58703 } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58704 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58705 }
58706 EG(vm_stack_top) = (zval*)execute_data;
58707 execute_data = EX(prev_execute_data);
58708
58709 if (UNEXPECTED(EG(exception) != NULL)) {
58710 zend_rethrow_exception(execute_data);
58711 HANDLE_EXCEPTION_LEAVE();
58712 }
58713
58714 LOAD_NEXT_OPLINE();
58715 ZEND_VM_LEAVE();
58716 } else if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP)) == 0)) {
58717 EG(current_execute_data) = EX(prev_execute_data);
58718 i_free_compiled_variables(execute_data);
58719
58720#ifdef ZEND_PREFER_RELOAD
58721 call_info = EX_CALL_INFO();
58722#endif
58723 if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58724 zend_clean_and_cache_symbol_table(EX(symbol_table));
58725 }
58726
58727 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
58728 zend_free_extra_named_params(EX(extra_named_params));
58729 }
58730
58731 /* Free extra args before releasing the closure,
58732 * as that may free the op_array. */
58733 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
58734
58735 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
58736 OBJ_RELEASE(Z_OBJ(execute_data->This));
58737 } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58738 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58739 }
58740
58741 old_execute_data = execute_data;
58742 execute_data = EX(prev_execute_data);
58743 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
58744
58745 if (UNEXPECTED(EG(exception) != NULL)) {
58746 zend_rethrow_exception(execute_data);
58747 HANDLE_EXCEPTION_LEAVE();
58748 }
58749
58750 LOAD_NEXT_OPLINE();
58751 ZEND_VM_LEAVE();
58752 } else if (EXPECTED((call_info & ZEND_CALL_TOP) == 0)) {
58753 if (EX(func)->op_array.last_var > 0) {
58754 zend_detach_symbol_table(execute_data);
58755 call_info |= ZEND_CALL_NEEDS_REATTACH;
58756 }
58757 zend_destroy_static_vars(&EX(func)->op_array);
58758 destroy_op_array(&EX(func)->op_array);
58759 efree_size(EX(func), sizeof(zend_op_array));
58760 old_execute_data = execute_data;
58761 execute_data = EG(current_execute_data) = EX(prev_execute_data);
58762 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
58763
58764 if (call_info & ZEND_CALL_NEEDS_REATTACH) {
58765 if (EX(func)->op_array.last_var > 0) {
58766 zend_attach_symbol_table(execute_data);
58767 } else {
58768 ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_NEEDS_REATTACH);
58769 }
58770 }
58771 if (UNEXPECTED(EG(exception) != NULL)) {
58772 zend_rethrow_exception(execute_data);
58773 HANDLE_EXCEPTION_LEAVE();
58774 }
58775
58776 LOAD_NEXT_OPLINE();
58777 ZEND_VM_LEAVE();
58778 } else {
58779 if (EXPECTED((call_info & ZEND_CALL_CODE) == 0)) {
58780 EG(current_execute_data) = EX(prev_execute_data);
58781 i_free_compiled_variables(execute_data);
58782#ifdef ZEND_PREFER_RELOAD
58783 call_info = EX_CALL_INFO();
58784#endif
58785 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) {
58786 if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58787 zend_clean_and_cache_symbol_table(EX(symbol_table));
58788 }
58789 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
58790 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
58791 zend_free_extra_named_params(EX(extra_named_params));
58792 }
58793 }
58794 if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58795 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58796 }
58797 ZEND_VM_RETURN();
58798 } else /* if (call_kind == ZEND_CALL_TOP_CODE) */ {
58799 zend_array *symbol_table = EX(symbol_table);
58800
58801 if (EX(func)->op_array.last_var > 0) {
58802 zend_detach_symbol_table(execute_data);
58803 call_info |= ZEND_CALL_NEEDS_REATTACH;
58804 }
58805 if (call_info & ZEND_CALL_NEEDS_REATTACH) {
58806 old_execute_data = EX(prev_execute_data);
58807 while (old_execute_data) {
58808 if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58809 if (old_execute_data->symbol_table == symbol_table) {
58810 if (old_execute_data->func->op_array.last_var > 0) {
58811 zend_attach_symbol_table(old_execute_data);
58812 } else {
58813 ZEND_ADD_CALL_FLAG(old_execute_data, ZEND_CALL_NEEDS_REATTACH);
58814 }
58815 }
58816 break;
58817 }
58818 old_execute_data = old_execute_data->prev_execute_data;
58819 }
58820 }
58821 EG(current_execute_data) = EX(prev_execute_data);
58822 ZEND_VM_RETURN();
58823 }
58824 }
58825}
58826
58827 HYBRID_CASE(ZEND_JMP_SPEC):
58828 VM_TRACE(ZEND_JMP_SPEC)
58829 ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58830 VM_TRACE_OP_END(ZEND_JMP_SPEC)
58831 HYBRID_BREAK();
58832 HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED):
58833 VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
58834 ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58835 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
58836 HYBRID_BREAK();
58837 HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_USED):
58838 VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_USED)
58839 ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58840 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_USED)
58841 HYBRID_BREAK();
58842 HYBRID_CASE(ZEND_DO_ICALL_SPEC_OBSERVER):
58843 VM_TRACE(ZEND_DO_ICALL_SPEC_OBSERVER)
58844 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58845 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_OBSERVER)
58846 HYBRID_BREAK();
58847 HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED):
58848 VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
58849 ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58850 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
58851 HYBRID_BREAK();
58852 HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_USED):
58853 VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_USED)
58854 ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58855 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_USED)
58856 HYBRID_BREAK();
58857 HYBRID_CASE(ZEND_DO_UCALL_SPEC_OBSERVER):
58858 VM_TRACE(ZEND_DO_UCALL_SPEC_OBSERVER)
58859 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58860 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_OBSERVER)
58861 HYBRID_BREAK();
58862 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED):
58863 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
58864 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58865 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
58866 HYBRID_BREAK();
58867 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED):
58868 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
58869 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58870 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
58871 HYBRID_BREAK();
58872 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER):
58873 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
58874 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58875 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
58876 HYBRID_BREAK();
58877 HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED):
58878 VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
58879 ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58880 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
58881 HYBRID_BREAK();
58882 HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_USED):
58883 VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_USED)
58884 ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58885 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_USED)
58886 HYBRID_BREAK();
58887 HYBRID_CASE(ZEND_DO_FCALL_SPEC_OBSERVER):
58888 VM_TRACE(ZEND_DO_FCALL_SPEC_OBSERVER)
58889 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58890 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_OBSERVER)
58891 HYBRID_BREAK();
58892 HYBRID_CASE(ZEND_GENERATOR_CREATE_SPEC):
58893 VM_TRACE(ZEND_GENERATOR_CREATE_SPEC)
58894 ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58895 VM_TRACE_OP_END(ZEND_GENERATOR_CREATE_SPEC)
58896 HYBRID_BREAK();
58897 HYBRID_CASE(ZEND_SEND_UNPACK_SPEC):
58898 VM_TRACE(ZEND_SEND_UNPACK_SPEC)
58899 ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58900 VM_TRACE_OP_END(ZEND_SEND_UNPACK_SPEC)
58901 HYBRID_BREAK();
58902 HYBRID_CASE(ZEND_SEND_ARRAY_SPEC):
58903 VM_TRACE(ZEND_SEND_ARRAY_SPEC)
58904 ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58905 VM_TRACE_OP_END(ZEND_SEND_ARRAY_SPEC)
58906 HYBRID_BREAK();
58907 HYBRID_CASE(ZEND_RECV_NOTYPE_SPEC):
58908 VM_TRACE(ZEND_RECV_NOTYPE_SPEC)
58909 ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58910 VM_TRACE_OP_END(ZEND_RECV_NOTYPE_SPEC)
58911 HYBRID_BREAK();
58912 HYBRID_CASE(ZEND_ADD_ARRAY_UNPACK_SPEC):
58913 VM_TRACE(ZEND_ADD_ARRAY_UNPACK_SPEC)
58914 ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58915 VM_TRACE_OP_END(ZEND_ADD_ARRAY_UNPACK_SPEC)
58916 HYBRID_BREAK();
58917 HYBRID_CASE(ZEND_UNSET_STATIC_PROP_SPEC):
58918 VM_TRACE(ZEND_UNSET_STATIC_PROP_SPEC)
58919 ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58920 VM_TRACE_OP_END(ZEND_UNSET_STATIC_PROP_SPEC)
58921 HYBRID_BREAK();
58922 HYBRID_CASE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC):
58923 VM_TRACE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
58924 ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58925 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
58926 HYBRID_BREAK();
58927 HYBRID_CASE(ZEND_BEGIN_SILENCE_SPEC):
58928 VM_TRACE(ZEND_BEGIN_SILENCE_SPEC)
58929 ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58930 VM_TRACE_OP_END(ZEND_BEGIN_SILENCE_SPEC)
58931 HYBRID_BREAK();
58932 HYBRID_CASE(ZEND_EXT_STMT_SPEC):
58933 VM_TRACE(ZEND_EXT_STMT_SPEC)
58934 ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58935 VM_TRACE_OP_END(ZEND_EXT_STMT_SPEC)
58936 HYBRID_BREAK();
58937 HYBRID_CASE(ZEND_EXT_FCALL_BEGIN_SPEC):
58938 VM_TRACE(ZEND_EXT_FCALL_BEGIN_SPEC)
58939 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58940 VM_TRACE_OP_END(ZEND_EXT_FCALL_BEGIN_SPEC)
58941 HYBRID_BREAK();
58942 HYBRID_CASE(ZEND_EXT_FCALL_END_SPEC):
58943 VM_TRACE(ZEND_EXT_FCALL_END_SPEC)
58944 ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58945 VM_TRACE_OP_END(ZEND_EXT_FCALL_END_SPEC)
58946 HYBRID_BREAK();
58947 HYBRID_CASE(ZEND_DECLARE_ANON_CLASS_SPEC):
58948 VM_TRACE(ZEND_DECLARE_ANON_CLASS_SPEC)
58949 ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58950 VM_TRACE_OP_END(ZEND_DECLARE_ANON_CLASS_SPEC)
58951 HYBRID_BREAK();
58952 HYBRID_CASE(ZEND_DECLARE_FUNCTION_SPEC):
58953 VM_TRACE(ZEND_DECLARE_FUNCTION_SPEC)
58954 ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58955 VM_TRACE_OP_END(ZEND_DECLARE_FUNCTION_SPEC)
58956 HYBRID_BREAK();
58957 HYBRID_CASE(ZEND_TICKS_SPEC):
58958 VM_TRACE(ZEND_TICKS_SPEC)
58959 ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58960 VM_TRACE_OP_END(ZEND_TICKS_SPEC)
58961 HYBRID_BREAK();
58962 HYBRID_CASE(ZEND_EXT_NOP_SPEC):
58963 VM_TRACE(ZEND_EXT_NOP_SPEC)
58964 ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58965 VM_TRACE_OP_END(ZEND_EXT_NOP_SPEC)
58966 HYBRID_BREAK();
58967 HYBRID_CASE(ZEND_NOP_SPEC):
58968 VM_TRACE(ZEND_NOP_SPEC)
58969 ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58970 VM_TRACE_OP_END(ZEND_NOP_SPEC)
58971 HYBRID_BREAK();
58972 HYBRID_CASE(ZEND_HANDLE_EXCEPTION_SPEC):
58973 VM_TRACE(ZEND_HANDLE_EXCEPTION_SPEC)
58974 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58975 VM_TRACE_OP_END(ZEND_HANDLE_EXCEPTION_SPEC)
58976 HYBRID_BREAK();
58977 HYBRID_CASE(ZEND_USER_OPCODE_SPEC):
58978 VM_TRACE(ZEND_USER_OPCODE_SPEC)
58979 ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58980 VM_TRACE_OP_END(ZEND_USER_OPCODE_SPEC)
58981 HYBRID_BREAK();
58982 HYBRID_CASE(ZEND_DISCARD_EXCEPTION_SPEC):
58983 VM_TRACE(ZEND_DISCARD_EXCEPTION_SPEC)
58984 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58985 VM_TRACE_OP_END(ZEND_DISCARD_EXCEPTION_SPEC)
58986 HYBRID_BREAK();
58987 HYBRID_CASE(ZEND_FAST_CALL_SPEC):
58988 VM_TRACE(ZEND_FAST_CALL_SPEC)
58989 ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58990 VM_TRACE_OP_END(ZEND_FAST_CALL_SPEC)
58991 HYBRID_BREAK();
58992 HYBRID_CASE(ZEND_FAST_RET_SPEC):
58993 VM_TRACE(ZEND_FAST_RET_SPEC)
58994 ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58995 VM_TRACE_OP_END(ZEND_FAST_RET_SPEC)
58996 HYBRID_BREAK();
58997 HYBRID_CASE(ZEND_ASSERT_CHECK_SPEC):
58998 VM_TRACE(ZEND_ASSERT_CHECK_SPEC)
58999 ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59000 VM_TRACE_OP_END(ZEND_ASSERT_CHECK_SPEC)
59001 HYBRID_BREAK();
59002 HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC):
59003 VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC)
59004 ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59005 VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC)
59006 HYBRID_BREAK();
59007 HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER):
59008 VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
59009 ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59010 VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
59011 HYBRID_BREAK();
59012 HYBRID_CASE(ZEND_FRAMELESS_ICALL_2_SPEC):
59013 VM_TRACE(ZEND_FRAMELESS_ICALL_2_SPEC)
59014 ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59015 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_2_SPEC)
59016 HYBRID_BREAK();
59017 HYBRID_CASE(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER):
59018 VM_TRACE(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER)
59019 ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59020 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER)
59021 HYBRID_BREAK();
59022 HYBRID_CASE(ZEND_FRAMELESS_ICALL_3_SPEC):
59023 VM_TRACE(ZEND_FRAMELESS_ICALL_3_SPEC)
59024 ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59025 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_3_SPEC)
59026 HYBRID_BREAK();
59027 HYBRID_CASE(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER):
59028 VM_TRACE(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER)
59029 ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59030 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER)
59031 HYBRID_BREAK();
59032 HYBRID_CASE(ZEND_JMP_FORWARD_SPEC):
59033 VM_TRACE(ZEND_JMP_FORWARD_SPEC)
59034 ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59035 VM_TRACE_OP_END(ZEND_JMP_FORWARD_SPEC)
59036 HYBRID_BREAK();
59037 HYBRID_CASE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST):
59038 VM_TRACE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
59039 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59040 VM_TRACE_OP_END(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
59041 HYBRID_BREAK();
59042 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST):
59043 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
59044 ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59045 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
59046 HYBRID_BREAK();
59047 HYBRID_CASE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST):
59048 VM_TRACE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
59049 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59050 VM_TRACE_OP_END(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
59051 HYBRID_BREAK();
59052 HYBRID_CASE(ZEND_INIT_FCALL_SPEC_CONST):
59053 VM_TRACE(ZEND_INIT_FCALL_SPEC_CONST)
59054 ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59055 VM_TRACE_OP_END(ZEND_INIT_FCALL_SPEC_CONST)
59056 HYBRID_BREAK();
59057 HYBRID_CASE(ZEND_INIT_FCALL_OFFSET_SPEC_CONST):
59058 VM_TRACE(ZEND_INIT_FCALL_OFFSET_SPEC_CONST)
59059 ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59060 VM_TRACE_OP_END(ZEND_INIT_FCALL_OFFSET_SPEC_CONST)
59061 HYBRID_BREAK();
59062 HYBRID_CASE(ZEND_RECV_INIT_SPEC_CONST):
59063 VM_TRACE(ZEND_RECV_INIT_SPEC_CONST)
59064 ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59065 VM_TRACE_OP_END(ZEND_RECV_INIT_SPEC_CONST)
59066 HYBRID_BREAK();
59067 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR):
59068 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
59069 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59070 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
59071 HYBRID_BREAK();
59072 HYBRID_CASE(ZEND_RECV_SPEC_UNUSED):
59073 VM_TRACE(ZEND_RECV_SPEC_UNUSED)
59074 ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59075 VM_TRACE_OP_END(ZEND_RECV_SPEC_UNUSED)
59076 HYBRID_BREAK();
59077 HYBRID_CASE(ZEND_RECV_VARIADIC_SPEC_UNUSED):
59078 VM_TRACE(ZEND_RECV_VARIADIC_SPEC_UNUSED)
59079 ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59080 VM_TRACE_OP_END(ZEND_RECV_VARIADIC_SPEC_UNUSED)
59081 HYBRID_BREAK();
59082 HYBRID_CASE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED):
59083 VM_TRACE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
59084 ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59085 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
59086 HYBRID_BREAK();
59087 HYBRID_CASE(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER):
59088 VM_TRACE(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER)
59089 ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59090 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER)
59091 HYBRID_BREAK();
59092 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV):
59093 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
59094 ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59095 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
59096 HYBRID_BREAK();
59097 HYBRID_CASE(ZEND_BW_NOT_SPEC_CONST):
59098 VM_TRACE(ZEND_BW_NOT_SPEC_CONST)
59099 ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59100 VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_CONST)
59101 HYBRID_BREAK();
59102 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CONST):
59103 VM_TRACE(ZEND_BOOL_NOT_SPEC_CONST)
59104 ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59105 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CONST)
59106 HYBRID_BREAK();
59107 HYBRID_CASE(ZEND_ECHO_SPEC_CONST):
59108 VM_TRACE(ZEND_ECHO_SPEC_CONST)
59109 ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59110 VM_TRACE_OP_END(ZEND_ECHO_SPEC_CONST)
59111 HYBRID_BREAK();
59112 HYBRID_CASE(ZEND_JMPZ_SPEC_CONST):
59113 VM_TRACE(ZEND_JMPZ_SPEC_CONST)
59114 ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59115 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CONST)
59116 HYBRID_BREAK();
59117 HYBRID_CASE(ZEND_JMPNZ_SPEC_CONST):
59118 VM_TRACE(ZEND_JMPNZ_SPEC_CONST)
59119 ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59120 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CONST)
59121 HYBRID_BREAK();
59122 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CONST):
59123 VM_TRACE(ZEND_JMPZ_EX_SPEC_CONST)
59124 ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59125 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CONST)
59126 HYBRID_BREAK();
59127 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CONST):
59128 VM_TRACE(ZEND_JMPNZ_EX_SPEC_CONST)
59129 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59130 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CONST)
59131 HYBRID_BREAK();
59132 HYBRID_CASE(ZEND_RETURN_SPEC_CONST):
59133 VM_TRACE(ZEND_RETURN_SPEC_CONST)
59134{
59135 USE_OPLINE
59136 zval *retval_ptr;
59137 zval *return_value;
59138
59139 retval_ptr = RT_CONSTANT(opline, opline->op1);
59140 return_value = EX(return_value);
59141
59142 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
59143 SAVE_OPLINE();
59144 retval_ptr = ZVAL_UNDEFINED_OP1();
59145 if (return_value) {
59146 ZVAL_NULL(return_value);
59147 }
59148 } else if (!return_value) {
59149 if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
59150 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
59151 SAVE_OPLINE();
59152 rc_dtor_func(Z_COUNTED_P(retval_ptr));
59153 }
59154 }
59155 } else {
59156 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
59157 ZVAL_COPY_VALUE(return_value, retval_ptr);
59158 if (IS_CONST == IS_CONST) {
59159 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
59160 Z_ADDREF_P(return_value);
59161 }
59162 }
59163 } else if (IS_CONST == IS_CV) {
59164 do {
59165 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59166 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
59167 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
59168 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59169 ZVAL_COPY_VALUE(return_value, retval_ptr);
59170 if (GC_MAY_LEAK(ref)) {
59171 SAVE_OPLINE();
59172 gc_possible_root(ref);
59173 }
59174 ZVAL_NULL(retval_ptr);
59175 break;
59176 } else {
59177 Z_ADDREF_P(retval_ptr);
59178 }
59179 } else {
59180 retval_ptr = Z_REFVAL_P(retval_ptr);
59181 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59182 Z_ADDREF_P(retval_ptr);
59183 }
59184 }
59185 }
59186 ZVAL_COPY_VALUE(return_value, retval_ptr);
59187 } while (0);
59188 } else /* if (IS_CONST == IS_VAR) */ {
59189 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
59190 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59191
59192 retval_ptr = Z_REFVAL_P(retval_ptr);
59193 ZVAL_COPY_VALUE(return_value, retval_ptr);
59194 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
59195 efree_size(ref, sizeof(zend_reference));
59196 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59197 Z_ADDREF_P(retval_ptr);
59198 }
59199 } else {
59200 ZVAL_COPY_VALUE(return_value, retval_ptr);
59201 }
59202 }
59203 }
59204
59205
59206
59207 goto zend_leave_helper_SPEC_LABEL;
59208}
59209
59210 VM_TRACE_OP_END(ZEND_RETURN_SPEC_CONST)
59211 HYBRID_CASE(ZEND_RETURN_SPEC_OBSERVER):
59212 VM_TRACE(ZEND_RETURN_SPEC_OBSERVER)
59213{
59214 USE_OPLINE
59215 zval *retval_ptr;
59216 zval *return_value;
59217 zval observer_retval;
59218
59219 retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
59220 return_value = EX(return_value);
59221 if (!return_value) { return_value = &observer_retval; };
59222 if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
59223 SAVE_OPLINE();
59224 retval_ptr = ZVAL_UNDEFINED_OP1();
59225 if (return_value) {
59226 ZVAL_NULL(return_value);
59227 }
59228 } else if (!return_value) {
59229 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
59230 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
59231 SAVE_OPLINE();
59232 rc_dtor_func(Z_COUNTED_P(retval_ptr));
59233 }
59234 }
59235 } else {
59236 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
59237 ZVAL_COPY_VALUE(return_value, retval_ptr);
59238 if (opline->op1_type == IS_CONST) {
59239 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
59240 Z_ADDREF_P(return_value);
59241 }
59242 }
59243 } else if (opline->op1_type == IS_CV) {
59244 do {
59245 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59246 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
59247 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
59248 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59249 ZVAL_COPY_VALUE(return_value, retval_ptr);
59250 if (GC_MAY_LEAK(ref)) {
59251 SAVE_OPLINE();
59252 gc_possible_root(ref);
59253 }
59254 ZVAL_NULL(retval_ptr);
59255 break;
59256 } else {
59257 Z_ADDREF_P(retval_ptr);
59258 }
59259 } else {
59260 retval_ptr = Z_REFVAL_P(retval_ptr);
59261 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59262 Z_ADDREF_P(retval_ptr);
59263 }
59264 }
59265 }
59266 ZVAL_COPY_VALUE(return_value, retval_ptr);
59267 } while (0);
59268 } else /* if (opline->op1_type == IS_VAR) */ {
59269 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
59270 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59271
59272 retval_ptr = Z_REFVAL_P(retval_ptr);
59273 ZVAL_COPY_VALUE(return_value, retval_ptr);
59274 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
59275 efree_size(ref, sizeof(zend_reference));
59276 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59277 Z_ADDREF_P(retval_ptr);
59278 }
59279 } else {
59280 ZVAL_COPY_VALUE(return_value, retval_ptr);
59281 }
59282 }
59283 }
59284 SAVE_OPLINE();
59285 zend_observer_fcall_end(execute_data, return_value);
59286 if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
59287 goto zend_leave_helper_SPEC_LABEL;
59288}
59289
59290 VM_TRACE_OP_END(ZEND_RETURN_SPEC_OBSERVER)
59291 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CONST):
59292 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CONST)
59293 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59294 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CONST)
59295 HYBRID_BREAK();
59296 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_OBSERVER):
59297 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
59298 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59299 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
59300 HYBRID_BREAK();
59301 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CONST):
59302 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CONST)
59303 ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59304 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CONST)
59305 HYBRID_BREAK();
59306 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER):
59307 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
59308 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59309 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
59310 HYBRID_BREAK();
59311 HYBRID_CASE(ZEND_THROW_SPEC_CONST):
59312 VM_TRACE(ZEND_THROW_SPEC_CONST)
59313 ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59314 VM_TRACE_OP_END(ZEND_THROW_SPEC_CONST)
59315 HYBRID_BREAK();
59316 HYBRID_CASE(ZEND_CATCH_SPEC_CONST):
59317 VM_TRACE(ZEND_CATCH_SPEC_CONST)
59318 ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59319 VM_TRACE_OP_END(ZEND_CATCH_SPEC_CONST)
59320 HYBRID_BREAK();
59321 HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST):
59322 VM_TRACE(ZEND_SEND_USER_SPEC_CONST)
59323 ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59324 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST)
59325 HYBRID_BREAK();
59326 HYBRID_CASE(ZEND_BOOL_SPEC_CONST):
59327 VM_TRACE(ZEND_BOOL_SPEC_CONST)
59328 ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59329 VM_TRACE_OP_END(ZEND_BOOL_SPEC_CONST)
59330 HYBRID_BREAK();
59331 HYBRID_CASE(ZEND_CLONE_SPEC_CONST):
59332 VM_TRACE(ZEND_CLONE_SPEC_CONST)
59333 ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59334 VM_TRACE_OP_END(ZEND_CLONE_SPEC_CONST)
59335 HYBRID_BREAK();
59336 HYBRID_CASE(ZEND_CAST_SPEC_CONST):
59337 VM_TRACE(ZEND_CAST_SPEC_CONST)
59338 ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59339 VM_TRACE_OP_END(ZEND_CAST_SPEC_CONST)
59340 HYBRID_BREAK();
59341 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST):
59342 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
59343 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59344 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
59345 HYBRID_BREAK();
59346 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER):
59347 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
59348 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59349 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
59350 HYBRID_BREAK();
59351 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CONST):
59352 VM_TRACE(ZEND_FE_RESET_R_SPEC_CONST)
59353 ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59354 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CONST)
59355 HYBRID_BREAK();
59356 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CONST):
59357 VM_TRACE(ZEND_FE_RESET_RW_SPEC_CONST)
59358 ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59359 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CONST)
59360 HYBRID_BREAK();
59361 HYBRID_CASE(ZEND_JMP_SET_SPEC_CONST):
59362 VM_TRACE(ZEND_JMP_SET_SPEC_CONST)
59363 ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59364 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CONST)
59365 HYBRID_BREAK();
59366 HYBRID_CASE(ZEND_COALESCE_SPEC_CONST):
59367 VM_TRACE(ZEND_COALESCE_SPEC_CONST)
59368 ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59369 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CONST)
59370 HYBRID_BREAK();
59371 HYBRID_CASE(ZEND_JMP_NULL_SPEC_CONST):
59372 VM_TRACE(ZEND_JMP_NULL_SPEC_CONST)
59373 ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59374 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CONST)
59375 HYBRID_BREAK();
59376 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CONST):
59377 VM_TRACE(ZEND_QM_ASSIGN_SPEC_CONST)
59378 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59379 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CONST)
59380 HYBRID_BREAK();
59381 HYBRID_CASE(ZEND_DECLARE_CLASS_SPEC_CONST):
59382 VM_TRACE(ZEND_DECLARE_CLASS_SPEC_CONST)
59383 ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59384 VM_TRACE_OP_END(ZEND_DECLARE_CLASS_SPEC_CONST)
59385 HYBRID_BREAK();
59386 HYBRID_CASE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST):
59387 VM_TRACE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
59388 ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59389 VM_TRACE_OP_END(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
59390 HYBRID_BREAK();
59391 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CONST):
59392 VM_TRACE(ZEND_YIELD_FROM_SPEC_CONST)
59393 ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59394 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CONST)
59395 HYBRID_BREAK();
59396 HYBRID_CASE(ZEND_STRLEN_SPEC_CONST):
59397 VM_TRACE(ZEND_STRLEN_SPEC_CONST)
59398 ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59399 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CONST)
59400 HYBRID_BREAK();
59401 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CONST):
59402 VM_TRACE(ZEND_TYPE_CHECK_SPEC_CONST)
59403 ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59404 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CONST)
59405 HYBRID_BREAK();
59406 HYBRID_CASE(ZEND_DEFINED_SPEC_CONST):
59407 VM_TRACE(ZEND_DEFINED_SPEC_CONST)
59408 ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59409 VM_TRACE_OP_END(ZEND_DEFINED_SPEC_CONST)
59410 HYBRID_BREAK();
59411 HYBRID_CASE(ZEND_JMP_FRAMELESS_SPEC_CONST):
59412 VM_TRACE(ZEND_JMP_FRAMELESS_SPEC_CONST)
59413 ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59414 VM_TRACE_OP_END(ZEND_JMP_FRAMELESS_SPEC_CONST)
59415 HYBRID_BREAK();
59416 HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_CONST):
59417 VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
59418 ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59419 VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
59420 HYBRID_BREAK();
59421 HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST):
59422 VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
59423 ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59424 VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
59425 HYBRID_BREAK();
59426 HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST):
59427 VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
59428 ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59429 VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
59430 HYBRID_BREAK();
59431 HYBRID_CASE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST):
59432 VM_TRACE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
59433 ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59434 VM_TRACE_OP_END(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
59435 HYBRID_BREAK();
59436 HYBRID_CASE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST):
59437 VM_TRACE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
59438 ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59439 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
59440 HYBRID_BREAK();
59441 HYBRID_CASE(ZEND_ADD_SPEC_CONST_CONST):
59442 VM_TRACE(ZEND_ADD_SPEC_CONST_CONST)
59443 ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59444 VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_CONST)
59445 HYBRID_BREAK();
59446 HYBRID_CASE(ZEND_SUB_SPEC_CONST_CONST):
59447 VM_TRACE(ZEND_SUB_SPEC_CONST_CONST)
59448 ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59449 VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_CONST)
59450 HYBRID_BREAK();
59451 HYBRID_CASE(ZEND_MUL_SPEC_CONST_CONST):
59452 VM_TRACE(ZEND_MUL_SPEC_CONST_CONST)
59453 ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59454 VM_TRACE_OP_END(ZEND_MUL_SPEC_CONST_CONST)
59455 HYBRID_BREAK();
59456 HYBRID_CASE(ZEND_DIV_SPEC_CONST_CONST):
59457 VM_TRACE(ZEND_DIV_SPEC_CONST_CONST)
59458 ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59459 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CONST)
59460 HYBRID_BREAK();
59461 HYBRID_CASE(ZEND_MOD_SPEC_CONST_CONST):
59462 VM_TRACE(ZEND_MOD_SPEC_CONST_CONST)
59463 ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59464 VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_CONST)
59465 HYBRID_BREAK();
59466 HYBRID_CASE(ZEND_SL_SPEC_CONST_CONST):
59467 VM_TRACE(ZEND_SL_SPEC_CONST_CONST)
59468 ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59469 VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_CONST)
59470 HYBRID_BREAK();
59471 HYBRID_CASE(ZEND_SR_SPEC_CONST_CONST):
59472 VM_TRACE(ZEND_SR_SPEC_CONST_CONST)
59473 ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59474 VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_CONST)
59475 HYBRID_BREAK();
59476 HYBRID_CASE(ZEND_POW_SPEC_CONST_CONST):
59477 VM_TRACE(ZEND_POW_SPEC_CONST_CONST)
59478 ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59479 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CONST)
59480 HYBRID_BREAK();
59481 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST):
59482 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
59483 ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59484 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
59485 HYBRID_BREAK();
59486 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST):
59487 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
59488 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59489 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
59490 HYBRID_BREAK();
59491 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CONST_CONST):
59492 VM_TRACE(ZEND_IS_EQUAL_SPEC_CONST_CONST)
59493 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59494 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CONST_CONST)
59495 HYBRID_BREAK();
59496 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST):
59497 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
59498 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59499 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
59500 HYBRID_BREAK();
59501 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_CONST):
59502 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_CONST)
59503 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59504 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_CONST)
59505 HYBRID_BREAK();
59506 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST):
59507 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
59508 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59509 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
59510 HYBRID_BREAK();
59511 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CONST):
59512 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CONST)
59513 ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59514 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CONST)
59515 HYBRID_BREAK();
59516 HYBRID_CASE(ZEND_BW_OR_SPEC_CONST_CONST):
59517 VM_TRACE(ZEND_BW_OR_SPEC_CONST_CONST)
59518 ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59519 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_CONST_CONST)
59520 HYBRID_BREAK();
59521 HYBRID_CASE(ZEND_BW_AND_SPEC_CONST_CONST):
59522 VM_TRACE(ZEND_BW_AND_SPEC_CONST_CONST)
59523 ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59524 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_CONST_CONST)
59525 HYBRID_BREAK();
59526 HYBRID_CASE(ZEND_BW_XOR_SPEC_CONST_CONST):
59527 VM_TRACE(ZEND_BW_XOR_SPEC_CONST_CONST)
59528 ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59529 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_CONST_CONST)
59530 HYBRID_BREAK();
59531 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CONST_CONST):
59532 VM_TRACE(ZEND_BOOL_XOR_SPEC_CONST_CONST)
59533 ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59534 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CONST_CONST)
59535 HYBRID_BREAK();
59536 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST):
59537 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
59538 ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59539 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
59540 HYBRID_BREAK();
59541 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST):
59542 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
59543 ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59544 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
59545 HYBRID_BREAK();
59546 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST):
59547 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
59548 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59549 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
59550 HYBRID_BREAK();
59551 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST):
59552 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
59553 ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59554 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
59555 HYBRID_BREAK();
59556 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST):
59557 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
59558 ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59559 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
59560 HYBRID_BREAK();
59561 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST):
59562 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
59563 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59564 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
59565 HYBRID_BREAK();
59566 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST):
59567 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
59568 ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59569 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
59570 HYBRID_BREAK();
59571 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CONST):
59572 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
59573 ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59574 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
59575 HYBRID_BREAK();
59576 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST):
59577 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
59578 ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59579 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
59580 HYBRID_BREAK();
59581 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST):
59582 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
59583 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59584 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
59585 HYBRID_BREAK();
59586 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST):
59587 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
59588 ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59589 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
59590 HYBRID_BREAK();
59591 HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_CONST):
59592 VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_CONST)
59593 ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59594 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_CONST)
59595 HYBRID_BREAK();
59596 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST):
59597 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
59598 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59599 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
59600 HYBRID_BREAK();
59601 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST):
59602 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
59603 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59604 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
59605 HYBRID_BREAK();
59606 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST):
59607 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
59608 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59609 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
59610 HYBRID_BREAK();
59611 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CONST):
59612 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
59613 ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59614 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
59615 HYBRID_BREAK();
59616 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST):
59617 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
59618 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59619 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
59620 HYBRID_BREAK();
59621 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST):
59622 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
59623 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59624 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
59625 HYBRID_BREAK();
59626 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST):
59627 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
59628 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59629 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
59630 HYBRID_BREAK();
59631 HYBRID_CASE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST):
59632 VM_TRACE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
59633 ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59634 VM_TRACE_OP_END(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
59635 HYBRID_BREAK();
59636 HYBRID_CASE(ZEND_DECLARE_CONST_SPEC_CONST_CONST):
59637 VM_TRACE(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
59638 ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59639 VM_TRACE_OP_END(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
59640 HYBRID_BREAK();
59641 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CONST):
59642 VM_TRACE(ZEND_YIELD_SPEC_CONST_CONST)
59643 ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59644 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CONST)
59645 HYBRID_BREAK();
59646 HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_CONST_CONST):
59647 VM_TRACE(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
59648 ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59649 VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
59650 HYBRID_BREAK();
59651 HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_CONST_CONST):
59652 VM_TRACE(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
59653 ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59654 VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
59655 HYBRID_BREAK();
59656 HYBRID_CASE(ZEND_MATCH_SPEC_CONST_CONST):
59657 VM_TRACE(ZEND_MATCH_SPEC_CONST_CONST)
59658 ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59659 VM_TRACE_OP_END(ZEND_MATCH_SPEC_CONST_CONST)
59660 HYBRID_BREAK();
59661 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CONST_CONST):
59662 VM_TRACE(ZEND_IN_ARRAY_SPEC_CONST_CONST)
59663 ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59664 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CONST_CONST)
59665 HYBRID_BREAK();
59666 HYBRID_CASE(ZEND_ADD_SPEC_CONST_TMPVARCV):
59667 VM_TRACE(ZEND_ADD_SPEC_CONST_TMPVARCV)
59668 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59669 VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_TMPVARCV)
59670 HYBRID_BREAK();
59671 HYBRID_CASE(ZEND_SUB_SPEC_CONST_TMPVARCV):
59672 VM_TRACE(ZEND_SUB_SPEC_CONST_TMPVARCV)
59673 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59674 VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_TMPVARCV)
59675 HYBRID_BREAK();
59676 HYBRID_CASE(ZEND_MOD_SPEC_CONST_TMPVARCV):
59677 VM_TRACE(ZEND_MOD_SPEC_CONST_TMPVARCV)
59678 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59679 VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_TMPVARCV)
59680 HYBRID_BREAK();
59681 HYBRID_CASE(ZEND_SL_SPEC_CONST_TMPVARCV):
59682 VM_TRACE(ZEND_SL_SPEC_CONST_TMPVARCV)
59683 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59684 VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_TMPVARCV)
59685 HYBRID_BREAK();
59686 HYBRID_CASE(ZEND_SR_SPEC_CONST_TMPVARCV):
59687 VM_TRACE(ZEND_SR_SPEC_CONST_TMPVARCV)
59688 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59689 VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_TMPVARCV)
59690 HYBRID_BREAK();
59691 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV):
59692 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
59693 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59694 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
59695 HYBRID_BREAK();
59696 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ):
59697 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
59698 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59699 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
59700 HYBRID_BREAK();
59701 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ):
59702 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
59703 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59704 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
59705 HYBRID_BREAK();
59706 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV):
59707 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
59708 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59709 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
59710 HYBRID_BREAK();
59711 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ):
59712 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
59713 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59714 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
59715 HYBRID_BREAK();
59716 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ):
59717 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
59718 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59719 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
59720 HYBRID_BREAK();
59721 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV):
59722 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
59723 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59724 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
59725 HYBRID_BREAK();
59726 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV):
59727 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
59728 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59729 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
59730 HYBRID_BREAK();
59731 HYBRID_CASE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV):
59732 VM_TRACE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
59733 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59734 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
59735 HYBRID_BREAK();
59736 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV):
59737 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
59738 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59739 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
59740 HYBRID_BREAK();
59741 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV):
59742 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
59743 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59744 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
59745 HYBRID_BREAK();
59746 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ):
59747 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59748 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59749 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59750 HYBRID_BREAK();
59751 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
59752 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59753 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59754 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59755 HYBRID_BREAK();
59756 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV):
59757 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
59758 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59759 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
59760 HYBRID_BREAK();
59761 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
59762 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59763 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59764 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59765 HYBRID_BREAK();
59766 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
59767 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59768 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59769 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59770 HYBRID_BREAK();
59771 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV):
59772 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
59773 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59774 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
59775 HYBRID_BREAK();
59776 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ):
59777 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59778 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59779 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59780 HYBRID_BREAK();
59781 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
59782 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59783 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59784 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59785 HYBRID_BREAK();
59786 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV):
59787 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
59788 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59789 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
59790 HYBRID_BREAK();
59791 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
59792 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59793 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59794 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59795 HYBRID_BREAK();
59796 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
59797 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59798 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59799 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59800 HYBRID_BREAK();
59801 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV):
59802 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
59803 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59804 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
59805 HYBRID_BREAK();
59806 HYBRID_CASE(ZEND_DIV_SPEC_CONST_TMPVAR):
59807 VM_TRACE(ZEND_DIV_SPEC_CONST_TMPVAR)
59808 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59809 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_TMPVAR)
59810 HYBRID_BREAK();
59811 HYBRID_CASE(ZEND_POW_SPEC_CONST_TMPVAR):
59812 VM_TRACE(ZEND_POW_SPEC_CONST_TMPVAR)
59813 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59814 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_TMPVAR)
59815 HYBRID_BREAK();
59816 HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_TMPVAR):
59817 VM_TRACE(ZEND_CONCAT_SPEC_CONST_TMPVAR)
59818 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59819 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_TMPVAR)
59820 HYBRID_BREAK();
59821 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR):
59822 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
59823 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59824 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
59825 HYBRID_BREAK();
59826 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR):
59827 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
59828 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59829 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
59830 HYBRID_BREAK();
59831 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR):
59832 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
59833 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59834 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
59835 HYBRID_BREAK();
59836 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR):
59837 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
59838 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59839 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
59840 HYBRID_BREAK();
59841 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR):
59842 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
59843 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59844 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
59845 HYBRID_BREAK();
59846 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR):
59847 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
59848 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59849 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
59850 HYBRID_BREAK();
59851 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR):
59852 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
59853 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59854 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
59855 HYBRID_BREAK();
59856 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR):
59857 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
59858 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59859 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
59860 HYBRID_BREAK();
59861 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR):
59862 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
59863 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59864 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
59865 HYBRID_BREAK();
59866 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR):
59867 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
59868 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59869 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
59870 HYBRID_BREAK();
59871 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR):
59872 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
59873 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59874 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
59875 HYBRID_BREAK();
59876 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR):
59877 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
59878 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59879 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
59880 HYBRID_BREAK();
59881 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR):
59882 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
59883 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59884 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
59885 HYBRID_BREAK();
59886 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR):
59887 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
59888 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59889 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
59890 HYBRID_BREAK();
59891 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR):
59892 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
59893 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59894 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
59895 HYBRID_BREAK();
59896 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR):
59897 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
59898 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59899 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
59900 HYBRID_BREAK();
59901 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR):
59902 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
59903 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59904 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
59905 HYBRID_BREAK();
59906 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_TMPVAR):
59907 VM_TRACE(ZEND_YIELD_SPEC_CONST_TMPVAR)
59908 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59909 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_TMPVAR)
59910 HYBRID_BREAK();
59911 HYBRID_CASE(ZEND_FETCH_R_SPEC_CONST_UNUSED):
59912 VM_TRACE(ZEND_FETCH_R_SPEC_CONST_UNUSED)
59913 ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59914 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CONST_UNUSED)
59915 HYBRID_BREAK();
59916 HYBRID_CASE(ZEND_FETCH_W_SPEC_CONST_UNUSED):
59917 VM_TRACE(ZEND_FETCH_W_SPEC_CONST_UNUSED)
59918 ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59919 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CONST_UNUSED)
59920 HYBRID_BREAK();
59921 HYBRID_CASE(ZEND_FETCH_RW_SPEC_CONST_UNUSED):
59922 VM_TRACE(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
59923 ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59924 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
59925 HYBRID_BREAK();
59926 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED):
59927 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
59928 ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59929 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
59930 HYBRID_BREAK();
59931 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED):
59932 VM_TRACE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
59933 ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59934 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
59935 HYBRID_BREAK();
59936 HYBRID_CASE(ZEND_FETCH_IS_SPEC_CONST_UNUSED):
59937 VM_TRACE(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
59938 ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59939 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
59940 HYBRID_BREAK();
59941 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED):
59942 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
59943 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59944 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
59945 HYBRID_BREAK();
59946 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED):
59947 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
59948 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59949 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
59950 HYBRID_BREAK();
59951 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED):
59952 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
59953 ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59954 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
59955 HYBRID_BREAK();
59956 HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_UNUSED):
59957 VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
59958 ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59959 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
59960 HYBRID_BREAK();
59961 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED):
59962 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
59963 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59964 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
59965 HYBRID_BREAK();
59966 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK):
59967 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
59968 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59969 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
59970 HYBRID_BREAK();
59971 HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED):
59972 VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED)
59973 ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59974 VM_TRACE_OP_END(ZEND_NEW_SPEC_CONST_UNUSED)
59975 HYBRID_BREAK();
59976 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED):
59977 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
59978 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59979 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
59980 HYBRID_BREAK();
59981 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED):
59982 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
59983 ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59984 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
59985 HYBRID_BREAK();
59986 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED):
59987 VM_TRACE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
59988 ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59989 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
59990 HYBRID_BREAK();
59991 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED):
59992 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
59993 ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59994 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
59995 HYBRID_BREAK();
59996 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_UNUSED):
59997 VM_TRACE(ZEND_YIELD_SPEC_CONST_UNUSED)
59998 ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59999 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_UNUSED)
60000 HYBRID_BREAK();
60001 HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED):
60002 VM_TRACE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
60003 ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60004 VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
60005 HYBRID_BREAK();
60006 HYBRID_CASE(ZEND_COUNT_SPEC_CONST_UNUSED):
60007 VM_TRACE(ZEND_COUNT_SPEC_CONST_UNUSED)
60008 ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60009 VM_TRACE_OP_END(ZEND_COUNT_SPEC_CONST_UNUSED)
60010 HYBRID_BREAK();
60011 HYBRID_CASE(ZEND_GET_CLASS_SPEC_CONST_UNUSED):
60012 VM_TRACE(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
60013 ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60014 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
60015 HYBRID_BREAK();
60016 HYBRID_CASE(ZEND_GET_TYPE_SPEC_CONST_UNUSED):
60017 VM_TRACE(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
60018 ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60019 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
60020 HYBRID_BREAK();
60021 HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED):
60022 VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
60023 ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60024 VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
60025 HYBRID_BREAK();
60026 HYBRID_CASE(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED):
60027 VM_TRACE(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED)
60028 ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60029 VM_TRACE_OP_END(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED)
60030 HYBRID_BREAK();
60031 HYBRID_CASE(ZEND_DIV_SPEC_CONST_CV):
60032 VM_TRACE(ZEND_DIV_SPEC_CONST_CV)
60033 ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60034 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CV)
60035 HYBRID_BREAK();
60036 HYBRID_CASE(ZEND_POW_SPEC_CONST_CV):
60037 VM_TRACE(ZEND_POW_SPEC_CONST_CV)
60038 ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60039 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CV)
60040 HYBRID_BREAK();
60041 HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_CV):
60042 VM_TRACE(ZEND_CONCAT_SPEC_CONST_CV)
60043 ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60044 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_CV)
60045 HYBRID_BREAK();
60046 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CV):
60047 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CV)
60048 ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60049 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CV)
60050 HYBRID_BREAK();
60051 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CV):
60052 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
60053 ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60054 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
60055 HYBRID_BREAK();
60056 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV):
60057 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
60058 ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60059 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
60060 HYBRID_BREAK();
60061 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV):
60062 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
60063 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60064 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
60065 HYBRID_BREAK();
60066 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV):
60067 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
60068 ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60069 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
60070 HYBRID_BREAK();
60071 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV):
60072 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
60073 ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60074 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
60075 HYBRID_BREAK();
60076 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV):
60077 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
60078 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60079 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
60080 HYBRID_BREAK();
60081 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CV):
60082 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
60083 ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60084 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
60085 HYBRID_BREAK();
60086 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CV):
60087 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CV)
60088 ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60089 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CV)
60090 HYBRID_BREAK();
60091 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV):
60092 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
60093 ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60094 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
60095 HYBRID_BREAK();
60096 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV):
60097 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
60098 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60099 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
60100 HYBRID_BREAK();
60101 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CV):
60102 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
60103 ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60104 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
60105 HYBRID_BREAK();
60106 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV):
60107 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
60108 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60109 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
60110 HYBRID_BREAK();
60111 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CV):
60112 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CV)
60113 ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60114 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CV)
60115 HYBRID_BREAK();
60116 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV):
60117 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
60118 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60119 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
60120 HYBRID_BREAK();
60121 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV):
60122 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
60123 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60124 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
60125 HYBRID_BREAK();
60126 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV):
60127 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
60128 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60129 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
60130 HYBRID_BREAK();
60131 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CV):
60132 VM_TRACE(ZEND_YIELD_SPEC_CONST_CV)
60133 ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60134 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CV)
60135 HYBRID_BREAK();
60136 HYBRID_CASE(ZEND_BW_NOT_SPEC_TMPVARCV):
60137 VM_TRACE(ZEND_BW_NOT_SPEC_TMPVARCV)
60138 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60139 VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_TMPVARCV)
60140 HYBRID_BREAK();
60141 HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV):
60142 VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
60143 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60144 VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
60145 HYBRID_BREAK();
60146 HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV):
60147 VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
60148 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60149 VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
60150 HYBRID_BREAK();
60151 HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV):
60152 VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
60153 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60154 VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
60155 HYBRID_BREAK();
60156 HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_CONST):
60157 VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_CONST)
60158 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60159 VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_CONST)
60160 HYBRID_BREAK();
60161 HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_CONST):
60162 VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_CONST)
60163 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60164 VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_CONST)
60165 HYBRID_BREAK();
60166 HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_CONST):
60167 VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_CONST)
60168 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60169 VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_CONST)
60170 HYBRID_BREAK();
60171 HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_CONST):
60172 VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_CONST)
60173 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60174 VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_CONST)
60175 HYBRID_BREAK();
60176 HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_CONST):
60177 VM_TRACE(ZEND_SL_SPEC_TMPVARCV_CONST)
60178 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60179 VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_CONST)
60180 HYBRID_BREAK();
60181 HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_CONST):
60182 VM_TRACE(ZEND_SR_SPEC_TMPVARCV_CONST)
60183 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60184 VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_CONST)
60185 HYBRID_BREAK();
60186 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST):
60187 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
60188 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60189 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
60190 HYBRID_BREAK();
60191 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ):
60192 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
60193 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60194 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
60195 HYBRID_BREAK();
60196 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ):
60197 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
60198 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60199 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
60200 HYBRID_BREAK();
60201 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST):
60202 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
60203 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60204 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
60205 HYBRID_BREAK();
60206 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ):
60207 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
60208 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60209 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
60210 HYBRID_BREAK();
60211 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ):
60212 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
60213 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60214 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
60215 HYBRID_BREAK();
60216 HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_CONST):
60217 VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
60218 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60219 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
60220 HYBRID_BREAK();
60221 HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_CONST):
60222 VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
60223 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60224 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
60225 HYBRID_BREAK();
60226 HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST):
60227 VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
60228 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60229 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
60230 HYBRID_BREAK();
60231 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST):
60232 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
60233 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60234 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
60235 HYBRID_BREAK();
60236 HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST):
60237 VM_TRACE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
60238 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60239 VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
60240 HYBRID_BREAK();
60241 HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST):
60242 VM_TRACE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
60243 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60244 VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
60245 HYBRID_BREAK();
60246 HYBRID_CASE(ZEND_MATCH_SPEC_TMPVARCV_CONST):
60247 VM_TRACE(ZEND_MATCH_SPEC_TMPVARCV_CONST)
60248 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60249 VM_TRACE_OP_END(ZEND_MATCH_SPEC_TMPVARCV_CONST)
60250 HYBRID_BREAK();
60251 HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60252 VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60253 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60254 VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60255 HYBRID_BREAK();
60256 HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST):
60257 VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
60258 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60259 VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
60260 HYBRID_BREAK();
60261 HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST):
60262 VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
60263 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60264 VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
60265 HYBRID_BREAK();
60266 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60267 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60268 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60269 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60270 HYBRID_BREAK();
60271 HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST):
60272 VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
60273 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60274 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
60275 HYBRID_BREAK();
60276 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST):
60277 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
60278 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60279 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
60280 HYBRID_BREAK();
60281 HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60282 VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60283 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60284 VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60285 HYBRID_BREAK();
60286 HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST):
60287 VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
60288 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60289 VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
60290 HYBRID_BREAK();
60291 HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST):
60292 VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
60293 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60294 VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
60295 HYBRID_BREAK();
60296 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60297 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60298 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60299 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60300 HYBRID_BREAK();
60301 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60302 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60303 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60304 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60305 HYBRID_BREAK();
60306 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60307 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60308 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60309 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60310 HYBRID_BREAK();
60311 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60312 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60313 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60314 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60315 HYBRID_BREAK();
60316 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60317 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60318 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60319 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60320 HYBRID_BREAK();
60321 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60322 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60323 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60324 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60325 HYBRID_BREAK();
60326 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60327 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60328 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60329 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60330 HYBRID_BREAK();
60331 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60332 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60333 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60334 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60335 HYBRID_BREAK();
60336 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60337 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60338 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60339 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60340 HYBRID_BREAK();
60341 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60342 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60343 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60344 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60345 HYBRID_BREAK();
60346 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60347 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60348 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60349 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60350 HYBRID_BREAK();
60351 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60352 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60353 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60354 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60355 HYBRID_BREAK();
60356 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST):
60357 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
60358 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60359 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
60360 HYBRID_BREAK();
60361 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60362 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60363 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60364 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60365 HYBRID_BREAK();
60366 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60367 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60368 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60369 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60370 HYBRID_BREAK();
60371 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST):
60372 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
60373 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60374 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
60375 HYBRID_BREAK();
60376 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60377 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60378 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60379 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60380 HYBRID_BREAK();
60381 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60382 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60383 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60384 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60385 HYBRID_BREAK();
60386 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60387 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60388 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60389 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60390 HYBRID_BREAK();
60391 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60392 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60393 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60394 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60395 HYBRID_BREAK();
60396 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60397 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60398 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60399 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60400 HYBRID_BREAK();
60401 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60402 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60403 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60404 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60405 HYBRID_BREAK();
60406 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60407 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60408 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60409 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60410 HYBRID_BREAK();
60411 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60412 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60413 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60414 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60415 HYBRID_BREAK();
60416 HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV):
60417 VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
60418 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60419 VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
60420 HYBRID_BREAK();
60421 HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV):
60422 VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
60423 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60424 VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
60425 HYBRID_BREAK();
60426 HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV):
60427 VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
60428 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60429 VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
60430 HYBRID_BREAK();
60431 HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV):
60432 VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
60433 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60434 VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
60435 HYBRID_BREAK();
60436 HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV):
60437 VM_TRACE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
60438 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60439 VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
60440 HYBRID_BREAK();
60441 HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV):
60442 VM_TRACE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
60443 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60444 VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
60445 HYBRID_BREAK();
60446 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV):
60447 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
60448 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60449 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
60450 HYBRID_BREAK();
60451 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60452 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60453 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60454 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60455 HYBRID_BREAK();
60456 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60457 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60458 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60459 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60460 HYBRID_BREAK();
60461 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV):
60462 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
60463 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60464 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
60465 HYBRID_BREAK();
60466 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60467 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60468 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60469 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60470 HYBRID_BREAK();
60471 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60472 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60473 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60474 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60475 HYBRID_BREAK();
60476 HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV):
60477 VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
60478 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60479 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
60480 HYBRID_BREAK();
60481 HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV):
60482 VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
60483 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60484 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
60485 HYBRID_BREAK();
60486 HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV):
60487 VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
60488 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60489 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
60490 HYBRID_BREAK();
60491 HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60492 VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60493 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60494 VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60495 HYBRID_BREAK();
60496 HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV):
60497 VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
60498 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60499 VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
60500 HYBRID_BREAK();
60501 HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60502 VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60503 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60504 VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60505 HYBRID_BREAK();
60506 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60507 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60508 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60509 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60510 HYBRID_BREAK();
60511 HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV):
60512 VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
60513 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60514 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
60515 HYBRID_BREAK();
60516 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60517 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60518 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60519 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60520 HYBRID_BREAK();
60521 HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60522 VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60523 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60524 VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60525 HYBRID_BREAK();
60526 HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV):
60527 VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
60528 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60529 VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
60530 HYBRID_BREAK();
60531 HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60532 VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60533 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60534 VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60535 HYBRID_BREAK();
60536 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60537 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60538 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60539 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60540 HYBRID_BREAK();
60541 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60542 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60543 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60544 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60545 HYBRID_BREAK();
60546 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60547 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60548 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60549 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60550 HYBRID_BREAK();
60551 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60552 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60553 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60554 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60555 HYBRID_BREAK();
60556 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60557 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60558 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60559 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60560 HYBRID_BREAK();
60561 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60562 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60563 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60564 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60565 HYBRID_BREAK();
60566 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60567 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60568 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60569 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60570 HYBRID_BREAK();
60571 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60572 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60573 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60574 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60575 HYBRID_BREAK();
60576 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60577 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60578 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60579 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60580 HYBRID_BREAK();
60581 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60582 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60583 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60584 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60585 HYBRID_BREAK();
60586 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60587 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60588 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60589 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60590 HYBRID_BREAK();
60591 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60592 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60593 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60594 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60595 HYBRID_BREAK();
60596 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV):
60597 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
60598 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60599 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
60600 HYBRID_BREAK();
60601 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60602 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60603 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60604 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60605 HYBRID_BREAK();
60606 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60607 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60608 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60609 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60610 HYBRID_BREAK();
60611 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60612 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60613 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60614 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60615 HYBRID_BREAK();
60616 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60617 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60618 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60619 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60620 HYBRID_BREAK();
60621 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60622 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60623 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60624 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60625 HYBRID_BREAK();
60626 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60627 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60628 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60629 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60630 HYBRID_BREAK();
60631 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60632 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60633 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60634 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60635 HYBRID_BREAK();
60636 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60637 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60638 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60639 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60640 HYBRID_BREAK();
60641 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60642 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60643 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60644 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60645 HYBRID_BREAK();
60646 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60647 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60648 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60649 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60650 HYBRID_BREAK();
60651 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60652 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60653 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60654 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60655 HYBRID_BREAK();
60656 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR):
60657 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
60658 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60659 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
60660 HYBRID_BREAK();
60661 HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED):
60662 VM_TRACE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
60663 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60664 VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
60665 HYBRID_BREAK();
60666 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV):
60667 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
60668 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60669 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
60670 HYBRID_BREAK();
60671 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_TMPVAR):
60672 VM_TRACE(ZEND_BOOL_NOT_SPEC_TMPVAR)
60673 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60674 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_TMPVAR)
60675 HYBRID_BREAK();
60676 HYBRID_CASE(ZEND_ECHO_SPEC_TMPVAR):
60677 VM_TRACE(ZEND_ECHO_SPEC_TMPVAR)
60678 ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60679 VM_TRACE_OP_END(ZEND_ECHO_SPEC_TMPVAR)
60680 HYBRID_BREAK();
60681 HYBRID_CASE(ZEND_JMPZ_SPEC_TMPVAR):
60682 VM_TRACE(ZEND_JMPZ_SPEC_TMPVAR)
60683 ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60684 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_TMPVAR)
60685 HYBRID_BREAK();
60686 HYBRID_CASE(ZEND_JMPNZ_SPEC_TMPVAR):
60687 VM_TRACE(ZEND_JMPNZ_SPEC_TMPVAR)
60688 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60689 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_TMPVAR)
60690 HYBRID_BREAK();
60691 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_TMPVAR):
60692 VM_TRACE(ZEND_JMPZ_EX_SPEC_TMPVAR)
60693 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60694 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_TMPVAR)
60695 HYBRID_BREAK();
60696 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_TMPVAR):
60697 VM_TRACE(ZEND_JMPNZ_EX_SPEC_TMPVAR)
60698 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60699 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_TMPVAR)
60700 HYBRID_BREAK();
60701 HYBRID_CASE(ZEND_FREE_SPEC_TMPVAR):
60702 VM_TRACE(ZEND_FREE_SPEC_TMPVAR)
60703 ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60704 VM_TRACE_OP_END(ZEND_FREE_SPEC_TMPVAR)
60705 HYBRID_BREAK();
60706 HYBRID_CASE(ZEND_FE_FREE_SPEC_TMPVAR):
60707 VM_TRACE(ZEND_FE_FREE_SPEC_TMPVAR)
60708 ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60709 VM_TRACE_OP_END(ZEND_FE_FREE_SPEC_TMPVAR)
60710 HYBRID_BREAK();
60711 HYBRID_CASE(ZEND_THROW_SPEC_TMPVAR):
60712 VM_TRACE(ZEND_THROW_SPEC_TMPVAR)
60713 ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60714 VM_TRACE_OP_END(ZEND_THROW_SPEC_TMPVAR)
60715 HYBRID_BREAK();
60716 HYBRID_CASE(ZEND_BOOL_SPEC_TMPVAR):
60717 VM_TRACE(ZEND_BOOL_SPEC_TMPVAR)
60718 ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60719 VM_TRACE_OP_END(ZEND_BOOL_SPEC_TMPVAR)
60720 HYBRID_BREAK();
60721 HYBRID_CASE(ZEND_CLONE_SPEC_TMPVAR):
60722 VM_TRACE(ZEND_CLONE_SPEC_TMPVAR)
60723 ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60724 VM_TRACE_OP_END(ZEND_CLONE_SPEC_TMPVAR)
60725 HYBRID_BREAK();
60726 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR):
60727 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
60728 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60729 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
60730 HYBRID_BREAK();
60731 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_TMPVAR):
60732 VM_TRACE(ZEND_YIELD_FROM_SPEC_TMPVAR)
60733 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60734 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_TMPVAR)
60735 HYBRID_BREAK();
60736 HYBRID_CASE(ZEND_STRLEN_SPEC_TMPVAR):
60737 VM_TRACE(ZEND_STRLEN_SPEC_TMPVAR)
60738 ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60739 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_TMPVAR)
60740 HYBRID_BREAK();
60741 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_TMPVAR):
60742 VM_TRACE(ZEND_TYPE_CHECK_SPEC_TMPVAR)
60743 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60744 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_TMPVAR)
60745 HYBRID_BREAK();
60746 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR):
60747 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
60748 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60749 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
60750 HYBRID_BREAK();
60751 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CONST):
60752 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CONST)
60753 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60754 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CONST)
60755 HYBRID_BREAK();
60756 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CONST):
60757 VM_TRACE(ZEND_POW_SPEC_TMPVAR_CONST)
60758 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60759 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CONST)
60760 HYBRID_BREAK();
60761 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CONST):
60762 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CONST)
60763 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60764 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CONST)
60765 HYBRID_BREAK();
60766 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST):
60767 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
60768 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60769 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
60770 HYBRID_BREAK();
60771 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
60772 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60773 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60774 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60775 HYBRID_BREAK();
60776 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
60777 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60778 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60779 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60780 HYBRID_BREAK();
60781 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST):
60782 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
60783 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60784 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
60785 HYBRID_BREAK();
60786 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
60787 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60788 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60789 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60790 HYBRID_BREAK();
60791 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
60792 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60793 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60794 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60795 HYBRID_BREAK();
60796 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST):
60797 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
60798 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60799 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
60800 HYBRID_BREAK();
60801 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST):
60802 VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
60803 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60804 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
60805 HYBRID_BREAK();
60806 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST):
60807 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
60808 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60809 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
60810 HYBRID_BREAK();
60811 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST):
60812 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
60813 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60814 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
60815 HYBRID_BREAK();
60816 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST):
60817 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
60818 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60819 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
60820 HYBRID_BREAK();
60821 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST):
60822 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
60823 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60824 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
60825 HYBRID_BREAK();
60826 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST):
60827 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
60828 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60829 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
60830 HYBRID_BREAK();
60831 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST):
60832 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
60833 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60834 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
60835 HYBRID_BREAK();
60836 HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST):
60837 VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
60838 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60839 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
60840 HYBRID_BREAK();
60841 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CONST):
60842 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CONST)
60843 ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60844 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CONST)
60845 HYBRID_BREAK();
60846 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST):
60847 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
60848 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60849 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
60850 HYBRID_BREAK();
60851 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST):
60852 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
60853 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60854 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
60855 HYBRID_BREAK();
60856 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST):
60857 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
60858 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60859 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
60860 HYBRID_BREAK();
60861 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST):
60862 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
60863 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60864 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
60865 HYBRID_BREAK();
60866 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST):
60867 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
60868 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60869 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
60870 HYBRID_BREAK();
60871 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV):
60872 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
60873 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60874 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
60875 HYBRID_BREAK();
60876 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_TMPVAR):
60877 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
60878 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60879 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
60880 HYBRID_BREAK();
60881 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_TMPVAR):
60882 VM_TRACE(ZEND_POW_SPEC_TMPVAR_TMPVAR)
60883 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60884 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_TMPVAR)
60885 HYBRID_BREAK();
60886 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR):
60887 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
60888 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60889 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
60890 HYBRID_BREAK();
60891 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR):
60892 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
60893 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60894 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
60895 HYBRID_BREAK();
60896 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
60897 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
60898 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60899 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
60900 HYBRID_BREAK();
60901 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
60902 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
60903 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60904 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
60905 HYBRID_BREAK();
60906 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR):
60907 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
60908 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60909 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
60910 HYBRID_BREAK();
60911 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
60912 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
60913 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60914 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
60915 HYBRID_BREAK();
60916 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
60917 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
60918 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60919 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
60920 HYBRID_BREAK();
60921 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR):
60922 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
60923 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60924 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
60925 HYBRID_BREAK();
60926 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR):
60927 VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
60928 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60929 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
60930 HYBRID_BREAK();
60931 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR):
60932 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
60933 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60934 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
60935 HYBRID_BREAK();
60936 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR):
60937 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
60938 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60939 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
60940 HYBRID_BREAK();
60941 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR):
60942 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
60943 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60944 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
60945 HYBRID_BREAK();
60946 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR):
60947 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
60948 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60949 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
60950 HYBRID_BREAK();
60951 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR):
60952 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
60953 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60954 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
60955 HYBRID_BREAK();
60956 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR):
60957 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
60958 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60959 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
60960 HYBRID_BREAK();
60961 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_TMPVAR):
60962 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
60963 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60964 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
60965 HYBRID_BREAK();
60966 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR):
60967 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
60968 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60969 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
60970 HYBRID_BREAK();
60971 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR):
60972 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
60973 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60974 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
60975 HYBRID_BREAK();
60976 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR):
60977 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
60978 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60979 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
60980 HYBRID_BREAK();
60981 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR):
60982 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
60983 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60984 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
60985 HYBRID_BREAK();
60986 HYBRID_CASE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED):
60987 VM_TRACE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
60988 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60989 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
60990 HYBRID_BREAK();
60991 HYBRID_CASE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED):
60992 VM_TRACE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
60993 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60994 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
60995 HYBRID_BREAK();
60996 HYBRID_CASE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED):
60997 VM_TRACE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
60998 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60999 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
61000 HYBRID_BREAK();
61001 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED):
61002 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
61003 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61004 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
61005 HYBRID_BREAK();
61006 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED):
61007 VM_TRACE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
61008 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61009 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
61010 HYBRID_BREAK();
61011 HYBRID_CASE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED):
61012 VM_TRACE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
61013 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61014 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
61015 HYBRID_BREAK();
61016 HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED):
61017 VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
61018 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61019 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
61020 HYBRID_BREAK();
61021 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED):
61022 VM_TRACE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
61023 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61024 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
61025 HYBRID_BREAK();
61026 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED):
61027 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
61028 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61029 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
61030 HYBRID_BREAK();
61031 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED):
61032 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
61033 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61034 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
61035 HYBRID_BREAK();
61036 HYBRID_CASE(ZEND_COUNT_SPEC_TMPVAR_UNUSED):
61037 VM_TRACE(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
61038 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61039 VM_TRACE_OP_END(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
61040 HYBRID_BREAK();
61041 HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED):
61042 VM_TRACE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
61043 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61044 VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
61045 HYBRID_BREAK();
61046 HYBRID_CASE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED):
61047 VM_TRACE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
61048 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61049 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
61050 HYBRID_BREAK();
61051 HYBRID_CASE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED):
61052 VM_TRACE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
61053 ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61054 VM_TRACE_OP_END(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
61055 HYBRID_BREAK();
61056 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CV):
61057 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CV)
61058 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61059 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CV)
61060 HYBRID_BREAK();
61061 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CV):
61062 VM_TRACE(ZEND_POW_SPEC_TMPVAR_CV)
61063 ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61064 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CV)
61065 HYBRID_BREAK();
61066 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CV):
61067 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CV)
61068 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61069 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CV)
61070 HYBRID_BREAK();
61071 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CV):
61072 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
61073 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61074 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
61075 HYBRID_BREAK();
61076 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV):
61077 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
61078 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61079 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
61080 HYBRID_BREAK();
61081 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV):
61082 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
61083 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61084 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
61085 HYBRID_BREAK();
61086 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV):
61087 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
61088 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61089 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
61090 HYBRID_BREAK();
61091 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV):
61092 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
61093 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61094 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
61095 HYBRID_BREAK();
61096 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV):
61097 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
61098 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61099 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
61100 HYBRID_BREAK();
61101 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV):
61102 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
61103 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61104 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
61105 HYBRID_BREAK();
61106 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CV):
61107 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CV)
61108 ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61109 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CV)
61110 HYBRID_BREAK();
61111 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV):
61112 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
61113 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61114 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
61115 HYBRID_BREAK();
61116 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV):
61117 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
61118 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61119 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
61120 HYBRID_BREAK();
61121 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV):
61122 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
61123 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61124 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
61125 HYBRID_BREAK();
61126 HYBRID_CASE(ZEND_RETURN_SPEC_TMP):
61127 VM_TRACE(ZEND_RETURN_SPEC_TMP)
61128{
61129 USE_OPLINE
61130 zval *retval_ptr;
61131 zval *return_value;
61132
61133 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
61134 return_value = EX(return_value);
61135
61136 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
61137 SAVE_OPLINE();
61138 retval_ptr = ZVAL_UNDEFINED_OP1();
61139 if (return_value) {
61140 ZVAL_NULL(return_value);
61141 }
61142 } else if (!return_value) {
61143 if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
61144 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
61145 SAVE_OPLINE();
61146 rc_dtor_func(Z_COUNTED_P(retval_ptr));
61147 }
61148 }
61149 } else {
61150 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
61151 ZVAL_COPY_VALUE(return_value, retval_ptr);
61152 if (IS_TMP_VAR == IS_CONST) {
61153 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
61154 Z_ADDREF_P(return_value);
61155 }
61156 }
61157 } else if (IS_TMP_VAR == IS_CV) {
61158 do {
61159 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61160 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
61161 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
61162 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61163 ZVAL_COPY_VALUE(return_value, retval_ptr);
61164 if (GC_MAY_LEAK(ref)) {
61165 SAVE_OPLINE();
61166 gc_possible_root(ref);
61167 }
61168 ZVAL_NULL(retval_ptr);
61169 break;
61170 } else {
61171 Z_ADDREF_P(retval_ptr);
61172 }
61173 } else {
61174 retval_ptr = Z_REFVAL_P(retval_ptr);
61175 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61176 Z_ADDREF_P(retval_ptr);
61177 }
61178 }
61179 }
61180 ZVAL_COPY_VALUE(return_value, retval_ptr);
61181 } while (0);
61182 } else /* if (IS_TMP_VAR == IS_VAR) */ {
61183 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
61184 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61185
61186 retval_ptr = Z_REFVAL_P(retval_ptr);
61187 ZVAL_COPY_VALUE(return_value, retval_ptr);
61188 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
61189 efree_size(ref, sizeof(zend_reference));
61190 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61191 Z_ADDREF_P(retval_ptr);
61192 }
61193 } else {
61194 ZVAL_COPY_VALUE(return_value, retval_ptr);
61195 }
61196 }
61197 }
61198
61199
61200
61201 goto zend_leave_helper_SPEC_LABEL;
61202}
61203
61204 VM_TRACE_OP_END(ZEND_RETURN_SPEC_TMP)
61205 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_TMP):
61206 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_TMP)
61207 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61208 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_TMP)
61209 HYBRID_BREAK();
61210 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_TMP):
61211 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_TMP)
61212 ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61213 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_TMP)
61214 HYBRID_BREAK();
61215 HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP):
61216 VM_TRACE(ZEND_SEND_USER_SPEC_TMP)
61217 ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61218 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP)
61219 HYBRID_BREAK();
61220 HYBRID_CASE(ZEND_CAST_SPEC_TMP):
61221 VM_TRACE(ZEND_CAST_SPEC_TMP)
61222 ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61223 VM_TRACE_OP_END(ZEND_CAST_SPEC_TMP)
61224 HYBRID_BREAK();
61225 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_TMP):
61226 VM_TRACE(ZEND_FE_RESET_R_SPEC_TMP)
61227 ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61228 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_TMP)
61229 HYBRID_BREAK();
61230 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_TMP):
61231 VM_TRACE(ZEND_FE_RESET_RW_SPEC_TMP)
61232 ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61233 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_TMP)
61234 HYBRID_BREAK();
61235 HYBRID_CASE(ZEND_END_SILENCE_SPEC_TMP):
61236 VM_TRACE(ZEND_END_SILENCE_SPEC_TMP)
61237 ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61238 VM_TRACE_OP_END(ZEND_END_SILENCE_SPEC_TMP)
61239 HYBRID_BREAK();
61240 HYBRID_CASE(ZEND_JMP_SET_SPEC_TMP):
61241 VM_TRACE(ZEND_JMP_SET_SPEC_TMP)
61242 ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61243 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_TMP)
61244 HYBRID_BREAK();
61245 HYBRID_CASE(ZEND_COALESCE_SPEC_TMP):
61246 VM_TRACE(ZEND_COALESCE_SPEC_TMP)
61247 ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61248 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_TMP)
61249 HYBRID_BREAK();
61250 HYBRID_CASE(ZEND_JMP_NULL_SPEC_TMP):
61251 VM_TRACE(ZEND_JMP_NULL_SPEC_TMP)
61252 ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61253 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_TMP)
61254 HYBRID_BREAK();
61255 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_TMP):
61256 VM_TRACE(ZEND_QM_ASSIGN_SPEC_TMP)
61257 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61258 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_TMP)
61259 HYBRID_BREAK();
61260 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST):
61261 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
61262 ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61263 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
61264 HYBRID_BREAK();
61265 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CONST):
61266 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CONST)
61267 ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61268 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CONST)
61269 HYBRID_BREAK();
61270 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST):
61271 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
61272 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61273 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
61274 HYBRID_BREAK();
61275 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST):
61276 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
61277 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61278 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
61279 HYBRID_BREAK();
61280 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST):
61281 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
61282 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61283 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
61284 HYBRID_BREAK();
61285 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CONST):
61286 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CONST)
61287 ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61288 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CONST)
61289 HYBRID_BREAK();
61290 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CONST):
61291 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CONST)
61292 ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61293 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CONST)
61294 HYBRID_BREAK();
61295 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST):
61296 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
61297 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61298 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
61299 HYBRID_BREAK();
61300 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST):
61301 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
61302 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61303 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
61304 HYBRID_BREAK();
61305 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CONST):
61306 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
61307 ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61308 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
61309 HYBRID_BREAK();
61310 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CONST):
61311 VM_TRACE(ZEND_YIELD_SPEC_TMP_CONST)
61312 ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61313 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CONST)
61314 HYBRID_BREAK();
61315 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_TMP_CONST):
61316 VM_TRACE(ZEND_IN_ARRAY_SPEC_TMP_CONST)
61317 ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61318 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_TMP_CONST)
61319 HYBRID_BREAK();
61320 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR):
61321 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
61322 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61323 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
61324 HYBRID_BREAK();
61325 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR):
61326 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
61327 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61328 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
61329 HYBRID_BREAK();
61330 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR):
61331 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
61332 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61333 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
61334 HYBRID_BREAK();
61335 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_TMPVAR):
61336 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
61337 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61338 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
61339 HYBRID_BREAK();
61340 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR):
61341 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
61342 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61343 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
61344 HYBRID_BREAK();
61345 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR):
61346 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
61347 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61348 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
61349 HYBRID_BREAK();
61350 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_TMPVAR):
61351 VM_TRACE(ZEND_YIELD_SPEC_TMP_TMPVAR)
61352 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61353 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_TMPVAR)
61354 HYBRID_BREAK();
61355 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP):
61356 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
61357 ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61358 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
61359 HYBRID_BREAK();
61360 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_TMP):
61361 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_TMP)
61362 ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61363 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_TMP)
61364 HYBRID_BREAK();
61365 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP):
61366 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
61367 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61368 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
61369 HYBRID_BREAK();
61370 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_VAR):
61371 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_VAR)
61372 ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61373 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_VAR)
61374 HYBRID_BREAK();
61375 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED):
61376 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
61377 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61378 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
61379 HYBRID_BREAK();
61380 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED):
61381 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
61382 ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61383 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
61384 HYBRID_BREAK();
61385 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED):
61386 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
61387 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61388 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
61389 HYBRID_BREAK();
61390 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK):
61391 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
61392 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61393 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
61394 HYBRID_BREAK();
61395 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED):
61396 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
61397 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61398 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
61399 HYBRID_BREAK();
61400 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED):
61401 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
61402 ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61403 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
61404 HYBRID_BREAK();
61405 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_UNUSED):
61406 VM_TRACE(ZEND_YIELD_SPEC_TMP_UNUSED)
61407 ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61408 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_UNUSED)
61409 HYBRID_BREAK();
61410 HYBRID_CASE(ZEND_GET_TYPE_SPEC_TMP_UNUSED):
61411 VM_TRACE(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
61412 ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61413 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
61414 HYBRID_BREAK();
61415 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CV):
61416 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CV)
61417 ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61418 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CV)
61419 HYBRID_BREAK();
61420 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV):
61421 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
61422 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61423 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
61424 HYBRID_BREAK();
61425 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV):
61426 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
61427 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61428 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
61429 HYBRID_BREAK();
61430 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CV):
61431 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CV)
61432 ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61433 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CV)
61434 HYBRID_BREAK();
61435 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CV):
61436 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CV)
61437 ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61438 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CV)
61439 HYBRID_BREAK();
61440 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV):
61441 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
61442 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61443 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
61444 HYBRID_BREAK();
61445 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CV):
61446 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CV)
61447 ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61448 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CV)
61449 HYBRID_BREAK();
61450 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CV):
61451 VM_TRACE(ZEND_YIELD_SPEC_TMP_CV)
61452 ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61453 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CV)
61454 HYBRID_BREAK();
61455 HYBRID_CASE(ZEND_BIND_LEXICAL_SPEC_TMP_CV):
61456 VM_TRACE(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
61457 ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61458 VM_TRACE_OP_END(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
61459 HYBRID_BREAK();
61460 HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED):
61461 VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
61462 ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61463 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
61464 HYBRID_BREAK();
61465 HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED):
61466 VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
61467 ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61468 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
61469 HYBRID_BREAK();
61470 HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED):
61471 VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
61472 ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61473 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
61474 HYBRID_BREAK();
61475 HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED):
61476 VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
61477 ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61478 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
61479 HYBRID_BREAK();
61480 HYBRID_CASE(ZEND_POST_INC_SPEC_VAR):
61481 VM_TRACE(ZEND_POST_INC_SPEC_VAR)
61482 ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61483 VM_TRACE_OP_END(ZEND_POST_INC_SPEC_VAR)
61484 HYBRID_BREAK();
61485 HYBRID_CASE(ZEND_POST_DEC_SPEC_VAR):
61486 VM_TRACE(ZEND_POST_DEC_SPEC_VAR)
61487 ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61488 VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_VAR)
61489 HYBRID_BREAK();
61490 HYBRID_CASE(ZEND_RETURN_SPEC_VAR):
61491 VM_TRACE(ZEND_RETURN_SPEC_VAR)
61492{
61493 USE_OPLINE
61494 zval *retval_ptr;
61495 zval *return_value;
61496
61497 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
61498 return_value = EX(return_value);
61499
61500 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
61501 SAVE_OPLINE();
61502 retval_ptr = ZVAL_UNDEFINED_OP1();
61503 if (return_value) {
61504 ZVAL_NULL(return_value);
61505 }
61506 } else if (!return_value) {
61507 if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
61508 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
61509 SAVE_OPLINE();
61510 rc_dtor_func(Z_COUNTED_P(retval_ptr));
61511 }
61512 }
61513 } else {
61514 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
61515 ZVAL_COPY_VALUE(return_value, retval_ptr);
61516 if (IS_VAR == IS_CONST) {
61517 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
61518 Z_ADDREF_P(return_value);
61519 }
61520 }
61521 } else if (IS_VAR == IS_CV) {
61522 do {
61523 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61524 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
61525 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
61526 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61527 ZVAL_COPY_VALUE(return_value, retval_ptr);
61528 if (GC_MAY_LEAK(ref)) {
61529 SAVE_OPLINE();
61530 gc_possible_root(ref);
61531 }
61532 ZVAL_NULL(retval_ptr);
61533 break;
61534 } else {
61535 Z_ADDREF_P(retval_ptr);
61536 }
61537 } else {
61538 retval_ptr = Z_REFVAL_P(retval_ptr);
61539 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61540 Z_ADDREF_P(retval_ptr);
61541 }
61542 }
61543 }
61544 ZVAL_COPY_VALUE(return_value, retval_ptr);
61545 } while (0);
61546 } else /* if (IS_VAR == IS_VAR) */ {
61547 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
61548 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61549
61550 retval_ptr = Z_REFVAL_P(retval_ptr);
61551 ZVAL_COPY_VALUE(return_value, retval_ptr);
61552 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
61553 efree_size(ref, sizeof(zend_reference));
61554 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61555 Z_ADDREF_P(retval_ptr);
61556 }
61557 } else {
61558 ZVAL_COPY_VALUE(return_value, retval_ptr);
61559 }
61560 }
61561 }
61562
61563
61564
61565 goto zend_leave_helper_SPEC_LABEL;
61566}
61567
61568 VM_TRACE_OP_END(ZEND_RETURN_SPEC_VAR)
61569 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_VAR):
61570 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_VAR)
61571 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61572 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_VAR)
61573 HYBRID_BREAK();
61574 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_VAR):
61575 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_VAR)
61576 ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61577 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_VAR)
61578 HYBRID_BREAK();
61579 HYBRID_CASE(ZEND_SEND_USER_SPEC_VAR):
61580 VM_TRACE(ZEND_SEND_USER_SPEC_VAR)
61581 ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61582 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_VAR)
61583 HYBRID_BREAK();
61584 HYBRID_CASE(ZEND_CAST_SPEC_VAR):
61585 VM_TRACE(ZEND_CAST_SPEC_VAR)
61586 ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61587 VM_TRACE_OP_END(ZEND_CAST_SPEC_VAR)
61588 HYBRID_BREAK();
61589 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_VAR):
61590 VM_TRACE(ZEND_FE_RESET_R_SPEC_VAR)
61591 ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61592 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_VAR)
61593 HYBRID_BREAK();
61594 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_VAR):
61595 VM_TRACE(ZEND_FE_RESET_RW_SPEC_VAR)
61596 ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61597 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_VAR)
61598 HYBRID_BREAK();
61599 HYBRID_CASE(ZEND_FE_FETCH_R_SPEC_VAR):
61600 VM_TRACE(ZEND_FE_FETCH_R_SPEC_VAR)
61601 ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61602 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SPEC_VAR)
61603 HYBRID_BREAK();
61604 HYBRID_CASE(ZEND_FE_FETCH_RW_SPEC_VAR):
61605 VM_TRACE(ZEND_FE_FETCH_RW_SPEC_VAR)
61606 ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61607 VM_TRACE_OP_END(ZEND_FE_FETCH_RW_SPEC_VAR)
61608 HYBRID_BREAK();
61609 HYBRID_CASE(ZEND_JMP_SET_SPEC_VAR):
61610 VM_TRACE(ZEND_JMP_SET_SPEC_VAR)
61611 ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61612 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_VAR)
61613 HYBRID_BREAK();
61614 HYBRID_CASE(ZEND_COALESCE_SPEC_VAR):
61615 VM_TRACE(ZEND_COALESCE_SPEC_VAR)
61616 ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61617 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_VAR)
61618 HYBRID_BREAK();
61619 HYBRID_CASE(ZEND_JMP_NULL_SPEC_VAR):
61620 VM_TRACE(ZEND_JMP_NULL_SPEC_VAR)
61621 ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61622 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_VAR)
61623 HYBRID_BREAK();
61624 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_VAR):
61625 VM_TRACE(ZEND_QM_ASSIGN_SPEC_VAR)
61626 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61627 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_VAR)
61628 HYBRID_BREAK();
61629 HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR):
61630 VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
61631 ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61632 VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
61633 HYBRID_BREAK();
61634 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST):
61635 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
61636 ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61637 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
61638 HYBRID_BREAK();
61639 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CONST):
61640 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CONST)
61641 ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61642 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CONST)
61643 HYBRID_BREAK();
61644 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST):
61645 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
61646 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61647 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
61648 HYBRID_BREAK();
61649 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST):
61650 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
61651 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61652 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
61653 HYBRID_BREAK();
61654 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST):
61655 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
61656 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61657 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
61658 HYBRID_BREAK();
61659 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CONST):
61660 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
61661 ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61662 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
61663 HYBRID_BREAK();
61664 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST):
61665 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
61666 ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61667 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
61668 HYBRID_BREAK();
61669 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST):
61670 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
61671 ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61672 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
61673 HYBRID_BREAK();
61674 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST):
61675 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
61676 ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61677 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
61678 HYBRID_BREAK();
61679 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST):
61680 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
61681 ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61682 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
61683 HYBRID_BREAK();
61684 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST):
61685 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
61686 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61687 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
61688 HYBRID_BREAK();
61689 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST):
61690 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
61691 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61692 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
61693 HYBRID_BREAK();
61694 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST):
61695 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
61696 ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61697 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
61698 HYBRID_BREAK();
61699 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST):
61700 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
61701 ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61702 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
61703 HYBRID_BREAK();
61704 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST):
61705 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
61706 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61707 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
61708 HYBRID_BREAK();
61709 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST):
61710 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
61711 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61712 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
61713 HYBRID_BREAK();
61714 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST):
61715 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
61716 ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61717 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
61718 HYBRID_BREAK();
61719 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST):
61720 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
61721 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61722 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
61723 HYBRID_BREAK();
61724 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP):
61725 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
61726 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61727 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
61728 HYBRID_BREAK();
61729 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR):
61730 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
61731 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61732 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
61733 HYBRID_BREAK();
61734 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV):
61735 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
61736 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61737 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
61738 HYBRID_BREAK();
61739 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST):
61740 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
61741 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61742 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
61743 HYBRID_BREAK();
61744 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP):
61745 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
61746 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61747 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
61748 HYBRID_BREAK();
61749 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR):
61750 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
61751 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61752 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
61753 HYBRID_BREAK();
61754 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV):
61755 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
61756 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61757 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
61758 HYBRID_BREAK();
61759 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED):
61760 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
61761 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61762 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
61763 HYBRID_BREAK();
61764 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED):
61765 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
61766 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61767 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
61768 HYBRID_BREAK();
61769 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR):
61770 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
61771 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61772 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
61773 HYBRID_BREAK();
61774 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV):
61775 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
61776 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61777 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
61778 HYBRID_BREAK();
61779 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST):
61780 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
61781 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61782 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
61783 HYBRID_BREAK();
61784 HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_CONST):
61785 VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_CONST)
61786 ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61787 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_CONST)
61788 HYBRID_BREAK();
61789 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST):
61790 VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
61791 ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61792 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
61793 HYBRID_BREAK();
61794 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST):
61795 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
61796 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61797 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
61798 HYBRID_BREAK();
61799 HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_CONST):
61800 VM_TRACE(ZEND_SEND_REF_SPEC_VAR_CONST)
61801 ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61802 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_CONST)
61803 HYBRID_BREAK();
61804 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST):
61805 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
61806 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61807 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
61808 HYBRID_BREAK();
61809 HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST):
61810 VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
61811 ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61812 VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
61813 HYBRID_BREAK();
61814 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST):
61815 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
61816 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61817 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
61818 HYBRID_BREAK();
61819 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST):
61820 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
61821 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61822 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
61823 HYBRID_BREAK();
61824 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CONST):
61825 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
61826 ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61827 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
61828 HYBRID_BREAK();
61829 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CONST):
61830 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CONST)
61831 ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61832 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CONST)
61833 HYBRID_BREAK();
61834 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CONST):
61835 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
61836 ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61837 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
61838 HYBRID_BREAK();
61839 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CONST):
61840 VM_TRACE(ZEND_YIELD_SPEC_VAR_CONST)
61841 ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61842 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CONST)
61843 HYBRID_BREAK();
61844 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_VAR_CONST):
61845 VM_TRACE(ZEND_IN_ARRAY_SPEC_VAR_CONST)
61846 ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61847 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_VAR_CONST)
61848 HYBRID_BREAK();
61849 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV):
61850 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
61851 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61852 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
61853 HYBRID_BREAK();
61854 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR):
61855 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
61856 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61857 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
61858 HYBRID_BREAK();
61859 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR):
61860 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
61861 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61862 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
61863 HYBRID_BREAK();
61864 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR):
61865 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
61866 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61867 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
61868 HYBRID_BREAK();
61869 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR):
61870 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
61871 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61872 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
61873 HYBRID_BREAK();
61874 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR):
61875 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
61876 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61877 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
61878 HYBRID_BREAK();
61879 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR):
61880 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
61881 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61882 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
61883 HYBRID_BREAK();
61884 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR):
61885 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
61886 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61887 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
61888 HYBRID_BREAK();
61889 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR):
61890 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
61891 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61892 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
61893 HYBRID_BREAK();
61894 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR):
61895 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
61896 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61897 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
61898 HYBRID_BREAK();
61899 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR):
61900 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
61901 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61902 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
61903 HYBRID_BREAK();
61904 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR):
61905 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
61906 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61907 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
61908 HYBRID_BREAK();
61909 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR):
61910 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
61911 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61912 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
61913 HYBRID_BREAK();
61914 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR):
61915 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
61916 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61917 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
61918 HYBRID_BREAK();
61919 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR):
61920 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
61921 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61922 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
61923 HYBRID_BREAK();
61924 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST):
61925 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
61926 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61927 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
61928 HYBRID_BREAK();
61929 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP):
61930 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
61931 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61932 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
61933 HYBRID_BREAK();
61934 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR):
61935 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61936 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61937 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61938 HYBRID_BREAK();
61939 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV):
61940 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
61941 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61942 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
61943 HYBRID_BREAK();
61944 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST):
61945 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
61946 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61947 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
61948 HYBRID_BREAK();
61949 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP):
61950 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
61951 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61952 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
61953 HYBRID_BREAK();
61954 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR):
61955 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61956 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61957 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61958 HYBRID_BREAK();
61959 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV):
61960 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
61961 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61962 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
61963 HYBRID_BREAK();
61964 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR):
61965 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61966 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61967 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61968 HYBRID_BREAK();
61969 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV):
61970 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
61971 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61972 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
61973 HYBRID_BREAK();
61974 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR):
61975 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
61976 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61977 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
61978 HYBRID_BREAK();
61979 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR):
61980 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
61981 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61982 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
61983 HYBRID_BREAK();
61984 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR):
61985 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
61986 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61987 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
61988 HYBRID_BREAK();
61989 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR):
61990 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
61991 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61992 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
61993 HYBRID_BREAK();
61994 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR):
61995 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
61996 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61997 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
61998 HYBRID_BREAK();
61999 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_TMPVAR):
62000 VM_TRACE(ZEND_YIELD_SPEC_VAR_TMPVAR)
62001 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62002 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_TMPVAR)
62003 HYBRID_BREAK();
62004 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP):
62005 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
62006 ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62007 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
62008 HYBRID_BREAK();
62009 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_TMP):
62010 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_TMP)
62011 ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62012 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_TMP)
62013 HYBRID_BREAK();
62014 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP):
62015 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
62016 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62017 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
62018 HYBRID_BREAK();
62019 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED):
62020 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
62021 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62022 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
62023 HYBRID_BREAK();
62024 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED):
62025 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
62026 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62027 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
62028 HYBRID_BREAK();
62029 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR):
62030 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
62031 ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62032 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
62033 HYBRID_BREAK();
62034 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_VAR):
62035 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_VAR)
62036 ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62037 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_VAR)
62038 HYBRID_BREAK();
62039 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR):
62040 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
62041 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62042 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
62043 HYBRID_BREAK();
62044 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED):
62045 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
62046 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62047 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
62048 HYBRID_BREAK();
62049 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED):
62050 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
62051 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62052 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
62053 HYBRID_BREAK();
62054 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_VAR):
62055 VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
62056 ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62057 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
62058 HYBRID_BREAK();
62059 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED):
62060 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
62061 ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62062 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
62063 HYBRID_BREAK();
62064 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED):
62065 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
62066 ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62067 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
62068 HYBRID_BREAK();
62069 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED):
62070 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
62071 ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62072 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
62073 HYBRID_BREAK();
62074 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED):
62075 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
62076 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62077 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
62078 HYBRID_BREAK();
62079 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST):
62080 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
62081 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62082 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
62083 HYBRID_BREAK();
62084 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP):
62085 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
62086 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62087 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
62088 HYBRID_BREAK();
62089 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR):
62090 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
62091 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62092 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
62093 HYBRID_BREAK();
62094 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV):
62095 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
62096 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62097 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
62098 HYBRID_BREAK();
62099 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED):
62100 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
62101 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62102 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
62103 HYBRID_BREAK();
62104 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED):
62105 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
62106 ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62107 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
62108 HYBRID_BREAK();
62109 HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_UNUSED):
62110 VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
62111 ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62112 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
62113 HYBRID_BREAK();
62114 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED):
62115 VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
62116 ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62117 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
62118 HYBRID_BREAK();
62119 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED):
62120 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
62121 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62122 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
62123 HYBRID_BREAK();
62124 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK):
62125 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
62126 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62127 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
62128 HYBRID_BREAK();
62129 HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_UNUSED):
62130 VM_TRACE(ZEND_SEND_REF_SPEC_VAR_UNUSED)
62131 ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62132 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_UNUSED)
62133 HYBRID_BREAK();
62134 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED):
62135 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
62136 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62137 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
62138 HYBRID_BREAK();
62139 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK):
62140 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
62141 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62142 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
62143 HYBRID_BREAK();
62144 HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED):
62145 VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
62146 ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62147 VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
62148 HYBRID_BREAK();
62149 HYBRID_CASE(ZEND_NEW_SPEC_VAR_UNUSED):
62150 VM_TRACE(ZEND_NEW_SPEC_VAR_UNUSED)
62151 ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62152 VM_TRACE_OP_END(ZEND_NEW_SPEC_VAR_UNUSED)
62153 HYBRID_BREAK();
62154 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED):
62155 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
62156 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62157 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
62158 HYBRID_BREAK();
62159 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED):
62160 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
62161 ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62162 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
62163 HYBRID_BREAK();
62164 HYBRID_CASE(ZEND_SEPARATE_SPEC_VAR_UNUSED):
62165 VM_TRACE(ZEND_SEPARATE_SPEC_VAR_UNUSED)
62166 ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62167 VM_TRACE_OP_END(ZEND_SEPARATE_SPEC_VAR_UNUSED)
62168 HYBRID_BREAK();
62169 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_UNUSED):
62170 VM_TRACE(ZEND_YIELD_SPEC_VAR_UNUSED)
62171 ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62172 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_UNUSED)
62173 HYBRID_BREAK();
62174 HYBRID_CASE(ZEND_MAKE_REF_SPEC_VAR_UNUSED):
62175 VM_TRACE(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
62176 ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62177 VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
62178 HYBRID_BREAK();
62179 HYBRID_CASE(ZEND_GET_TYPE_SPEC_VAR_UNUSED):
62180 VM_TRACE(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
62181 ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62182 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
62183 HYBRID_BREAK();
62184 HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED):
62185 VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
62186 ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62187 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
62188 HYBRID_BREAK();
62189 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CV):
62190 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CV)
62191 ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62192 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CV)
62193 HYBRID_BREAK();
62194 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV):
62195 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
62196 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62197 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
62198 HYBRID_BREAK();
62199 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV):
62200 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
62201 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62202 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
62203 HYBRID_BREAK();
62204 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CV):
62205 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CV)
62206 ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62207 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CV)
62208 HYBRID_BREAK();
62209 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV):
62210 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
62211 ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62212 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
62213 HYBRID_BREAK();
62214 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CV):
62215 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
62216 ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62217 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
62218 HYBRID_BREAK();
62219 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CV):
62220 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
62221 ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62222 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
62223 HYBRID_BREAK();
62224 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV):
62225 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
62226 ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62227 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
62228 HYBRID_BREAK();
62229 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV):
62230 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
62231 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62232 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
62233 HYBRID_BREAK();
62234 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV):
62235 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
62236 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62237 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
62238 HYBRID_BREAK();
62239 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV):
62240 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
62241 ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62242 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
62243 HYBRID_BREAK();
62244 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV):
62245 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
62246 ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62247 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
62248 HYBRID_BREAK();
62249 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV):
62250 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
62251 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62252 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
62253 HYBRID_BREAK();
62254 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV):
62255 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
62256 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62257 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
62258 HYBRID_BREAK();
62259 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CV):
62260 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
62261 ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62262 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
62263 HYBRID_BREAK();
62264 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST):
62265 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
62266 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62267 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
62268 HYBRID_BREAK();
62269 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP):
62270 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
62271 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62272 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
62273 HYBRID_BREAK();
62274 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR):
62275 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
62276 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62277 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
62278 HYBRID_BREAK();
62279 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV):
62280 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
62281 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62282 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
62283 HYBRID_BREAK();
62284 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST):
62285 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
62286 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62287 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
62288 HYBRID_BREAK();
62289 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP):
62290 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
62291 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62292 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
62293 HYBRID_BREAK();
62294 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR):
62295 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
62296 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62297 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
62298 HYBRID_BREAK();
62299 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV):
62300 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
62301 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62302 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
62303 HYBRID_BREAK();
62304 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED):
62305 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
62306 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62307 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
62308 HYBRID_BREAK();
62309 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED):
62310 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
62311 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62312 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
62313 HYBRID_BREAK();
62314 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_CV):
62315 VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_CV)
62316 ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62317 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_CV)
62318 HYBRID_BREAK();
62319 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR):
62320 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
62321 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62322 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
62323 HYBRID_BREAK();
62324 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV):
62325 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
62326 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62327 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
62328 HYBRID_BREAK();
62329 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV):
62330 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
62331 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62332 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
62333 HYBRID_BREAK();
62334 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV):
62335 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
62336 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62337 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
62338 HYBRID_BREAK();
62339 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CV):
62340 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CV)
62341 ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62342 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CV)
62343 HYBRID_BREAK();
62344 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CV):
62345 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CV)
62346 ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62347 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CV)
62348 HYBRID_BREAK();
62349 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CV):
62350 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CV)
62351 ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62352 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CV)
62353 HYBRID_BREAK();
62354 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CV):
62355 VM_TRACE(ZEND_YIELD_SPEC_VAR_CV)
62356 ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62357 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CV)
62358 HYBRID_BREAK();
62359 HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED):
62360 VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
62361 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62362 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
62363 HYBRID_BREAK();
62364 HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED):
62365 VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
62366 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62367 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
62368 HYBRID_BREAK();
62369 HYBRID_CASE(ZEND_CLONE_SPEC_UNUSED):
62370 VM_TRACE(ZEND_CLONE_SPEC_UNUSED)
62371 ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62372 VM_TRACE_OP_END(ZEND_CLONE_SPEC_UNUSED)
62373 HYBRID_BREAK();
62374 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED):
62375 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
62376 ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62377 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
62378 HYBRID_BREAK();
62379 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST):
62380 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
62381 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62382 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
62383 HYBRID_BREAK();
62384 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST):
62385 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
62386 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62387 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
62388 HYBRID_BREAK();
62389 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST):
62390 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
62391 ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62392 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
62393 HYBRID_BREAK();
62394 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST):
62395 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
62396 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62397 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
62398 HYBRID_BREAK();
62399 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST):
62400 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
62401 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62402 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
62403 HYBRID_BREAK();
62404 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST):
62405 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
62406 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62407 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
62408 HYBRID_BREAK();
62409 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST):
62410 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
62411 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62412 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
62413 HYBRID_BREAK();
62414 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST):
62415 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
62416 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62417 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
62418 HYBRID_BREAK();
62419 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST):
62420 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
62421 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62422 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
62423 HYBRID_BREAK();
62424 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST):
62425 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
62426 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62427 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
62428 HYBRID_BREAK();
62429 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP):
62430 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
62431 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62432 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
62433 HYBRID_BREAK();
62434 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR):
62435 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
62436 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62437 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
62438 HYBRID_BREAK();
62439 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV):
62440 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
62441 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62442 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
62443 HYBRID_BREAK();
62444 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR):
62445 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
62446 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62447 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
62448 HYBRID_BREAK();
62449 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV):
62450 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
62451 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62452 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
62453 HYBRID_BREAK();
62454 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST):
62455 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
62456 ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62457 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
62458 HYBRID_BREAK();
62459 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST):
62460 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
62461 ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62462 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
62463 HYBRID_BREAK();
62464 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST):
62465 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
62466 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62467 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
62468 HYBRID_BREAK();
62469 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST):
62470 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
62471 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62472 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
62473 HYBRID_BREAK();
62474 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST):
62475 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
62476 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62477 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
62478 HYBRID_BREAK();
62479 HYBRID_CASE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST):
62480 VM_TRACE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
62481 ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62482 VM_TRACE_OP_END(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
62483 HYBRID_BREAK();
62484 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST):
62485 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
62486 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62487 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
62488 HYBRID_BREAK();
62489 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST):
62490 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
62491 ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62492 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
62493 HYBRID_BREAK();
62494 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST):
62495 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
62496 ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62497 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
62498 HYBRID_BREAK();
62499 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST):
62500 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
62501 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62502 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
62503 HYBRID_BREAK();
62504 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CONST):
62505 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CONST)
62506 ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62507 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CONST)
62508 HYBRID_BREAK();
62509 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV):
62510 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
62511 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62512 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
62513 HYBRID_BREAK();
62514 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR):
62515 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
62516 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62517 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
62518 HYBRID_BREAK();
62519 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR):
62520 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
62521 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62522 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
62523 HYBRID_BREAK();
62524 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR):
62525 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
62526 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62527 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
62528 HYBRID_BREAK();
62529 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR):
62530 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
62531 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62532 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
62533 HYBRID_BREAK();
62534 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR):
62535 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
62536 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62537 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
62538 HYBRID_BREAK();
62539 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR):
62540 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
62541 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62542 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
62543 HYBRID_BREAK();
62544 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR):
62545 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
62546 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62547 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
62548 HYBRID_BREAK();
62549 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR):
62550 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
62551 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62552 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
62553 HYBRID_BREAK();
62554 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR):
62555 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
62556 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62557 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
62558 HYBRID_BREAK();
62559 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST):
62560 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
62561 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62562 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
62563 HYBRID_BREAK();
62564 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP):
62565 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
62566 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62567 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
62568 HYBRID_BREAK();
62569 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
62570 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62571 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62572 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62573 HYBRID_BREAK();
62574 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
62575 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62576 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62577 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62578 HYBRID_BREAK();
62579 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
62580 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62581 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62582 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62583 HYBRID_BREAK();
62584 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
62585 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62586 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62587 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62588 HYBRID_BREAK();
62589 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR):
62590 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
62591 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62592 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
62593 HYBRID_BREAK();
62594 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR):
62595 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
62596 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62597 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
62598 HYBRID_BREAK();
62599 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR):
62600 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62601 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62602 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62603 HYBRID_BREAK();
62604 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR):
62605 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62606 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62607 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62608 HYBRID_BREAK();
62609 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR):
62610 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
62611 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62612 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
62613 HYBRID_BREAK();
62614 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR):
62615 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
62616 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62617 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
62618 HYBRID_BREAK();
62619 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR):
62620 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
62621 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62622 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
62623 HYBRID_BREAK();
62624 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_TMPVAR):
62625 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
62626 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62627 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
62628 HYBRID_BREAK();
62629 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED):
62630 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
62631 ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62632 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
62633 HYBRID_BREAK();
62634 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED):
62635 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
62636 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62637 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
62638 HYBRID_BREAK();
62639 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED):
62640 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
62641 ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62642 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
62643 HYBRID_BREAK();
62644 HYBRID_CASE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED):
62645 VM_TRACE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
62646 ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62647 VM_TRACE_OP_END(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
62648 HYBRID_BREAK();
62649 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED):
62650 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
62651 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62652 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
62653 HYBRID_BREAK();
62654 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK):
62655 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
62656 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62657 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
62658 HYBRID_BREAK();
62659 HYBRID_CASE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED):
62660 VM_TRACE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
62661 ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62662 VM_TRACE_OP_END(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
62663 HYBRID_BREAK();
62664 HYBRID_CASE(ZEND_NEW_SPEC_UNUSED_UNUSED):
62665 VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED)
62666 ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62667 VM_TRACE_OP_END(ZEND_NEW_SPEC_UNUSED_UNUSED)
62668 HYBRID_BREAK();
62669 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED):
62670 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
62671 ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62672 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
62673 HYBRID_BREAK();
62674 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_UNUSED):
62675 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_UNUSED)
62676 ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62677 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_UNUSED)
62678 HYBRID_BREAK();
62679 HYBRID_CASE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED):
62680 VM_TRACE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
62681 ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62682 VM_TRACE_OP_END(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
62683 HYBRID_BREAK();
62684 HYBRID_CASE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED):
62685 VM_TRACE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
62686 ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62687 VM_TRACE_OP_END(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
62688 HYBRID_BREAK();
62689 HYBRID_CASE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED):
62690 VM_TRACE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
62691 ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62692 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
62693 HYBRID_BREAK();
62694 HYBRID_CASE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED):
62695 VM_TRACE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
62696 ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62697 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
62698 HYBRID_BREAK();
62699 HYBRID_CASE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED):
62700 VM_TRACE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
62701 ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62702 VM_TRACE_OP_END(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
62703 HYBRID_BREAK();
62704 HYBRID_CASE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED):
62705 VM_TRACE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
62706 ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62707 VM_TRACE_OP_END(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
62708 HYBRID_BREAK();
62709 HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED):
62710 VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
62711 ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62712 VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
62713 HYBRID_BREAK();
62714 HYBRID_CASE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED):
62715 VM_TRACE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
62716 ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62717 VM_TRACE_OP_END(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
62718 HYBRID_BREAK();
62719 HYBRID_CASE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED):
62720 VM_TRACE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
62721 ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62722 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
62723 HYBRID_BREAK();
62724 HYBRID_CASE(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER):
62725 VM_TRACE(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER)
62726 ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62727 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER)
62728 HYBRID_BREAK();
62729 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV):
62730 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
62731 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62732 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
62733 HYBRID_BREAK();
62734 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV):
62735 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
62736 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62737 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
62738 HYBRID_BREAK();
62739 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV):
62740 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
62741 ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62742 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
62743 HYBRID_BREAK();
62744 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV):
62745 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
62746 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62747 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
62748 HYBRID_BREAK();
62749 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV):
62750 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
62751 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62752 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
62753 HYBRID_BREAK();
62754 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV):
62755 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
62756 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62757 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
62758 HYBRID_BREAK();
62759 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV):
62760 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
62761 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62762 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
62763 HYBRID_BREAK();
62764 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV):
62765 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
62766 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62767 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
62768 HYBRID_BREAK();
62769 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV):
62770 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
62771 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62772 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
62773 HYBRID_BREAK();
62774 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST):
62775 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
62776 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62777 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
62778 HYBRID_BREAK();
62779 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP):
62780 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
62781 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62782 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
62783 HYBRID_BREAK();
62784 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR):
62785 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
62786 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62787 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
62788 HYBRID_BREAK();
62789 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV):
62790 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
62791 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62792 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
62793 HYBRID_BREAK();
62794 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR):
62795 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
62796 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62797 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
62798 HYBRID_BREAK();
62799 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV):
62800 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
62801 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62802 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
62803 HYBRID_BREAK();
62804 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CV):
62805 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
62806 ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62807 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
62808 HYBRID_BREAK();
62809 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV):
62810 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
62811 ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62812 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
62813 HYBRID_BREAK();
62814 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV):
62815 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
62816 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62817 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
62818 HYBRID_BREAK();
62819 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV):
62820 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
62821 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62822 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
62823 HYBRID_BREAK();
62824 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV):
62825 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
62826 ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62827 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
62828 HYBRID_BREAK();
62829 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV):
62830 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
62831 ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62832 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
62833 HYBRID_BREAK();
62834 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV):
62835 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
62836 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62837 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
62838 HYBRID_BREAK();
62839 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CV):
62840 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CV)
62841 ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62842 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CV)
62843 HYBRID_BREAK();
62844 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CV):
62845 VM_TRACE(ZEND_BOOL_NOT_SPEC_CV)
62846 ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62847 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CV)
62848 HYBRID_BREAK();
62849 HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED):
62850 VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
62851 ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62852 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
62853 HYBRID_BREAK();
62854 HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED):
62855 VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
62856 ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62857 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
62858 HYBRID_BREAK();
62859 HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED):
62860 VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
62861 ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62862 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
62863 HYBRID_BREAK();
62864 HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED):
62865 VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
62866 ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62867 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
62868 HYBRID_BREAK();
62869 HYBRID_CASE(ZEND_POST_INC_SPEC_CV):
62870 VM_TRACE(ZEND_POST_INC_SPEC_CV)
62871 ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62872 VM_TRACE_OP_END(ZEND_POST_INC_SPEC_CV)
62873 HYBRID_BREAK();
62874 HYBRID_CASE(ZEND_POST_DEC_SPEC_CV):
62875 VM_TRACE(ZEND_POST_DEC_SPEC_CV)
62876 ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62877 VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_CV)
62878 HYBRID_BREAK();
62879 HYBRID_CASE(ZEND_ECHO_SPEC_CV):
62880 VM_TRACE(ZEND_ECHO_SPEC_CV)
62881 ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62882 VM_TRACE_OP_END(ZEND_ECHO_SPEC_CV)
62883 HYBRID_BREAK();
62884 HYBRID_CASE(ZEND_JMPZ_SPEC_CV):
62885 VM_TRACE(ZEND_JMPZ_SPEC_CV)
62886 ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62887 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CV)
62888 HYBRID_BREAK();
62889 HYBRID_CASE(ZEND_JMPNZ_SPEC_CV):
62890 VM_TRACE(ZEND_JMPNZ_SPEC_CV)
62891 ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62892 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CV)
62893 HYBRID_BREAK();
62894 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CV):
62895 VM_TRACE(ZEND_JMPZ_EX_SPEC_CV)
62896 ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62897 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CV)
62898 HYBRID_BREAK();
62899 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CV):
62900 VM_TRACE(ZEND_JMPNZ_EX_SPEC_CV)
62901 ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62902 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CV)
62903 HYBRID_BREAK();
62904 HYBRID_CASE(ZEND_RETURN_SPEC_CV):
62905 VM_TRACE(ZEND_RETURN_SPEC_CV)
62906{
62907 USE_OPLINE
62908 zval *retval_ptr;
62909 zval *return_value;
62910
62911 retval_ptr = EX_VAR(opline->op1.var);
62912 return_value = EX(return_value);
62913
62914 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
62915 SAVE_OPLINE();
62916 retval_ptr = ZVAL_UNDEFINED_OP1();
62917 if (return_value) {
62918 ZVAL_NULL(return_value);
62919 }
62920 } else if (!return_value) {
62921 if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
62922 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
62923 SAVE_OPLINE();
62924 rc_dtor_func(Z_COUNTED_P(retval_ptr));
62925 }
62926 }
62927 } else {
62928 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
62929 ZVAL_COPY_VALUE(return_value, retval_ptr);
62930 if (IS_CV == IS_CONST) {
62931 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
62932 Z_ADDREF_P(return_value);
62933 }
62934 }
62935 } else if (IS_CV == IS_CV) {
62936 do {
62937 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
62938 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
62939 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
62940 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
62941 ZVAL_COPY_VALUE(return_value, retval_ptr);
62942 if (GC_MAY_LEAK(ref)) {
62943 SAVE_OPLINE();
62944 gc_possible_root(ref);
62945 }
62946 ZVAL_NULL(retval_ptr);
62947 break;
62948 } else {
62949 Z_ADDREF_P(retval_ptr);
62950 }
62951 } else {
62952 retval_ptr = Z_REFVAL_P(retval_ptr);
62953 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
62954 Z_ADDREF_P(retval_ptr);
62955 }
62956 }
62957 }
62958 ZVAL_COPY_VALUE(return_value, retval_ptr);
62959 } while (0);
62960 } else /* if (IS_CV == IS_VAR) */ {
62961 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
62962 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
62963
62964 retval_ptr = Z_REFVAL_P(retval_ptr);
62965 ZVAL_COPY_VALUE(return_value, retval_ptr);
62966 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
62967 efree_size(ref, sizeof(zend_reference));
62968 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
62969 Z_ADDREF_P(retval_ptr);
62970 }
62971 } else {
62972 ZVAL_COPY_VALUE(return_value, retval_ptr);
62973 }
62974 }
62975 }
62976
62977
62978
62979 goto zend_leave_helper_SPEC_LABEL;
62980}
62981
62982 VM_TRACE_OP_END(ZEND_RETURN_SPEC_CV)
62983 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CV):
62984 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CV)
62985 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62986 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CV)
62987 HYBRID_BREAK();
62988 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CV):
62989 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CV)
62990 ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62991 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CV)
62992 HYBRID_BREAK();
62993 HYBRID_CASE(ZEND_THROW_SPEC_CV):
62994 VM_TRACE(ZEND_THROW_SPEC_CV)
62995 ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62996 VM_TRACE_OP_END(ZEND_THROW_SPEC_CV)
62997 HYBRID_BREAK();
62998 HYBRID_CASE(ZEND_SEND_USER_SPEC_CV):
62999 VM_TRACE(ZEND_SEND_USER_SPEC_CV)
63000 ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63001 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV)
63002 HYBRID_BREAK();
63003 HYBRID_CASE(ZEND_BOOL_SPEC_CV):
63004 VM_TRACE(ZEND_BOOL_SPEC_CV)
63005 ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63006 VM_TRACE_OP_END(ZEND_BOOL_SPEC_CV)
63007 HYBRID_BREAK();
63008 HYBRID_CASE(ZEND_CLONE_SPEC_CV):
63009 VM_TRACE(ZEND_CLONE_SPEC_CV)
63010 ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63011 VM_TRACE_OP_END(ZEND_CLONE_SPEC_CV)
63012 HYBRID_BREAK();
63013 HYBRID_CASE(ZEND_CAST_SPEC_CV):
63014 VM_TRACE(ZEND_CAST_SPEC_CV)
63015 ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63016 VM_TRACE_OP_END(ZEND_CAST_SPEC_CV)
63017 HYBRID_BREAK();
63018 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CV):
63019 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
63020 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63021 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
63022 HYBRID_BREAK();
63023 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CV):
63024 VM_TRACE(ZEND_FE_RESET_R_SPEC_CV)
63025 ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63026 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CV)
63027 HYBRID_BREAK();
63028 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CV):
63029 VM_TRACE(ZEND_FE_RESET_RW_SPEC_CV)
63030 ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63031 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CV)
63032 HYBRID_BREAK();
63033 HYBRID_CASE(ZEND_JMP_SET_SPEC_CV):
63034 VM_TRACE(ZEND_JMP_SET_SPEC_CV)
63035 ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63036 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CV)
63037 HYBRID_BREAK();
63038 HYBRID_CASE(ZEND_COALESCE_SPEC_CV):
63039 VM_TRACE(ZEND_COALESCE_SPEC_CV)
63040 ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63041 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CV)
63042 HYBRID_BREAK();
63043 HYBRID_CASE(ZEND_JMP_NULL_SPEC_CV):
63044 VM_TRACE(ZEND_JMP_NULL_SPEC_CV)
63045 ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63046 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CV)
63047 HYBRID_BREAK();
63048 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CV):
63049 VM_TRACE(ZEND_QM_ASSIGN_SPEC_CV)
63050 ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63051 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CV)
63052 HYBRID_BREAK();
63053 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CV):
63054 VM_TRACE(ZEND_YIELD_FROM_SPEC_CV)
63055 ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63056 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CV)
63057 HYBRID_BREAK();
63058 HYBRID_CASE(ZEND_STRLEN_SPEC_CV):
63059 VM_TRACE(ZEND_STRLEN_SPEC_CV)
63060 ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63061 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CV)
63062 HYBRID_BREAK();
63063 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CV):
63064 VM_TRACE(ZEND_TYPE_CHECK_SPEC_CV)
63065 ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63066 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CV)
63067 HYBRID_BREAK();
63068 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_CV):
63069 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_CV)
63070 ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63071 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_CV)
63072 HYBRID_BREAK();
63073 HYBRID_CASE(ZEND_BIND_STATIC_SPEC_CV):
63074 VM_TRACE(ZEND_BIND_STATIC_SPEC_CV)
63075 ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63076 VM_TRACE_OP_END(ZEND_BIND_STATIC_SPEC_CV)
63077 HYBRID_BREAK();
63078 HYBRID_CASE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV):
63079 VM_TRACE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
63080 ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63081 VM_TRACE_OP_END(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
63082 HYBRID_BREAK();
63083 HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
63084 VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63085 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63086 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63087 HYBRID_BREAK();
63088 HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
63089 VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63090 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63091 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63092 HYBRID_BREAK();
63093 HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED):
63094 VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
63095 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63096 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
63097 HYBRID_BREAK();
63098 HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED):
63099 VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
63100 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63101 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
63102 HYBRID_BREAK();
63103 HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
63104 VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63105 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63106 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63107 HYBRID_BREAK();
63108 HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
63109 VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63110 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63111 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63112 HYBRID_BREAK();
63113 HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED):
63114 VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
63115 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63116 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
63117 HYBRID_BREAK();
63118 HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED):
63119 VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
63120 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63121 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
63122 HYBRID_BREAK();
63123 HYBRID_CASE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV):
63124 VM_TRACE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
63125 ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63126 VM_TRACE_OP_END(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
63127 HYBRID_BREAK();
63128 HYBRID_CASE(ZEND_POST_INC_LONG_SPEC_CV):
63129 VM_TRACE(ZEND_POST_INC_LONG_SPEC_CV)
63130 ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63131 VM_TRACE_OP_END(ZEND_POST_INC_LONG_SPEC_CV)
63132 HYBRID_BREAK();
63133 HYBRID_CASE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV):
63134 VM_TRACE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
63135 ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63136 VM_TRACE_OP_END(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
63137 HYBRID_BREAK();
63138 HYBRID_CASE(ZEND_POST_DEC_LONG_SPEC_CV):
63139 VM_TRACE(ZEND_POST_DEC_LONG_SPEC_CV)
63140 ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63141 VM_TRACE_OP_END(ZEND_POST_DEC_LONG_SPEC_CV)
63142 HYBRID_BREAK();
63143 HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_CV):
63144 VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
63145 ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63146 VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
63147 HYBRID_BREAK();
63148 HYBRID_CASE(ZEND_DIV_SPEC_CV_CONST):
63149 VM_TRACE(ZEND_DIV_SPEC_CV_CONST)
63150 ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63151 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CONST)
63152 HYBRID_BREAK();
63153 HYBRID_CASE(ZEND_POW_SPEC_CV_CONST):
63154 VM_TRACE(ZEND_POW_SPEC_CV_CONST)
63155 ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63156 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CONST)
63157 HYBRID_BREAK();
63158 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CONST):
63159 VM_TRACE(ZEND_CONCAT_SPEC_CV_CONST)
63160 ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63161 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CONST)
63162 HYBRID_BREAK();
63163 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CONST):
63164 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
63165 ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63166 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
63167 HYBRID_BREAK();
63168 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST):
63169 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
63170 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63171 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
63172 HYBRID_BREAK();
63173 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST):
63174 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST)
63175 ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63176 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST)
63177 HYBRID_BREAK();
63178 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ):
63179 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
63180 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63181 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
63182 HYBRID_BREAK();
63183 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ):
63184 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
63185 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63186 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
63187 HYBRID_BREAK();
63188 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST):
63189 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
63190 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63191 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
63192 HYBRID_BREAK();
63193 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ):
63194 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
63195 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63196 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
63197 HYBRID_BREAK();
63198 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ):
63199 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
63200 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63201 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
63202 HYBRID_BREAK();
63203 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CONST):
63204 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CONST)
63205 ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63206 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CONST)
63207 HYBRID_BREAK();
63208 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CONST):
63209 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CONST)
63210 ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63211 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CONST)
63212 HYBRID_BREAK();
63213 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST):
63214 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
63215 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63216 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
63217 HYBRID_BREAK();
63218 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST):
63219 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
63220 ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63221 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
63222 HYBRID_BREAK();
63223 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CONST):
63224 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CONST)
63225 ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63226 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CONST)
63227 HYBRID_BREAK();
63228 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST):
63229 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
63230 ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63231 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
63232 HYBRID_BREAK();
63233 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CONST):
63234 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
63235 ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63236 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
63237 HYBRID_BREAK();
63238 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CONST):
63239 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
63240 ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63241 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
63242 HYBRID_BREAK();
63243 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CONST):
63244 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
63245 ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63246 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
63247 HYBRID_BREAK();
63248 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST):
63249 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
63250 ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63251 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
63252 HYBRID_BREAK();
63253 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST):
63254 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
63255 ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63256 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
63257 HYBRID_BREAK();
63258 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST):
63259 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
63260 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63261 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
63262 HYBRID_BREAK();
63263 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST):
63264 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
63265 ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63266 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
63267 HYBRID_BREAK();
63268 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST):
63269 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
63270 ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63271 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
63272 HYBRID_BREAK();
63273 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST):
63274 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
63275 ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63276 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
63277 HYBRID_BREAK();
63278 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST):
63279 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
63280 ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63281 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
63282 HYBRID_BREAK();
63283 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST):
63284 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
63285 ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63286 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
63287 HYBRID_BREAK();
63288 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST):
63289 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
63290 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63291 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
63292 HYBRID_BREAK();
63293 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST):
63294 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
63295 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63296 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
63297 HYBRID_BREAK();
63298 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST):
63299 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
63300 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63301 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
63302 HYBRID_BREAK();
63303 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP):
63304 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
63305 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63306 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
63307 HYBRID_BREAK();
63308 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR):
63309 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
63310 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63311 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
63312 HYBRID_BREAK();
63313 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV):
63314 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
63315 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63316 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
63317 HYBRID_BREAK();
63318 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST):
63319 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
63320 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63321 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
63322 HYBRID_BREAK();
63323 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP):
63324 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
63325 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63326 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
63327 HYBRID_BREAK();
63328 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR):
63329 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
63330 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63331 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
63332 HYBRID_BREAK();
63333 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV):
63334 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
63335 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63336 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
63337 HYBRID_BREAK();
63338 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED):
63339 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
63340 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63341 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
63342 HYBRID_BREAK();
63343 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED):
63344 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
63345 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63346 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
63347 HYBRID_BREAK();
63348 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR):
63349 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
63350 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63351 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
63352 HYBRID_BREAK();
63353 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV):
63354 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
63355 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63356 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
63357 HYBRID_BREAK();
63358 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CONST):
63359 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CONST)
63360 ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63361 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CONST)
63362 HYBRID_BREAK();
63363 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST):
63364 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
63365 ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63366 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
63367 HYBRID_BREAK();
63368 HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_CONST):
63369 VM_TRACE(ZEND_SEND_VAR_SPEC_CV_CONST)
63370 ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63371 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_CONST)
63372 HYBRID_BREAK();
63373 HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_CONST):
63374 VM_TRACE(ZEND_SEND_REF_SPEC_CV_CONST)
63375 ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63376 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_CONST)
63377 HYBRID_BREAK();
63378 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_CONST):
63379 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
63380 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63381 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
63382 HYBRID_BREAK();
63383 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST):
63384 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
63385 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63386 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
63387 HYBRID_BREAK();
63388 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CONST):
63389 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CONST)
63390 ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63391 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CONST)
63392 HYBRID_BREAK();
63393 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CONST):
63394 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CONST)
63395 ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63396 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CONST)
63397 HYBRID_BREAK();
63398 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CONST):
63399 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CONST)
63400 ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63401 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CONST)
63402 HYBRID_BREAK();
63403 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST):
63404 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
63405 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63406 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
63407 HYBRID_BREAK();
63408 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST):
63409 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
63410 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63411 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
63412 HYBRID_BREAK();
63413 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST):
63414 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
63415 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63416 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
63417 HYBRID_BREAK();
63418 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_CONST):
63419 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_CONST)
63420 ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63421 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_CONST)
63422 HYBRID_BREAK();
63423 HYBRID_CASE(ZEND_YIELD_SPEC_CV_CONST):
63424 VM_TRACE(ZEND_YIELD_SPEC_CV_CONST)
63425 ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63426 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CONST)
63427 HYBRID_BREAK();
63428 HYBRID_CASE(ZEND_BIND_GLOBAL_SPEC_CV_CONST):
63429 VM_TRACE(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
63430 ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63431 VM_TRACE_OP_END(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
63432 HYBRID_BREAK();
63433 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CV_CONST):
63434 VM_TRACE(ZEND_IN_ARRAY_SPEC_CV_CONST)
63435 ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63436 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CV_CONST)
63437 HYBRID_BREAK();
63438 HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST):
63439 VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63440 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63441 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63442 HYBRID_BREAK();
63443 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST):
63444 VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63445 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63446 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63447 HYBRID_BREAK();
63448 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST):
63449 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
63450 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63451 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
63452 HYBRID_BREAK();
63453 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV):
63454 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
63455 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63456 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
63457 HYBRID_BREAK();
63458 HYBRID_CASE(ZEND_DIV_SPEC_CV_TMPVAR):
63459 VM_TRACE(ZEND_DIV_SPEC_CV_TMPVAR)
63460 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63461 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_TMPVAR)
63462 HYBRID_BREAK();
63463 HYBRID_CASE(ZEND_POW_SPEC_CV_TMPVAR):
63464 VM_TRACE(ZEND_POW_SPEC_CV_TMPVAR)
63465 ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63466 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_TMPVAR)
63467 HYBRID_BREAK();
63468 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_TMPVAR):
63469 VM_TRACE(ZEND_CONCAT_SPEC_CV_TMPVAR)
63470 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63471 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_TMPVAR)
63472 HYBRID_BREAK();
63473 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR):
63474 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
63475 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63476 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
63477 HYBRID_BREAK();
63478 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ):
63479 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63480 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63481 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63482 HYBRID_BREAK();
63483 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
63484 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63485 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63486 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63487 HYBRID_BREAK();
63488 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR):
63489 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
63490 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63491 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
63492 HYBRID_BREAK();
63493 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ):
63494 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63495 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63496 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63497 HYBRID_BREAK();
63498 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
63499 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63500 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63501 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63502 HYBRID_BREAK();
63503 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_TMPVAR):
63504 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
63505 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63506 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
63507 HYBRID_BREAK();
63508 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR):
63509 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
63510 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63511 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
63512 HYBRID_BREAK();
63513 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR):
63514 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
63515 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63516 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
63517 HYBRID_BREAK();
63518 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR):
63519 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
63520 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63521 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
63522 HYBRID_BREAK();
63523 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR):
63524 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
63525 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63526 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
63527 HYBRID_BREAK();
63528 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR):
63529 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
63530 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63531 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
63532 HYBRID_BREAK();
63533 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR):
63534 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
63535 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63536 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
63537 HYBRID_BREAK();
63538 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR):
63539 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
63540 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63541 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
63542 HYBRID_BREAK();
63543 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR):
63544 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
63545 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63546 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
63547 HYBRID_BREAK();
63548 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR):
63549 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
63550 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63551 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
63552 HYBRID_BREAK();
63553 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR):
63554 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
63555 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63556 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
63557 HYBRID_BREAK();
63558 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR):
63559 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
63560 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63561 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
63562 HYBRID_BREAK();
63563 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR):
63564 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
63565 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63566 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
63567 HYBRID_BREAK();
63568 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR):
63569 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
63570 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63571 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
63572 HYBRID_BREAK();
63573 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR):
63574 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
63575 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63576 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
63577 HYBRID_BREAK();
63578 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR):
63579 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
63580 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63581 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
63582 HYBRID_BREAK();
63583 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR):
63584 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
63585 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63586 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
63587 HYBRID_BREAK();
63588 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR):
63589 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
63590 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63591 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
63592 HYBRID_BREAK();
63593 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR):
63594 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
63595 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63596 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
63597 HYBRID_BREAK();
63598 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST):
63599 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
63600 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63601 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
63602 HYBRID_BREAK();
63603 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP):
63604 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
63605 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63606 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
63607 HYBRID_BREAK();
63608 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR):
63609 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
63610 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63611 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
63612 HYBRID_BREAK();
63613 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV):
63614 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
63615 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63616 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
63617 HYBRID_BREAK();
63618 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST):
63619 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
63620 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63621 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
63622 HYBRID_BREAK();
63623 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP):
63624 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
63625 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63626 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
63627 HYBRID_BREAK();
63628 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR):
63629 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
63630 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63631 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
63632 HYBRID_BREAK();
63633 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV):
63634 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
63635 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63636 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
63637 HYBRID_BREAK();
63638 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR):
63639 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
63640 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63641 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
63642 HYBRID_BREAK();
63643 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV):
63644 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
63645 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63646 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
63647 HYBRID_BREAK();
63648 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR):
63649 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
63650 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63651 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
63652 HYBRID_BREAK();
63653 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR):
63654 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
63655 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63656 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
63657 HYBRID_BREAK();
63658 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR):
63659 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
63660 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63661 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
63662 HYBRID_BREAK();
63663 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR):
63664 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
63665 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63666 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
63667 HYBRID_BREAK();
63668 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR):
63669 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
63670 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63671 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
63672 HYBRID_BREAK();
63673 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR):
63674 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
63675 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63676 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
63677 HYBRID_BREAK();
63678 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR):
63679 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
63680 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63681 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
63682 HYBRID_BREAK();
63683 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR):
63684 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
63685 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63686 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
63687 HYBRID_BREAK();
63688 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR):
63689 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
63690 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63691 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
63692 HYBRID_BREAK();
63693 HYBRID_CASE(ZEND_YIELD_SPEC_CV_TMPVAR):
63694 VM_TRACE(ZEND_YIELD_SPEC_CV_TMPVAR)
63695 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63696 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_TMPVAR)
63697 HYBRID_BREAK();
63698 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_TMP):
63699 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
63700 ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63701 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
63702 HYBRID_BREAK();
63703 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP):
63704 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
63705 ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63706 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
63707 HYBRID_BREAK();
63708 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED):
63709 VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
63710 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63711 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
63712 HYBRID_BREAK();
63713 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED):
63714 VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
63715 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63716 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
63717 HYBRID_BREAK();
63718 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_VAR):
63719 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
63720 ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63721 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
63722 HYBRID_BREAK();
63723 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR):
63724 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
63725 ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63726 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
63727 HYBRID_BREAK();
63728 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED):
63729 VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
63730 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63731 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
63732 HYBRID_BREAK();
63733 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED):
63734 VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
63735 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63736 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
63737 HYBRID_BREAK();
63738 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_VAR):
63739 VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_VAR)
63740 ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63741 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_VAR)
63742 HYBRID_BREAK();
63743 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_VAR):
63744 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_VAR)
63745 ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63746 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_VAR)
63747 HYBRID_BREAK();
63748 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED):
63749 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
63750 ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63751 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
63752 HYBRID_BREAK();
63753 HYBRID_CASE(ZEND_FETCH_R_SPEC_CV_UNUSED):
63754 VM_TRACE(ZEND_FETCH_R_SPEC_CV_UNUSED)
63755 ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63756 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CV_UNUSED)
63757 HYBRID_BREAK();
63758 HYBRID_CASE(ZEND_FETCH_W_SPEC_CV_UNUSED):
63759 VM_TRACE(ZEND_FETCH_W_SPEC_CV_UNUSED)
63760 ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63761 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CV_UNUSED)
63762 HYBRID_BREAK();
63763 HYBRID_CASE(ZEND_FETCH_RW_SPEC_CV_UNUSED):
63764 VM_TRACE(ZEND_FETCH_RW_SPEC_CV_UNUSED)
63765 ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63766 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CV_UNUSED)
63767 HYBRID_BREAK();
63768 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED):
63769 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
63770 ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63771 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
63772 HYBRID_BREAK();
63773 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED):
63774 VM_TRACE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
63775 ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63776 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
63777 HYBRID_BREAK();
63778 HYBRID_CASE(ZEND_FETCH_IS_SPEC_CV_UNUSED):
63779 VM_TRACE(ZEND_FETCH_IS_SPEC_CV_UNUSED)
63780 ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63781 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CV_UNUSED)
63782 HYBRID_BREAK();
63783 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED):
63784 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
63785 ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63786 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
63787 HYBRID_BREAK();
63788 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED):
63789 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
63790 ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63791 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
63792 HYBRID_BREAK();
63793 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED):
63794 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
63795 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63796 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
63797 HYBRID_BREAK();
63798 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST):
63799 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
63800 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63801 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
63802 HYBRID_BREAK();
63803 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP):
63804 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
63805 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63806 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
63807 HYBRID_BREAK();
63808 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR):
63809 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
63810 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63811 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
63812 HYBRID_BREAK();
63813 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV):
63814 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
63815 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63816 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
63817 HYBRID_BREAK();
63818 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED):
63819 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
63820 ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63821 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
63822 HYBRID_BREAK();
63823 HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_UNUSED):
63824 VM_TRACE(ZEND_SEND_VAR_SPEC_CV_UNUSED)
63825 ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63826 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_UNUSED)
63827 HYBRID_BREAK();
63828 HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_UNUSED):
63829 VM_TRACE(ZEND_SEND_REF_SPEC_CV_UNUSED)
63830 ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63831 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_UNUSED)
63832 HYBRID_BREAK();
63833 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED):
63834 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
63835 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63836 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
63837 HYBRID_BREAK();
63838 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK):
63839 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
63840 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63841 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
63842 HYBRID_BREAK();
63843 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED):
63844 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
63845 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63846 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
63847 HYBRID_BREAK();
63848 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED):
63849 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
63850 ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63851 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
63852 HYBRID_BREAK();
63853 HYBRID_CASE(ZEND_UNSET_CV_SPEC_CV_UNUSED):
63854 VM_TRACE(ZEND_UNSET_CV_SPEC_CV_UNUSED)
63855 ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63856 VM_TRACE_OP_END(ZEND_UNSET_CV_SPEC_CV_UNUSED)
63857 HYBRID_BREAK();
63858 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CV_UNUSED):
63859 VM_TRACE(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
63860 ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63861 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
63862 HYBRID_BREAK();
63863 HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET):
63864 VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
63865 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63866 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
63867 HYBRID_BREAK();
63868 HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY):
63869 VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
63870 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63871 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
63872 HYBRID_BREAK();
63873 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED):
63874 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
63875 ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63876 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
63877 HYBRID_BREAK();
63878 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_UNUSED):
63879 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
63880 ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63881 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
63882 HYBRID_BREAK();
63883 HYBRID_CASE(ZEND_YIELD_SPEC_CV_UNUSED):
63884 VM_TRACE(ZEND_YIELD_SPEC_CV_UNUSED)
63885 ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63886 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_UNUSED)
63887 HYBRID_BREAK();
63888 HYBRID_CASE(ZEND_CHECK_VAR_SPEC_CV_UNUSED):
63889 VM_TRACE(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
63890 ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63891 VM_TRACE_OP_END(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
63892 HYBRID_BREAK();
63893 HYBRID_CASE(ZEND_MAKE_REF_SPEC_CV_UNUSED):
63894 VM_TRACE(ZEND_MAKE_REF_SPEC_CV_UNUSED)
63895 ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63896 VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_CV_UNUSED)
63897 HYBRID_BREAK();
63898 HYBRID_CASE(ZEND_COUNT_SPEC_CV_UNUSED):
63899 VM_TRACE(ZEND_COUNT_SPEC_CV_UNUSED)
63900 ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63901 VM_TRACE_OP_END(ZEND_COUNT_SPEC_CV_UNUSED)
63902 HYBRID_BREAK();
63903 HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED):
63904 VM_TRACE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
63905 ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63906 VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
63907 HYBRID_BREAK();
63908 HYBRID_CASE(ZEND_GET_CLASS_SPEC_CV_UNUSED):
63909 VM_TRACE(ZEND_GET_CLASS_SPEC_CV_UNUSED)
63910 ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63911 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CV_UNUSED)
63912 HYBRID_BREAK();
63913 HYBRID_CASE(ZEND_GET_TYPE_SPEC_CV_UNUSED):
63914 VM_TRACE(ZEND_GET_TYPE_SPEC_CV_UNUSED)
63915 ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63916 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CV_UNUSED)
63917 HYBRID_BREAK();
63918 HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED):
63919 VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
63920 ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63921 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
63922 HYBRID_BREAK();
63923 HYBRID_CASE(ZEND_DIV_SPEC_CV_CV):
63924 VM_TRACE(ZEND_DIV_SPEC_CV_CV)
63925 ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63926 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CV)
63927 HYBRID_BREAK();
63928 HYBRID_CASE(ZEND_POW_SPEC_CV_CV):
63929 VM_TRACE(ZEND_POW_SPEC_CV_CV)
63930 ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63931 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CV)
63932 HYBRID_BREAK();
63933 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CV):
63934 VM_TRACE(ZEND_CONCAT_SPEC_CV_CV)
63935 ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63936 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CV)
63937 HYBRID_BREAK();
63938 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CV):
63939 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CV)
63940 ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63941 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CV)
63942 HYBRID_BREAK();
63943 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV):
63944 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
63945 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63946 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
63947 HYBRID_BREAK();
63948 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV):
63949 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV)
63950 ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63951 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV)
63952 HYBRID_BREAK();
63953 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ):
63954 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
63955 ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63956 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
63957 HYBRID_BREAK();
63958 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ):
63959 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
63960 ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63961 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
63962 HYBRID_BREAK();
63963 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV):
63964 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
63965 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63966 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
63967 HYBRID_BREAK();
63968 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ):
63969 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
63970 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63971 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
63972 HYBRID_BREAK();
63973 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ):
63974 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
63975 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63976 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
63977 HYBRID_BREAK();
63978 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CV):
63979 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CV)
63980 ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63981 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CV)
63982 HYBRID_BREAK();
63983 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CV):
63984 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CV)
63985 ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63986 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CV)
63987 HYBRID_BREAK();
63988 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV):
63989 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
63990 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63991 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
63992 HYBRID_BREAK();
63993 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV):
63994 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
63995 ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63996 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
63997 HYBRID_BREAK();
63998 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CV):
63999 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CV)
64000 ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64001 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CV)
64002 HYBRID_BREAK();
64003 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CV):
64004 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
64005 ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64006 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
64007 HYBRID_BREAK();
64008 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CV):
64009 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CV)
64010 ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64011 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CV)
64012 HYBRID_BREAK();
64013 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CV):
64014 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CV)
64015 ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64016 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CV)
64017 HYBRID_BREAK();
64018 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CV):
64019 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CV)
64020 ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64021 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CV)
64022 HYBRID_BREAK();
64023 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CV):
64024 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
64025 ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64026 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
64027 HYBRID_BREAK();
64028 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CV):
64029 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
64030 ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64031 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
64032 HYBRID_BREAK();
64033 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV):
64034 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
64035 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64036 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
64037 HYBRID_BREAK();
64038 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV):
64039 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
64040 ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64041 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
64042 HYBRID_BREAK();
64043 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CV):
64044 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
64045 ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64046 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
64047 HYBRID_BREAK();
64048 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CV):
64049 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
64050 ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64051 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
64052 HYBRID_BREAK();
64053 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV):
64054 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
64055 ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64056 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
64057 HYBRID_BREAK();
64058 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV):
64059 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
64060 ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64061 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
64062 HYBRID_BREAK();
64063 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV):
64064 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
64065 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64066 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
64067 HYBRID_BREAK();
64068 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV):
64069 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
64070 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64071 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
64072 HYBRID_BREAK();
64073 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST):
64074 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
64075 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64076 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
64077 HYBRID_BREAK();
64078 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP):
64079 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
64080 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64081 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
64082 HYBRID_BREAK();
64083 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR):
64084 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
64085 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64086 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
64087 HYBRID_BREAK();
64088 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV):
64089 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
64090 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64091 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
64092 HYBRID_BREAK();
64093 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST):
64094 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
64095 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64096 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
64097 HYBRID_BREAK();
64098 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP):
64099 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
64100 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64101 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
64102 HYBRID_BREAK();
64103 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR):
64104 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
64105 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64106 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
64107 HYBRID_BREAK();
64108 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV):
64109 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
64110 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64111 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
64112 HYBRID_BREAK();
64113 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED):
64114 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
64115 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64116 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
64117 HYBRID_BREAK();
64118 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED):
64119 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
64120 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64121 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
64122 HYBRID_BREAK();
64123 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_CV):
64124 VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_CV)
64125 ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64126 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_CV)
64127 HYBRID_BREAK();
64128 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR):
64129 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
64130 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64131 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
64132 HYBRID_BREAK();
64133 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV):
64134 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
64135 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64136 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
64137 HYBRID_BREAK();
64138 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CV):
64139 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CV)
64140 ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64141 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CV)
64142 HYBRID_BREAK();
64143 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV):
64144 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
64145 ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64146 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
64147 HYBRID_BREAK();
64148 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV):
64149 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
64150 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64151 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
64152 HYBRID_BREAK();
64153 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CV):
64154 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CV)
64155 ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64156 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CV)
64157 HYBRID_BREAK();
64158 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CV):
64159 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CV)
64160 ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64161 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CV)
64162 HYBRID_BREAK();
64163 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CV):
64164 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CV)
64165 ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64166 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CV)
64167 HYBRID_BREAK();
64168 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV):
64169 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
64170 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64171 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
64172 HYBRID_BREAK();
64173 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV):
64174 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
64175 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64176 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
64177 HYBRID_BREAK();
64178 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV):
64179 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
64180 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64181 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
64182 HYBRID_BREAK();
64183 HYBRID_CASE(ZEND_YIELD_SPEC_CV_CV):
64184 VM_TRACE(ZEND_YIELD_SPEC_CV_CV)
64185 ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64186 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CV)
64187 HYBRID_BREAK();
64188 HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV):
64189 VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
64190 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64191 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
64192 HYBRID_BREAK();
64193 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV):
64194 VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
64195 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64196 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
64197 HYBRID_BREAK();
64198 HYBRID_CASE(HYBRID_HALT):
64199#ifdef ZEND_VM_FP_GLOBAL_REG
64200 execute_data = vm_stack_data.orig_execute_data;
64201#endif
64202#ifdef ZEND_VM_IP_GLOBAL_REG
64203 opline = vm_stack_data.orig_opline;
64204#endif
64205 return;
64206 HYBRID_DEFAULT:
64207 VM_TRACE(ZEND_NULL)
64208 ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64209 VM_TRACE_OP_END(ZEND_NULL)
64210 HYBRID_BREAK(); /* Never reached */
64211#else
64212#ifdef ZEND_VM_FP_GLOBAL_REG
64213 execute_data = vm_stack_data.orig_execute_data;
64214# ifdef ZEND_VM_IP_GLOBAL_REG
64215 opline = vm_stack_data.orig_opline;
64216# endif
64217 return;
64218#else
64219 if (EXPECTED(ret > 0)) {
64220 execute_data = EG(current_execute_data);
64221 ZEND_VM_LOOP_INTERRUPT_CHECK();
64222 } else {
64223# ifdef ZEND_VM_IP_GLOBAL_REG
64224 opline = vm_stack_data.orig_opline;
64225# endif
64226 return;
64227 }
64228#endif
64229#endif
64230 }
64231
64232 }
64233 zend_error_noreturn(E_CORE_ERROR, "Arrived at end of main loop which shouldn't happen");
64234}
64235#if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
64236# pragma GCC pop_options
64237#endif
64238
64239ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value)
64240{
64241 zend_execute_data *execute_data;
64242 void *object_or_called_scope;
64243 uint32_t call_info;
64244
64245 if (EG(exception) != NULL) {
64246 return;
64247 }
64248
64249 object_or_called_scope = zend_get_this_object(EG(current_execute_data));
64250 if (EXPECTED(!object_or_called_scope)) {
64251 object_or_called_scope = zend_get_called_scope(EG(current_execute_data));
64252 call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE;
64253 } else {
64254 call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE | ZEND_CALL_HAS_THIS;
64255 }
64256 execute_data = zend_vm_stack_push_call_frame(call_info,
64257 (zend_function*)op_array, 0, object_or_called_scope);
64258 if (EG(current_execute_data)) {
64259 execute_data->symbol_table = zend_rebuild_symbol_table();
64260 } else {
64261 execute_data->symbol_table = &EG(symbol_table);
64262 }
64263 EX(prev_execute_data) = EG(current_execute_data);
64264 i_init_code_execute_data(execute_data, op_array, return_value);
64265 ZEND_OBSERVER_FCALL_BEGIN(execute_data);
64266 zend_execute_ex(execute_data);
64267 /* Observer end handlers are called from ZEND_RETURN */
64268 zend_vm_stack_free_call_frame(execute_data);
64269}
64270
64271
64272void zend_vm_init(void)
64273{
64274 static const void * const labels[] = {
64275 ZEND_NOP_SPEC_HANDLER,
64276 ZEND_ADD_SPEC_CONST_CONST_HANDLER,
64277 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64278 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64279 ZEND_NULL_HANDLER,
64280 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64281 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64282 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64283 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64284 ZEND_NULL_HANDLER,
64285 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64286 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64287 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64288 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64289 ZEND_NULL_HANDLER,
64290 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64291 ZEND_NULL_HANDLER,
64292 ZEND_NULL_HANDLER,
64293 ZEND_NULL_HANDLER,
64294 ZEND_NULL_HANDLER,
64295 ZEND_NULL_HANDLER,
64296 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64297 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64298 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64299 ZEND_NULL_HANDLER,
64300 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64301 ZEND_SUB_SPEC_CONST_CONST_HANDLER,
64302 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64303 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64304 ZEND_NULL_HANDLER,
64305 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64306 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64307 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64308 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64309 ZEND_NULL_HANDLER,
64310 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64311 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64312 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64313 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64314 ZEND_NULL_HANDLER,
64315 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64316 ZEND_NULL_HANDLER,
64317 ZEND_NULL_HANDLER,
64318 ZEND_NULL_HANDLER,
64319 ZEND_NULL_HANDLER,
64320 ZEND_NULL_HANDLER,
64321 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64322 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64323 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64324 ZEND_NULL_HANDLER,
64325 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64326 ZEND_MUL_SPEC_CONST_CONST_HANDLER,
64327 ZEND_NULL_HANDLER,
64328 ZEND_NULL_HANDLER,
64329 ZEND_NULL_HANDLER,
64330 ZEND_NULL_HANDLER,
64331 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64332 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64333 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64334 ZEND_NULL_HANDLER,
64335 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64336 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64337 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64338 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64339 ZEND_NULL_HANDLER,
64340 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64341 ZEND_NULL_HANDLER,
64342 ZEND_NULL_HANDLER,
64343 ZEND_NULL_HANDLER,
64344 ZEND_NULL_HANDLER,
64345 ZEND_NULL_HANDLER,
64346 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64347 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64348 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64349 ZEND_NULL_HANDLER,
64350 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64351 ZEND_DIV_SPEC_CONST_CONST_HANDLER,
64352 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
64353 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
64354 ZEND_NULL_HANDLER,
64355 ZEND_DIV_SPEC_CONST_CV_HANDLER,
64356 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
64357 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64358 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64359 ZEND_NULL_HANDLER,
64360 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
64361 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
64362 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64363 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64364 ZEND_NULL_HANDLER,
64365 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
64366 ZEND_NULL_HANDLER,
64367 ZEND_NULL_HANDLER,
64368 ZEND_NULL_HANDLER,
64369 ZEND_NULL_HANDLER,
64370 ZEND_NULL_HANDLER,
64371 ZEND_DIV_SPEC_CV_CONST_HANDLER,
64372 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
64373 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
64374 ZEND_NULL_HANDLER,
64375 ZEND_DIV_SPEC_CV_CV_HANDLER,
64376 ZEND_MOD_SPEC_CONST_CONST_HANDLER,
64377 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64378 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64379 ZEND_NULL_HANDLER,
64380 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64381 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64382 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64383 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64384 ZEND_NULL_HANDLER,
64385 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64386 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64387 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64388 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64389 ZEND_NULL_HANDLER,
64390 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64391 ZEND_NULL_HANDLER,
64392 ZEND_NULL_HANDLER,
64393 ZEND_NULL_HANDLER,
64394 ZEND_NULL_HANDLER,
64395 ZEND_NULL_HANDLER,
64396 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64397 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64398 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64399 ZEND_NULL_HANDLER,
64400 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64401 ZEND_SL_SPEC_CONST_CONST_HANDLER,
64402 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64403 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64404 ZEND_NULL_HANDLER,
64405 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64406 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64407 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64408 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64409 ZEND_NULL_HANDLER,
64410 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64411 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64412 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64413 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64414 ZEND_NULL_HANDLER,
64415 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64416 ZEND_NULL_HANDLER,
64417 ZEND_NULL_HANDLER,
64418 ZEND_NULL_HANDLER,
64419 ZEND_NULL_HANDLER,
64420 ZEND_NULL_HANDLER,
64421 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64422 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64423 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64424 ZEND_NULL_HANDLER,
64425 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64426 ZEND_SR_SPEC_CONST_CONST_HANDLER,
64427 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64428 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64429 ZEND_NULL_HANDLER,
64430 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64431 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64432 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64433 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64434 ZEND_NULL_HANDLER,
64435 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64436 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64437 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64438 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64439 ZEND_NULL_HANDLER,
64440 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64441 ZEND_NULL_HANDLER,
64442 ZEND_NULL_HANDLER,
64443 ZEND_NULL_HANDLER,
64444 ZEND_NULL_HANDLER,
64445 ZEND_NULL_HANDLER,
64446 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64447 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64448 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64449 ZEND_NULL_HANDLER,
64450 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64451 ZEND_NULL_HANDLER,
64452 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64453 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64454 ZEND_NULL_HANDLER,
64455 ZEND_CONCAT_SPEC_CONST_CV_HANDLER,
64456 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64457 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64458 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64459 ZEND_NULL_HANDLER,
64460 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64461 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64462 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64463 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64464 ZEND_NULL_HANDLER,
64465 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64466 ZEND_NULL_HANDLER,
64467 ZEND_NULL_HANDLER,
64468 ZEND_NULL_HANDLER,
64469 ZEND_NULL_HANDLER,
64470 ZEND_NULL_HANDLER,
64471 ZEND_CONCAT_SPEC_CV_CONST_HANDLER,
64472 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64473 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64474 ZEND_NULL_HANDLER,
64475 ZEND_CONCAT_SPEC_CV_CV_HANDLER,
64476 ZEND_BW_OR_SPEC_CONST_CONST_HANDLER,
64477 ZEND_NULL_HANDLER,
64478 ZEND_NULL_HANDLER,
64479 ZEND_NULL_HANDLER,
64480 ZEND_NULL_HANDLER,
64481 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64482 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64483 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64484 ZEND_NULL_HANDLER,
64485 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64486 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64487 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64488 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64489 ZEND_NULL_HANDLER,
64490 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64491 ZEND_NULL_HANDLER,
64492 ZEND_NULL_HANDLER,
64493 ZEND_NULL_HANDLER,
64494 ZEND_NULL_HANDLER,
64495 ZEND_NULL_HANDLER,
64496 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64497 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64498 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64499 ZEND_NULL_HANDLER,
64500 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64501 ZEND_BW_AND_SPEC_CONST_CONST_HANDLER,
64502 ZEND_NULL_HANDLER,
64503 ZEND_NULL_HANDLER,
64504 ZEND_NULL_HANDLER,
64505 ZEND_NULL_HANDLER,
64506 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64507 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64508 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64509 ZEND_NULL_HANDLER,
64510 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64511 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64512 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64513 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64514 ZEND_NULL_HANDLER,
64515 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64516 ZEND_NULL_HANDLER,
64517 ZEND_NULL_HANDLER,
64518 ZEND_NULL_HANDLER,
64519 ZEND_NULL_HANDLER,
64520 ZEND_NULL_HANDLER,
64521 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64522 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64523 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64524 ZEND_NULL_HANDLER,
64525 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64526 ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER,
64527 ZEND_NULL_HANDLER,
64528 ZEND_NULL_HANDLER,
64529 ZEND_NULL_HANDLER,
64530 ZEND_NULL_HANDLER,
64531 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64532 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64533 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64534 ZEND_NULL_HANDLER,
64535 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64536 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64537 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64538 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64539 ZEND_NULL_HANDLER,
64540 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64541 ZEND_NULL_HANDLER,
64542 ZEND_NULL_HANDLER,
64543 ZEND_NULL_HANDLER,
64544 ZEND_NULL_HANDLER,
64545 ZEND_NULL_HANDLER,
64546 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64547 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64548 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64549 ZEND_NULL_HANDLER,
64550 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64551 ZEND_POW_SPEC_CONST_CONST_HANDLER,
64552 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
64553 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
64554 ZEND_NULL_HANDLER,
64555 ZEND_POW_SPEC_CONST_CV_HANDLER,
64556 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
64557 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64558 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64559 ZEND_NULL_HANDLER,
64560 ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
64561 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
64562 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64563 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64564 ZEND_NULL_HANDLER,
64565 ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
64566 ZEND_NULL_HANDLER,
64567 ZEND_NULL_HANDLER,
64568 ZEND_NULL_HANDLER,
64569 ZEND_NULL_HANDLER,
64570 ZEND_NULL_HANDLER,
64571 ZEND_POW_SPEC_CV_CONST_HANDLER,
64572 ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
64573 ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
64574 ZEND_NULL_HANDLER,
64575 ZEND_POW_SPEC_CV_CV_HANDLER,
64576 ZEND_BW_NOT_SPEC_CONST_HANDLER,
64577 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64578 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64579 ZEND_NULL_HANDLER,
64580 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64581 ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
64582 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
64583 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
64584 ZEND_NULL_HANDLER,
64585 ZEND_BOOL_NOT_SPEC_CV_HANDLER,
64586 ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER,
64587 ZEND_NULL_HANDLER,
64588 ZEND_NULL_HANDLER,
64589 ZEND_NULL_HANDLER,
64590 ZEND_NULL_HANDLER,
64591 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
64592 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64593 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64594 ZEND_NULL_HANDLER,
64595 ZEND_NULL_HANDLER,
64596 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
64597 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64598 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64599 ZEND_NULL_HANDLER,
64600 ZEND_NULL_HANDLER,
64601 ZEND_NULL_HANDLER,
64602 ZEND_NULL_HANDLER,
64603 ZEND_NULL_HANDLER,
64604 ZEND_NULL_HANDLER,
64605 ZEND_NULL_HANDLER,
64606 ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER,
64607 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
64608 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
64609 ZEND_NULL_HANDLER,
64610 ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER,
64611 ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER,
64612 ZEND_NULL_HANDLER,
64613 ZEND_NULL_HANDLER,
64614 ZEND_NULL_HANDLER,
64615 ZEND_NULL_HANDLER,
64616 ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER,
64617 ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER,
64618 ZEND_NULL_HANDLER,
64619 ZEND_NULL_HANDLER,
64620 ZEND_NULL_HANDLER,
64621 ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER,
64622 ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER,
64623 ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER,
64624 ZEND_NULL_HANDLER,
64625 ZEND_NULL_HANDLER,
64626 ZEND_NULL_HANDLER,
64627 ZEND_NULL_HANDLER,
64628 ZEND_NULL_HANDLER,
64629 ZEND_NULL_HANDLER,
64630 ZEND_NULL_HANDLER,
64631 ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER,
64632 ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER,
64633 ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER,
64634 ZEND_NULL_HANDLER,
64635 ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER,
64636 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER,
64637 ZEND_NULL_HANDLER,
64638 ZEND_NULL_HANDLER,
64639 ZEND_NULL_HANDLER,
64640 ZEND_NULL_HANDLER,
64641 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER,
64642 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER,
64643 ZEND_NULL_HANDLER,
64644 ZEND_NULL_HANDLER,
64645 ZEND_NULL_HANDLER,
64646 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER,
64647 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER,
64648 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER,
64649 ZEND_NULL_HANDLER,
64650 ZEND_NULL_HANDLER,
64651 ZEND_NULL_HANDLER,
64652 ZEND_NULL_HANDLER,
64653 ZEND_NULL_HANDLER,
64654 ZEND_NULL_HANDLER,
64655 ZEND_NULL_HANDLER,
64656 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER,
64657 ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER,
64658 ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER,
64659 ZEND_NULL_HANDLER,
64660 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER,
64661 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64662 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64663 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64664 ZEND_NULL_HANDLER,
64665 ZEND_NULL_HANDLER,
64666 ZEND_NULL_HANDLER,
64667 ZEND_NULL_HANDLER,
64668 ZEND_NULL_HANDLER,
64669 ZEND_NULL_HANDLER,
64670 ZEND_NULL_HANDLER,
64671 ZEND_NULL_HANDLER,
64672 ZEND_NULL_HANDLER,
64673 ZEND_NULL_HANDLER,
64674 ZEND_NULL_HANDLER,
64675 ZEND_NULL_HANDLER,
64676 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64677 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64678 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64679 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64680 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64681 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64682 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64683 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64684 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64685 ZEND_NULL_HANDLER,
64686 ZEND_NULL_HANDLER,
64687 ZEND_NULL_HANDLER,
64688 ZEND_NULL_HANDLER,
64689 ZEND_NULL_HANDLER,
64690 ZEND_NULL_HANDLER,
64691 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64692 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64693 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64694 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64695 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64696 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64697 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64698 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64699 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64700 ZEND_NULL_HANDLER,
64701 ZEND_NULL_HANDLER,
64702 ZEND_NULL_HANDLER,
64703 ZEND_NULL_HANDLER,
64704 ZEND_NULL_HANDLER,
64705 ZEND_NULL_HANDLER,
64706 ZEND_NULL_HANDLER,
64707 ZEND_NULL_HANDLER,
64708 ZEND_NULL_HANDLER,
64709 ZEND_NULL_HANDLER,
64710 ZEND_NULL_HANDLER,
64711 ZEND_NULL_HANDLER,
64712 ZEND_NULL_HANDLER,
64713 ZEND_NULL_HANDLER,
64714 ZEND_NULL_HANDLER,
64715 ZEND_NULL_HANDLER,
64716 ZEND_NULL_HANDLER,
64717 ZEND_NULL_HANDLER,
64718 ZEND_NULL_HANDLER,
64719 ZEND_NULL_HANDLER,
64720 ZEND_NULL_HANDLER,
64721 ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER,
64722 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
64723 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
64724 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64725 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64726 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64727 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64728 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64729 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64730 ZEND_NULL_HANDLER,
64731 ZEND_NULL_HANDLER,
64732 ZEND_NULL_HANDLER,
64733 ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER,
64734 ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
64735 ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
64736 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64737 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64738 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64739 ZEND_NULL_HANDLER,
64740 ZEND_NULL_HANDLER,
64741 ZEND_NULL_HANDLER,
64742 ZEND_NULL_HANDLER,
64743 ZEND_NULL_HANDLER,
64744 ZEND_NULL_HANDLER,
64745 ZEND_NULL_HANDLER,
64746 ZEND_NULL_HANDLER,
64747 ZEND_NULL_HANDLER,
64748 ZEND_NULL_HANDLER,
64749 ZEND_NULL_HANDLER,
64750 ZEND_NULL_HANDLER,
64751 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64752 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64753 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64754 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64755 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64756 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64757 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64758 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64759 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64760 ZEND_NULL_HANDLER,
64761 ZEND_NULL_HANDLER,
64762 ZEND_NULL_HANDLER,
64763 ZEND_NULL_HANDLER,
64764 ZEND_NULL_HANDLER,
64765 ZEND_NULL_HANDLER,
64766 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64767 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64768 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64769 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64770 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64771 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64772 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64773 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64774 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64775 ZEND_NULL_HANDLER,
64776 ZEND_NULL_HANDLER,
64777 ZEND_NULL_HANDLER,
64778 ZEND_NULL_HANDLER,
64779 ZEND_NULL_HANDLER,
64780 ZEND_NULL_HANDLER,
64781 ZEND_NULL_HANDLER,
64782 ZEND_NULL_HANDLER,
64783 ZEND_NULL_HANDLER,
64784 ZEND_NULL_HANDLER,
64785 ZEND_NULL_HANDLER,
64786 ZEND_NULL_HANDLER,
64787 ZEND_NULL_HANDLER,
64788 ZEND_NULL_HANDLER,
64789 ZEND_NULL_HANDLER,
64790 ZEND_NULL_HANDLER,
64791 ZEND_NULL_HANDLER,
64792 ZEND_NULL_HANDLER,
64793 ZEND_NULL_HANDLER,
64794 ZEND_NULL_HANDLER,
64795 ZEND_NULL_HANDLER,
64796 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER,
64797 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
64798 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
64799 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64800 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64801 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64802 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64803 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64804 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64805 ZEND_NULL_HANDLER,
64806 ZEND_NULL_HANDLER,
64807 ZEND_NULL_HANDLER,
64808 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER,
64809 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
64810 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
64811 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64812 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64813 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64814 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64815 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64816 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64817 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64818 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64819 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64820 ZEND_NULL_HANDLER,
64821 ZEND_NULL_HANDLER,
64822 ZEND_NULL_HANDLER,
64823 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64824 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64825 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64826 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64827 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64828 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64829 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64830 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64831 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64832 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64833 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64834 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64835 ZEND_NULL_HANDLER,
64836 ZEND_NULL_HANDLER,
64837 ZEND_NULL_HANDLER,
64838 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64839 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64840 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64841 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64842 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64843 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64844 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64845 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64846 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64847 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64848 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64849 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64850 ZEND_NULL_HANDLER,
64851 ZEND_NULL_HANDLER,
64852 ZEND_NULL_HANDLER,
64853 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64854 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64855 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64856 ZEND_NULL_HANDLER,
64857 ZEND_NULL_HANDLER,
64858 ZEND_NULL_HANDLER,
64859 ZEND_NULL_HANDLER,
64860 ZEND_NULL_HANDLER,
64861 ZEND_NULL_HANDLER,
64862 ZEND_NULL_HANDLER,
64863 ZEND_NULL_HANDLER,
64864 ZEND_NULL_HANDLER,
64865 ZEND_NULL_HANDLER,
64866 ZEND_NULL_HANDLER,
64867 ZEND_NULL_HANDLER,
64868 ZEND_NULL_HANDLER,
64869 ZEND_NULL_HANDLER,
64870 ZEND_NULL_HANDLER,
64871 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64872 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64873 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64874 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64875 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64876 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64877 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64878 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64879 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64880 ZEND_NULL_HANDLER,
64881 ZEND_NULL_HANDLER,
64882 ZEND_NULL_HANDLER,
64883 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64884 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64885 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64886 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
64887 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
64888 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
64889 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
64890 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64891 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64892 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
64893 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64894 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64895 ZEND_NULL_HANDLER,
64896 ZEND_NULL_HANDLER,
64897 ZEND_NULL_HANDLER,
64898 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
64899 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64900 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64901 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
64902 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64903 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64904 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64905 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64906 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64907 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64908 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64909 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64910 ZEND_NULL_HANDLER,
64911 ZEND_NULL_HANDLER,
64912 ZEND_NULL_HANDLER,
64913 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64914 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64915 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64916 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
64917 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64918 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64919 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64920 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64921 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64922 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64923 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64924 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64925 ZEND_NULL_HANDLER,
64926 ZEND_NULL_HANDLER,
64927 ZEND_NULL_HANDLER,
64928 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64929 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64930 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64931 ZEND_NULL_HANDLER,
64932 ZEND_NULL_HANDLER,
64933 ZEND_NULL_HANDLER,
64934 ZEND_NULL_HANDLER,
64935 ZEND_NULL_HANDLER,
64936 ZEND_NULL_HANDLER,
64937 ZEND_NULL_HANDLER,
64938 ZEND_NULL_HANDLER,
64939 ZEND_NULL_HANDLER,
64940 ZEND_NULL_HANDLER,
64941 ZEND_NULL_HANDLER,
64942 ZEND_NULL_HANDLER,
64943 ZEND_NULL_HANDLER,
64944 ZEND_NULL_HANDLER,
64945 ZEND_NULL_HANDLER,
64946 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
64947 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64948 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64949 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64950 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64951 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64952 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64953 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64954 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64955 ZEND_NULL_HANDLER,
64956 ZEND_NULL_HANDLER,
64957 ZEND_NULL_HANDLER,
64958 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64959 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64960 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64961 ZEND_NULL_HANDLER,
64962 ZEND_NULL_HANDLER,
64963 ZEND_NULL_HANDLER,
64964 ZEND_NULL_HANDLER,
64965 ZEND_NULL_HANDLER,
64966 ZEND_NULL_HANDLER,
64967 ZEND_NULL_HANDLER,
64968 ZEND_NULL_HANDLER,
64969 ZEND_NULL_HANDLER,
64970 ZEND_NULL_HANDLER,
64971 ZEND_NULL_HANDLER,
64972 ZEND_NULL_HANDLER,
64973 ZEND_NULL_HANDLER,
64974 ZEND_NULL_HANDLER,
64975 ZEND_NULL_HANDLER,
64976 ZEND_NULL_HANDLER,
64977 ZEND_NULL_HANDLER,
64978 ZEND_NULL_HANDLER,
64979 ZEND_NULL_HANDLER,
64980 ZEND_NULL_HANDLER,
64981 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER,
64982 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER,
64983 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER,
64984 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER,
64985 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER,
64986 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER,
64987 ZEND_NULL_HANDLER,
64988 ZEND_NULL_HANDLER,
64989 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
64990 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER,
64991 ZEND_NULL_HANDLER,
64992 ZEND_NULL_HANDLER,
64993 ZEND_NULL_HANDLER,
64994 ZEND_NULL_HANDLER,
64995 ZEND_NULL_HANDLER,
64996 ZEND_NULL_HANDLER,
64997 ZEND_NULL_HANDLER,
64998 ZEND_NULL_HANDLER,
64999 ZEND_NULL_HANDLER,
65000 ZEND_NULL_HANDLER,
65001 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER,
65002 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER,
65003 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER,
65004 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER,
65005 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER,
65006 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER,
65007 ZEND_NULL_HANDLER,
65008 ZEND_NULL_HANDLER,
65009 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER,
65010 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER,
65011 ZEND_NULL_HANDLER,
65012 ZEND_NULL_HANDLER,
65013 ZEND_NULL_HANDLER,
65014 ZEND_NULL_HANDLER,
65015 ZEND_NULL_HANDLER,
65016 ZEND_NULL_HANDLER,
65017 ZEND_NULL_HANDLER,
65018 ZEND_NULL_HANDLER,
65019 ZEND_NULL_HANDLER,
65020 ZEND_NULL_HANDLER,
65021 ZEND_NULL_HANDLER,
65022 ZEND_NULL_HANDLER,
65023 ZEND_NULL_HANDLER,
65024 ZEND_NULL_HANDLER,
65025 ZEND_NULL_HANDLER,
65026 ZEND_NULL_HANDLER,
65027 ZEND_NULL_HANDLER,
65028 ZEND_NULL_HANDLER,
65029 ZEND_NULL_HANDLER,
65030 ZEND_NULL_HANDLER,
65031 ZEND_NULL_HANDLER,
65032 ZEND_NULL_HANDLER,
65033 ZEND_NULL_HANDLER,
65034 ZEND_NULL_HANDLER,
65035 ZEND_NULL_HANDLER,
65036 ZEND_NULL_HANDLER,
65037 ZEND_NULL_HANDLER,
65038 ZEND_NULL_HANDLER,
65039 ZEND_NULL_HANDLER,
65040 ZEND_NULL_HANDLER,
65041 ZEND_NULL_HANDLER,
65042 ZEND_NULL_HANDLER,
65043 ZEND_NULL_HANDLER,
65044 ZEND_NULL_HANDLER,
65045 ZEND_NULL_HANDLER,
65046 ZEND_NULL_HANDLER,
65047 ZEND_NULL_HANDLER,
65048 ZEND_NULL_HANDLER,
65049 ZEND_NULL_HANDLER,
65050 ZEND_NULL_HANDLER,
65051 ZEND_NULL_HANDLER,
65052 ZEND_NULL_HANDLER,
65053 ZEND_NULL_HANDLER,
65054 ZEND_NULL_HANDLER,
65055 ZEND_NULL_HANDLER,
65056 ZEND_NULL_HANDLER,
65057 ZEND_NULL_HANDLER,
65058 ZEND_NULL_HANDLER,
65059 ZEND_NULL_HANDLER,
65060 ZEND_NULL_HANDLER,
65061 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
65062 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
65063 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65064 ZEND_NULL_HANDLER,
65065 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65066 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65067 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65068 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65069 ZEND_NULL_HANDLER,
65070 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65071 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65072 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65073 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65074 ZEND_NULL_HANDLER,
65075 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65076 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER,
65077 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER,
65078 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER,
65079 ZEND_NULL_HANDLER,
65080 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER,
65081 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
65082 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
65083 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65084 ZEND_NULL_HANDLER,
65085 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
65086 ZEND_NULL_HANDLER,
65087 ZEND_NULL_HANDLER,
65088 ZEND_NULL_HANDLER,
65089 ZEND_NULL_HANDLER,
65090 ZEND_NULL_HANDLER,
65091 ZEND_NULL_HANDLER,
65092 ZEND_NULL_HANDLER,
65093 ZEND_NULL_HANDLER,
65094 ZEND_NULL_HANDLER,
65095 ZEND_NULL_HANDLER,
65096 ZEND_NULL_HANDLER,
65097 ZEND_NULL_HANDLER,
65098 ZEND_NULL_HANDLER,
65099 ZEND_NULL_HANDLER,
65100 ZEND_NULL_HANDLER,
65101 ZEND_NULL_HANDLER,
65102 ZEND_NULL_HANDLER,
65103 ZEND_NULL_HANDLER,
65104 ZEND_NULL_HANDLER,
65105 ZEND_NULL_HANDLER,
65106 ZEND_NULL_HANDLER,
65107 ZEND_NULL_HANDLER,
65108 ZEND_NULL_HANDLER,
65109 ZEND_NULL_HANDLER,
65110 ZEND_NULL_HANDLER,
65111 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
65112 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
65113 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65114 ZEND_NULL_HANDLER,
65115 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65116 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65117 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65118 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65119 ZEND_NULL_HANDLER,
65120 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65121 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65122 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65123 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65124 ZEND_NULL_HANDLER,
65125 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65126 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER,
65127 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER,
65128 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER,
65129 ZEND_NULL_HANDLER,
65130 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER,
65131 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
65132 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
65133 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65134 ZEND_NULL_HANDLER,
65135 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER,
65136 ZEND_NULL_HANDLER,
65137 ZEND_NULL_HANDLER,
65138 ZEND_NULL_HANDLER,
65139 ZEND_NULL_HANDLER,
65140 ZEND_NULL_HANDLER,
65141 ZEND_NULL_HANDLER,
65142 ZEND_NULL_HANDLER,
65143 ZEND_NULL_HANDLER,
65144 ZEND_NULL_HANDLER,
65145 ZEND_NULL_HANDLER,
65146 ZEND_NULL_HANDLER,
65147 ZEND_NULL_HANDLER,
65148 ZEND_NULL_HANDLER,
65149 ZEND_NULL_HANDLER,
65150 ZEND_NULL_HANDLER,
65151 ZEND_NULL_HANDLER,
65152 ZEND_NULL_HANDLER,
65153 ZEND_NULL_HANDLER,
65154 ZEND_NULL_HANDLER,
65155 ZEND_NULL_HANDLER,
65156 ZEND_NULL_HANDLER,
65157 ZEND_NULL_HANDLER,
65158 ZEND_NULL_HANDLER,
65159 ZEND_NULL_HANDLER,
65160 ZEND_NULL_HANDLER,
65161 ZEND_NULL_HANDLER,
65162 ZEND_NULL_HANDLER,
65163 ZEND_NULL_HANDLER,
65164 ZEND_NULL_HANDLER,
65165 ZEND_NULL_HANDLER,
65166 ZEND_NULL_HANDLER,
65167 ZEND_NULL_HANDLER,
65168 ZEND_NULL_HANDLER,
65169 ZEND_NULL_HANDLER,
65170 ZEND_NULL_HANDLER,
65171 ZEND_NULL_HANDLER,
65172 ZEND_NULL_HANDLER,
65173 ZEND_NULL_HANDLER,
65174 ZEND_NULL_HANDLER,
65175 ZEND_NULL_HANDLER,
65176 ZEND_NULL_HANDLER,
65177 ZEND_NULL_HANDLER,
65178 ZEND_NULL_HANDLER,
65179 ZEND_NULL_HANDLER,
65180 ZEND_NULL_HANDLER,
65181 ZEND_NULL_HANDLER,
65182 ZEND_NULL_HANDLER,
65183 ZEND_NULL_HANDLER,
65184 ZEND_NULL_HANDLER,
65185 ZEND_NULL_HANDLER,
65186 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
65187 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
65188 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65189 ZEND_NULL_HANDLER,
65190 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65191 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65192 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65193 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65194 ZEND_NULL_HANDLER,
65195 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65196 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65197 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65198 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65199 ZEND_NULL_HANDLER,
65200 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65201 ZEND_NULL_HANDLER,
65202 ZEND_NULL_HANDLER,
65203 ZEND_NULL_HANDLER,
65204 ZEND_NULL_HANDLER,
65205 ZEND_NULL_HANDLER,
65206 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
65207 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
65208 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65209 ZEND_NULL_HANDLER,
65210 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
65211 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER,
65212 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER,
65213 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
65214 ZEND_NULL_HANDLER,
65215 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
65216 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
65217 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
65218 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65219 ZEND_NULL_HANDLER,
65220 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65221 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
65222 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
65223 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65224 ZEND_NULL_HANDLER,
65225 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65226 ZEND_NULL_HANDLER,
65227 ZEND_NULL_HANDLER,
65228 ZEND_NULL_HANDLER,
65229 ZEND_NULL_HANDLER,
65230 ZEND_NULL_HANDLER,
65231 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER,
65232 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER,
65233 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
65234 ZEND_NULL_HANDLER,
65235 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
65236 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
65237 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
65238 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65239 ZEND_NULL_HANDLER,
65240 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65241 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65242 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65243 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65244 ZEND_NULL_HANDLER,
65245 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65246 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65247 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65248 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65249 ZEND_NULL_HANDLER,
65250 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65251 ZEND_NULL_HANDLER,
65252 ZEND_NULL_HANDLER,
65253 ZEND_NULL_HANDLER,
65254 ZEND_NULL_HANDLER,
65255 ZEND_NULL_HANDLER,
65256 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
65257 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
65258 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65259 ZEND_NULL_HANDLER,
65260 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER,
65261 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER,
65262 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER,
65263 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER,
65264 ZEND_NULL_HANDLER,
65265 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER,
65266 ZEND_NULL_HANDLER,
65267 ZEND_NULL_HANDLER,
65268 ZEND_NULL_HANDLER,
65269 ZEND_NULL_HANDLER,
65270 ZEND_NULL_HANDLER,
65271 ZEND_NULL_HANDLER,
65272 ZEND_NULL_HANDLER,
65273 ZEND_NULL_HANDLER,
65274 ZEND_NULL_HANDLER,
65275 ZEND_NULL_HANDLER,
65276 ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER,
65277 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
65278 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
65279 ZEND_NULL_HANDLER,
65280 ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER,
65281 ZEND_NULL_HANDLER,
65282 ZEND_NULL_HANDLER,
65283 ZEND_NULL_HANDLER,
65284 ZEND_NULL_HANDLER,
65285 ZEND_NULL_HANDLER,
65286 ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER,
65287 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
65288 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
65289 ZEND_NULL_HANDLER,
65290 ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER,
65291 ZEND_NULL_HANDLER,
65292 ZEND_NULL_HANDLER,
65293 ZEND_NULL_HANDLER,
65294 ZEND_NULL_HANDLER,
65295 ZEND_NULL_HANDLER,
65296 ZEND_NULL_HANDLER,
65297 ZEND_NULL_HANDLER,
65298 ZEND_NULL_HANDLER,
65299 ZEND_NULL_HANDLER,
65300 ZEND_NULL_HANDLER,
65301 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER,
65302 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
65303 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
65304 ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER,
65305 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER,
65306 ZEND_NULL_HANDLER,
65307 ZEND_NULL_HANDLER,
65308 ZEND_NULL_HANDLER,
65309 ZEND_NULL_HANDLER,
65310 ZEND_NULL_HANDLER,
65311 ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER,
65312 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
65313 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
65314 ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER,
65315 ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER,
65316 ZEND_NULL_HANDLER,
65317 ZEND_NULL_HANDLER,
65318 ZEND_NULL_HANDLER,
65319 ZEND_NULL_HANDLER,
65320 ZEND_NULL_HANDLER,
65321 ZEND_NULL_HANDLER,
65322 ZEND_NULL_HANDLER,
65323 ZEND_NULL_HANDLER,
65324 ZEND_NULL_HANDLER,
65325 ZEND_NULL_HANDLER,
65326 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER,
65327 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
65328 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
65329 ZEND_NULL_HANDLER,
65330 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER,
65331 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER,
65332 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
65333 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
65334 ZEND_NULL_HANDLER,
65335 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER,
65336 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER,
65337 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
65338 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
65339 ZEND_NULL_HANDLER,
65340 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER,
65341 ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER,
65342 ZEND_NULL_HANDLER,
65343 ZEND_NULL_HANDLER,
65344 ZEND_NULL_HANDLER,
65345 ZEND_NULL_HANDLER,
65346 ZEND_NULL_HANDLER,
65347 ZEND_NULL_HANDLER,
65348 ZEND_NULL_HANDLER,
65349 ZEND_NULL_HANDLER,
65350 ZEND_NULL_HANDLER,
65351 ZEND_NULL_HANDLER,
65352 ZEND_NULL_HANDLER,
65353 ZEND_NULL_HANDLER,
65354 ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER,
65355 ZEND_NULL_HANDLER,
65356 ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER,
65357 ZEND_NULL_HANDLER,
65358 ZEND_NULL_HANDLER,
65359 ZEND_NULL_HANDLER,
65360 ZEND_NULL_HANDLER,
65361 ZEND_NULL_HANDLER,
65362 ZEND_NULL_HANDLER,
65363 ZEND_NULL_HANDLER,
65364 ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER,
65365 ZEND_NULL_HANDLER,
65366 ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER,
65367 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
65368 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
65369 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
65370 ZEND_NULL_HANDLER,
65371 ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
65372 ZEND_NULL_HANDLER,
65373 ZEND_NULL_HANDLER,
65374 ZEND_NULL_HANDLER,
65375 ZEND_NULL_HANDLER,
65376 ZEND_NULL_HANDLER,
65377 ZEND_NULL_HANDLER,
65378 ZEND_NULL_HANDLER,
65379 ZEND_NULL_HANDLER,
65380 ZEND_NULL_HANDLER,
65381 ZEND_NULL_HANDLER,
65382 ZEND_NULL_HANDLER,
65383 ZEND_NULL_HANDLER,
65384 ZEND_NULL_HANDLER,
65385 ZEND_NULL_HANDLER,
65386 ZEND_NULL_HANDLER,
65387 ZEND_NULL_HANDLER,
65388 ZEND_NULL_HANDLER,
65389 ZEND_NULL_HANDLER,
65390 ZEND_NULL_HANDLER,
65391 ZEND_NULL_HANDLER,
65392 ZEND_NULL_HANDLER,
65393 ZEND_NULL_HANDLER,
65394 ZEND_NULL_HANDLER,
65395 ZEND_NULL_HANDLER,
65396 ZEND_NULL_HANDLER,
65397 ZEND_NULL_HANDLER,
65398 ZEND_NULL_HANDLER,
65399 ZEND_NULL_HANDLER,
65400 ZEND_NULL_HANDLER,
65401 ZEND_NULL_HANDLER,
65402 ZEND_NULL_HANDLER,
65403 ZEND_NULL_HANDLER,
65404 ZEND_NULL_HANDLER,
65405 ZEND_NULL_HANDLER,
65406 ZEND_NULL_HANDLER,
65407 ZEND_NULL_HANDLER,
65408 ZEND_NULL_HANDLER,
65409 ZEND_NULL_HANDLER,
65410 ZEND_NULL_HANDLER,
65411 ZEND_NULL_HANDLER,
65412 ZEND_NULL_HANDLER,
65413 ZEND_NULL_HANDLER,
65414 ZEND_NULL_HANDLER,
65415 ZEND_NULL_HANDLER,
65416 ZEND_NULL_HANDLER,
65417 ZEND_NULL_HANDLER,
65418 ZEND_NULL_HANDLER,
65419 ZEND_NULL_HANDLER,
65420 ZEND_NULL_HANDLER,
65421 ZEND_NULL_HANDLER,
65422 ZEND_NULL_HANDLER,
65423 ZEND_NULL_HANDLER,
65424 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65425 ZEND_NULL_HANDLER,
65426 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65427 ZEND_NULL_HANDLER,
65428 ZEND_NULL_HANDLER,
65429 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65430 ZEND_NULL_HANDLER,
65431 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65432 ZEND_NULL_HANDLER,
65433 ZEND_NULL_HANDLER,
65434 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65435 ZEND_NULL_HANDLER,
65436 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65437 ZEND_NULL_HANDLER,
65438 ZEND_NULL_HANDLER,
65439 ZEND_NULL_HANDLER,
65440 ZEND_NULL_HANDLER,
65441 ZEND_NULL_HANDLER,
65442 ZEND_NULL_HANDLER,
65443 ZEND_NULL_HANDLER,
65444 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65445 ZEND_NULL_HANDLER,
65446 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
65447 ZEND_NULL_HANDLER,
65448 ZEND_NULL_HANDLER,
65449 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
65450 ZEND_NULL_HANDLER,
65451 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
65452 ZEND_NULL_HANDLER,
65453 ZEND_NULL_HANDLER,
65454 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65455 ZEND_NULL_HANDLER,
65456 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65457 ZEND_NULL_HANDLER,
65458 ZEND_NULL_HANDLER,
65459 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65460 ZEND_NULL_HANDLER,
65461 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65462 ZEND_NULL_HANDLER,
65463 ZEND_NULL_HANDLER,
65464 ZEND_NULL_HANDLER,
65465 ZEND_NULL_HANDLER,
65466 ZEND_NULL_HANDLER,
65467 ZEND_NULL_HANDLER,
65468 ZEND_NULL_HANDLER,
65469 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
65470 ZEND_NULL_HANDLER,
65471 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
65472 ZEND_NULL_HANDLER,
65473 ZEND_NULL_HANDLER,
65474 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65475 ZEND_NULL_HANDLER,
65476 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65477 ZEND_NULL_HANDLER,
65478 ZEND_NULL_HANDLER,
65479 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65480 ZEND_NULL_HANDLER,
65481 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65482 ZEND_NULL_HANDLER,
65483 ZEND_NULL_HANDLER,
65484 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65485 ZEND_NULL_HANDLER,
65486 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65487 ZEND_NULL_HANDLER,
65488 ZEND_NULL_HANDLER,
65489 ZEND_NULL_HANDLER,
65490 ZEND_NULL_HANDLER,
65491 ZEND_NULL_HANDLER,
65492 ZEND_NULL_HANDLER,
65493 ZEND_NULL_HANDLER,
65494 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65495 ZEND_NULL_HANDLER,
65496 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER,
65497 ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER,
65498 ZEND_NULL_HANDLER,
65499 ZEND_NULL_HANDLER,
65500 ZEND_NULL_HANDLER,
65501 ZEND_NULL_HANDLER,
65502 ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
65503 ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER,
65504 ZEND_NULL_HANDLER,
65505 ZEND_NULL_HANDLER,
65506 ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER,
65507 ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER,
65508 ZEND_NULL_HANDLER,
65509 ZEND_NULL_HANDLER,
65510 ZEND_NULL_HANDLER,
65511 ZEND_NULL_HANDLER,
65512 ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
65513 ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER,
65514 ZEND_NULL_HANDLER,
65515 ZEND_NULL_HANDLER,
65516 ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER,
65517 ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER,
65518 ZEND_NULL_HANDLER,
65519 ZEND_NULL_HANDLER,
65520 ZEND_POST_INC_SPEC_VAR_HANDLER,
65521 ZEND_NULL_HANDLER,
65522 ZEND_POST_INC_SPEC_CV_HANDLER,
65523 ZEND_NULL_HANDLER,
65524 ZEND_NULL_HANDLER,
65525 ZEND_POST_DEC_SPEC_VAR_HANDLER,
65526 ZEND_NULL_HANDLER,
65527 ZEND_POST_DEC_SPEC_CV_HANDLER,
65528 ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER,
65529 ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER,
65530 ZEND_JMP_SPEC_HANDLER,
65531 ZEND_JMPZ_SPEC_CONST_HANDLER,
65532 ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
65533 ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
65534 ZEND_NULL_HANDLER,
65535 ZEND_JMPZ_SPEC_CV_HANDLER,
65536 ZEND_JMPNZ_SPEC_CONST_HANDLER,
65537 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
65538 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
65539 ZEND_NULL_HANDLER,
65540 ZEND_JMPNZ_SPEC_CV_HANDLER,
65541 ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
65542 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
65543 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
65544 ZEND_NULL_HANDLER,
65545 ZEND_JMPZ_EX_SPEC_CV_HANDLER,
65546 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
65547 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
65548 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
65549 ZEND_NULL_HANDLER,
65550 ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
65551 ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER,
65552 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
65553 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
65554 ZEND_NULL_HANDLER,
65555 ZEND_CASE_SPEC_TMPVAR_CV_HANDLER,
65556 ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER,
65557 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
65558 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
65559 ZEND_NULL_HANDLER,
65560 ZEND_NULL_HANDLER,
65561 ZEND_NULL_HANDLER,
65562 ZEND_NULL_HANDLER,
65563 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER,
65564 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER,
65565 ZEND_NULL_HANDLER,
65566 ZEND_NULL_HANDLER,
65567 ZEND_CAST_SPEC_CONST_HANDLER,
65568 ZEND_CAST_SPEC_TMP_HANDLER,
65569 ZEND_CAST_SPEC_VAR_HANDLER,
65570 ZEND_NULL_HANDLER,
65571 ZEND_CAST_SPEC_CV_HANDLER,
65572 ZEND_BOOL_SPEC_CONST_HANDLER,
65573 ZEND_BOOL_SPEC_TMPVAR_HANDLER,
65574 ZEND_BOOL_SPEC_TMPVAR_HANDLER,
65575 ZEND_NULL_HANDLER,
65576 ZEND_BOOL_SPEC_CV_HANDLER,
65577 ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER,
65578 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
65579 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
65580 ZEND_NULL_HANDLER,
65581 ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER,
65582 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
65583 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65584 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65585 ZEND_NULL_HANDLER,
65586 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
65587 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
65588 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65589 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65590 ZEND_NULL_HANDLER,
65591 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
65592 ZEND_NULL_HANDLER,
65593 ZEND_NULL_HANDLER,
65594 ZEND_NULL_HANDLER,
65595 ZEND_NULL_HANDLER,
65596 ZEND_NULL_HANDLER,
65597 ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER,
65598 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
65599 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
65600 ZEND_NULL_HANDLER,
65601 ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER,
65602 ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER,
65603 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
65604 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
65605 ZEND_NULL_HANDLER,
65606 ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER,
65607 ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER,
65608 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
65609 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
65610 ZEND_NULL_HANDLER,
65611 ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER,
65612 ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER,
65613 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
65614 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
65615 ZEND_NULL_HANDLER,
65616 ZEND_ROPE_END_SPEC_TMP_CV_HANDLER,
65617 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
65618 ZEND_END_SILENCE_SPEC_TMP_HANDLER,
65619 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
65620 ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER,
65621 ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER,
65622 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
65623 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
65624 ZEND_INIT_FCALL_SPEC_CONST_HANDLER,
65625 ZEND_RETURN_SPEC_CONST_HANDLER,
65626 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65627 ZEND_RETURN_SPEC_TMP_HANDLER,
65628 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65629 ZEND_RETURN_SPEC_VAR_HANDLER,
65630 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65631 ZEND_NULL_HANDLER,
65632 ZEND_NULL_HANDLER,
65633 ZEND_RETURN_SPEC_CV_HANDLER,
65634 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65635 ZEND_RECV_SPEC_UNUSED_HANDLER,
65636 ZEND_RECV_INIT_SPEC_CONST_HANDLER,
65637 ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER,
65638 ZEND_NULL_HANDLER,
65639 ZEND_NULL_HANDLER,
65640 ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER,
65641 ZEND_NULL_HANDLER,
65642 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
65643 ZEND_NULL_HANDLER,
65644 ZEND_NULL_HANDLER,
65645 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER,
65646 ZEND_NULL_HANDLER,
65647 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
65648 ZEND_NULL_HANDLER,
65649 ZEND_NULL_HANDLER,
65650 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER,
65651 ZEND_NULL_HANDLER,
65652 ZEND_NULL_HANDLER,
65653 ZEND_NULL_HANDLER,
65654 ZEND_NULL_HANDLER,
65655 ZEND_NULL_HANDLER,
65656 ZEND_NULL_HANDLER,
65657 ZEND_NULL_HANDLER,
65658 ZEND_NULL_HANDLER,
65659 ZEND_NULL_HANDLER,
65660 ZEND_NULL_HANDLER,
65661 ZEND_NULL_HANDLER,
65662 ZEND_NULL_HANDLER,
65663 ZEND_NULL_HANDLER,
65664 ZEND_NULL_HANDLER,
65665 ZEND_NULL_HANDLER,
65666 ZEND_NULL_HANDLER,
65667 ZEND_NULL_HANDLER,
65668 ZEND_NULL_HANDLER,
65669 ZEND_NULL_HANDLER,
65670 ZEND_NULL_HANDLER,
65671 ZEND_NULL_HANDLER,
65672 ZEND_NULL_HANDLER,
65673 ZEND_NULL_HANDLER,
65674 ZEND_NULL_HANDLER,
65675 ZEND_NULL_HANDLER,
65676 ZEND_NULL_HANDLER,
65677 ZEND_NULL_HANDLER,
65678 ZEND_NULL_HANDLER,
65679 ZEND_NULL_HANDLER,
65680 ZEND_NULL_HANDLER,
65681 ZEND_NULL_HANDLER,
65682 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
65683 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
65684 ZEND_NULL_HANDLER,
65685 ZEND_NULL_HANDLER,
65686 ZEND_NULL_HANDLER,
65687 ZEND_NULL_HANDLER,
65688 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER,
65689 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER,
65690 ZEND_NULL_HANDLER,
65691 ZEND_NULL_HANDLER,
65692 ZEND_NULL_HANDLER,
65693 ZEND_NULL_HANDLER,
65694 ZEND_NULL_HANDLER,
65695 ZEND_NULL_HANDLER,
65696 ZEND_NULL_HANDLER,
65697 ZEND_NULL_HANDLER,
65698 ZEND_NULL_HANDLER,
65699 ZEND_NULL_HANDLER,
65700 ZEND_NULL_HANDLER,
65701 ZEND_NULL_HANDLER,
65702 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
65703 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
65704 ZEND_NULL_HANDLER,
65705 ZEND_NULL_HANDLER,
65706 ZEND_NULL_HANDLER,
65707 ZEND_NULL_HANDLER,
65708 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER,
65709 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER,
65710 ZEND_NULL_HANDLER,
65711 ZEND_NULL_HANDLER,
65712 ZEND_NULL_HANDLER,
65713 ZEND_NULL_HANDLER,
65714 ZEND_NULL_HANDLER,
65715 ZEND_NULL_HANDLER,
65716 ZEND_NULL_HANDLER,
65717 ZEND_NULL_HANDLER,
65718 ZEND_NULL_HANDLER,
65719 ZEND_NULL_HANDLER,
65720 ZEND_NULL_HANDLER,
65721 ZEND_NULL_HANDLER,
65722 ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER,
65723 ZEND_NULL_HANDLER,
65724 ZEND_NULL_HANDLER,
65725 ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER,
65726 ZEND_NULL_HANDLER,
65727 ZEND_NULL_HANDLER,
65728 ZEND_NULL_HANDLER,
65729 ZEND_NULL_HANDLER,
65730 ZEND_NULL_HANDLER,
65731 ZEND_NULL_HANDLER,
65732 ZEND_SEND_REF_SPEC_CV_CONST_HANDLER,
65733 ZEND_NULL_HANDLER,
65734 ZEND_NULL_HANDLER,
65735 ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER,
65736 ZEND_NULL_HANDLER,
65737 ZEND_NEW_SPEC_CONST_UNUSED_HANDLER,
65738 ZEND_NULL_HANDLER,
65739 ZEND_NEW_SPEC_VAR_UNUSED_HANDLER,
65740 ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER,
65741 ZEND_NULL_HANDLER,
65742 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
65743 ZEND_FREE_SPEC_TMPVAR_HANDLER,
65744 ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER,
65745 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
65746 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
65747 ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER,
65748 ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER,
65749 ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER,
65750 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
65751 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
65752 ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER,
65753 ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER,
65754 ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER,
65755 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
65756 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
65757 ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER,
65758 ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER,
65759 ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER,
65760 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
65761 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
65762 ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER,
65763 ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER,
65764 ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER,
65765 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
65766 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
65767 ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER,
65768 ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER,
65769 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER,
65770 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
65771 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
65772 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER,
65773 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER,
65774 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER,
65775 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
65776 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
65777 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER,
65778 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER,
65779 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER,
65780 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
65781 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
65782 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER,
65783 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER,
65784 ZEND_NULL_HANDLER,
65785 ZEND_NULL_HANDLER,
65786 ZEND_NULL_HANDLER,
65787 ZEND_NULL_HANDLER,
65788 ZEND_NULL_HANDLER,
65789 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER,
65790 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
65791 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
65792 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER,
65793 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER,
65794 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
65795 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65796 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
65797 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65798 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
65799 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65800 ZEND_NULL_HANDLER,
65801 ZEND_NULL_HANDLER,
65802 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
65803 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65804 ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER,
65805 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
65806 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
65807 ZEND_NULL_HANDLER,
65808 ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER,
65809 ZEND_NULL_HANDLER,
65810 ZEND_NULL_HANDLER,
65811 ZEND_NULL_HANDLER,
65812 ZEND_NULL_HANDLER,
65813 ZEND_NULL_HANDLER,
65814 ZEND_NULL_HANDLER,
65815 ZEND_NULL_HANDLER,
65816 ZEND_NULL_HANDLER,
65817 ZEND_NULL_HANDLER,
65818 ZEND_NULL_HANDLER,
65819 ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER,
65820 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
65821 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
65822 ZEND_NULL_HANDLER,
65823 ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER,
65824 ZEND_NULL_HANDLER,
65825 ZEND_NULL_HANDLER,
65826 ZEND_NULL_HANDLER,
65827 ZEND_NULL_HANDLER,
65828 ZEND_NULL_HANDLER,
65829 ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER,
65830 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
65831 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
65832 ZEND_NULL_HANDLER,
65833 ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER,
65834 ZEND_NULL_HANDLER,
65835 ZEND_NULL_HANDLER,
65836 ZEND_NULL_HANDLER,
65837 ZEND_NULL_HANDLER,
65838 ZEND_NULL_HANDLER,
65839 ZEND_NULL_HANDLER,
65840 ZEND_NULL_HANDLER,
65841 ZEND_NULL_HANDLER,
65842 ZEND_NULL_HANDLER,
65843 ZEND_NULL_HANDLER,
65844 ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER,
65845 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
65846 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
65847 ZEND_NULL_HANDLER,
65848 ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER,
65849 ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER,
65850 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65851 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65852 ZEND_NULL_HANDLER,
65853 ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER,
65854 ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER,
65855 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
65856 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
65857 ZEND_NULL_HANDLER,
65858 ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER,
65859 ZEND_FE_RESET_R_SPEC_CONST_HANDLER,
65860 ZEND_FE_RESET_R_SPEC_TMP_HANDLER,
65861 ZEND_FE_RESET_R_SPEC_VAR_HANDLER,
65862 ZEND_NULL_HANDLER,
65863 ZEND_FE_RESET_R_SPEC_CV_HANDLER,
65864 ZEND_FE_FETCH_R_SPEC_VAR_HANDLER,
65865 ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER,
65866 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
65867 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
65868 ZEND_NULL_HANDLER,
65869 ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER,
65870 ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER,
65871 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
65872 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
65873 ZEND_NULL_HANDLER,
65874 ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER,
65875 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
65876 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65877 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65878 ZEND_NULL_HANDLER,
65879 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
65880 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
65881 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65882 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65883 ZEND_NULL_HANDLER,
65884 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
65885 ZEND_NULL_HANDLER,
65886 ZEND_NULL_HANDLER,
65887 ZEND_NULL_HANDLER,
65888 ZEND_NULL_HANDLER,
65889 ZEND_NULL_HANDLER,
65890 ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER,
65891 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
65892 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
65893 ZEND_NULL_HANDLER,
65894 ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
65895 ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER,
65896 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
65897 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
65898 ZEND_NULL_HANDLER,
65899 ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER,
65900 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
65901 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65902 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65903 ZEND_NULL_HANDLER,
65904 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
65905 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
65906 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65907 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65908 ZEND_NULL_HANDLER,
65909 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
65910 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER,
65911 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
65912 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
65913 ZEND_NULL_HANDLER,
65914 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER,
65915 ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER,
65916 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
65917 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
65918 ZEND_NULL_HANDLER,
65919 ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER,
65920 ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER,
65921 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
65922 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
65923 ZEND_NULL_HANDLER,
65924 ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER,
65925 ZEND_NULL_HANDLER,
65926 ZEND_NULL_HANDLER,
65927 ZEND_NULL_HANDLER,
65928 ZEND_NULL_HANDLER,
65929 ZEND_NULL_HANDLER,
65930 ZEND_NULL_HANDLER,
65931 ZEND_NULL_HANDLER,
65932 ZEND_NULL_HANDLER,
65933 ZEND_NULL_HANDLER,
65934 ZEND_NULL_HANDLER,
65935 ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
65936 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
65937 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
65938 ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER,
65939 ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER,
65940 ZEND_NULL_HANDLER,
65941 ZEND_NULL_HANDLER,
65942 ZEND_NULL_HANDLER,
65943 ZEND_NULL_HANDLER,
65944 ZEND_NULL_HANDLER,
65945 ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER,
65946 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
65947 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
65948 ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER,
65949 ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER,
65950 ZEND_NULL_HANDLER,
65951 ZEND_NULL_HANDLER,
65952 ZEND_NULL_HANDLER,
65953 ZEND_NULL_HANDLER,
65954 ZEND_NULL_HANDLER,
65955 ZEND_NULL_HANDLER,
65956 ZEND_NULL_HANDLER,
65957 ZEND_NULL_HANDLER,
65958 ZEND_NULL_HANDLER,
65959 ZEND_NULL_HANDLER,
65960 ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER,
65961 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
65962 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
65963 ZEND_NULL_HANDLER,
65964 ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER,
65965 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER,
65966 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
65967 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
65968 ZEND_NULL_HANDLER,
65969 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER,
65970 ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER,
65971 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
65972 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
65973 ZEND_NULL_HANDLER,
65974 ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER,
65975 ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER,
65976 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
65977 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
65978 ZEND_NULL_HANDLER,
65979 ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER,
65980 ZEND_NULL_HANDLER,
65981 ZEND_NULL_HANDLER,
65982 ZEND_NULL_HANDLER,
65983 ZEND_NULL_HANDLER,
65984 ZEND_NULL_HANDLER,
65985 ZEND_NULL_HANDLER,
65986 ZEND_NULL_HANDLER,
65987 ZEND_NULL_HANDLER,
65988 ZEND_NULL_HANDLER,
65989 ZEND_NULL_HANDLER,
65990 ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
65991 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
65992 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
65993 ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER,
65994 ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER,
65995 ZEND_NULL_HANDLER,
65996 ZEND_NULL_HANDLER,
65997 ZEND_NULL_HANDLER,
65998 ZEND_NULL_HANDLER,
65999 ZEND_NULL_HANDLER,
66000 ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER,
66001 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
66002 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
66003 ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER,
66004 ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER,
66005 ZEND_NULL_HANDLER,
66006 ZEND_NULL_HANDLER,
66007 ZEND_NULL_HANDLER,
66008 ZEND_NULL_HANDLER,
66009 ZEND_NULL_HANDLER,
66010 ZEND_NULL_HANDLER,
66011 ZEND_NULL_HANDLER,
66012 ZEND_NULL_HANDLER,
66013 ZEND_NULL_HANDLER,
66014 ZEND_NULL_HANDLER,
66015 ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER,
66016 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
66017 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
66018 ZEND_NULL_HANDLER,
66019 ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER,
66020 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER,
66021 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
66022 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
66023 ZEND_NULL_HANDLER,
66024 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER,
66025 ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER,
66026 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
66027 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
66028 ZEND_NULL_HANDLER,
66029 ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER,
66030 ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER,
66031 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
66032 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
66033 ZEND_NULL_HANDLER,
66034 ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER,
66035 ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER,
66036 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
66037 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
66038 ZEND_NULL_HANDLER,
66039 ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER,
66040 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
66041 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66042 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66043 ZEND_NULL_HANDLER,
66044 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
66045 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
66046 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66047 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66048 ZEND_NULL_HANDLER,
66049 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
66050 ZEND_NULL_HANDLER,
66051 ZEND_NULL_HANDLER,
66052 ZEND_NULL_HANDLER,
66053 ZEND_NULL_HANDLER,
66054 ZEND_NULL_HANDLER,
66055 ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER,
66056 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
66057 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
66058 ZEND_NULL_HANDLER,
66059 ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
66060 ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER,
66061 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
66062 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
66063 ZEND_NULL_HANDLER,
66064 ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER,
66065 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
66066 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66067 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66068 ZEND_NULL_HANDLER,
66069 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
66070 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
66071 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66072 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66073 ZEND_NULL_HANDLER,
66074 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
66075 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER,
66076 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
66077 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
66078 ZEND_NULL_HANDLER,
66079 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER,
66080 ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER,
66081 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
66082 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
66083 ZEND_NULL_HANDLER,
66084 ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER,
66085 ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
66086 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
66087 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
66088 ZEND_NULL_HANDLER,
66089 ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
66090 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
66091 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66092 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66093 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
66094 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER,
66095 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
66096 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66097 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66098 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER,
66099 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER,
66100 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66101 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66102 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66103 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
66104 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER,
66105 ZEND_NULL_HANDLER,
66106 ZEND_NULL_HANDLER,
66107 ZEND_NULL_HANDLER,
66108 ZEND_NULL_HANDLER,
66109 ZEND_NULL_HANDLER,
66110 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER,
66111 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66112 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66113 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
66114 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
66115 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
66116 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66117 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66118 ZEND_NULL_HANDLER,
66119 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER,
66120 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
66121 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66122 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66123 ZEND_NULL_HANDLER,
66124 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER,
66125 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66126 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66127 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66128 ZEND_NULL_HANDLER,
66129 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER,
66130 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66131 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
66132 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
66133 ZEND_NULL_HANDLER,
66134 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER,
66135 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER,
66136 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66137 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66138 ZEND_NULL_HANDLER,
66139 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER,
66140 ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER,
66141 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
66142 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
66143 ZEND_NULL_HANDLER,
66144 ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER,
66145 ZEND_NULL_HANDLER,
66146 ZEND_NULL_HANDLER,
66147 ZEND_NULL_HANDLER,
66148 ZEND_NULL_HANDLER,
66149 ZEND_NULL_HANDLER,
66150 ZEND_NULL_HANDLER,
66151 ZEND_NULL_HANDLER,
66152 ZEND_NULL_HANDLER,
66153 ZEND_NULL_HANDLER,
66154 ZEND_NULL_HANDLER,
66155 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
66156 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66157 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66158 ZEND_NULL_HANDLER,
66159 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER,
66160 ZEND_NULL_HANDLER,
66161 ZEND_NULL_HANDLER,
66162 ZEND_NULL_HANDLER,
66163 ZEND_NULL_HANDLER,
66164 ZEND_NULL_HANDLER,
66165 ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER,
66166 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
66167 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
66168 ZEND_NULL_HANDLER,
66169 ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER,
66170 ZEND_NULL_HANDLER,
66171 ZEND_NULL_HANDLER,
66172 ZEND_NULL_HANDLER,
66173 ZEND_NULL_HANDLER,
66174 ZEND_NULL_HANDLER,
66175 ZEND_NULL_HANDLER,
66176 ZEND_NULL_HANDLER,
66177 ZEND_NULL_HANDLER,
66178 ZEND_NULL_HANDLER,
66179 ZEND_NULL_HANDLER,
66180 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER,
66181 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66182 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66183 ZEND_NULL_HANDLER,
66184 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER,
66185 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER,
66186 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
66187 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
66188 ZEND_NULL_HANDLER,
66189 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER,
66190 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER,
66191 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
66192 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
66193 ZEND_NULL_HANDLER,
66194 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER,
66195 ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER,
66196 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
66197 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
66198 ZEND_NULL_HANDLER,
66199 ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER,
66200 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66201 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66202 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66203 ZEND_NULL_HANDLER,
66204 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66205 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66206 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66207 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66208 ZEND_NULL_HANDLER,
66209 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66210 ZEND_NULL_HANDLER,
66211 ZEND_NULL_HANDLER,
66212 ZEND_NULL_HANDLER,
66213 ZEND_NULL_HANDLER,
66214 ZEND_NULL_HANDLER,
66215 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66216 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66217 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66218 ZEND_NULL_HANDLER,
66219 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66220 ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
66221 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66222 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66223 ZEND_NULL_HANDLER,
66224 ZEND_NULL_HANDLER,
66225 ZEND_NULL_HANDLER,
66226 ZEND_NULL_HANDLER,
66227 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER,
66228 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER,
66229 ZEND_NULL_HANDLER,
66230 ZEND_NULL_HANDLER,
66231 ZEND_EXT_STMT_SPEC_HANDLER,
66232 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
66233 ZEND_EXT_FCALL_END_SPEC_HANDLER,
66234 ZEND_EXT_NOP_SPEC_HANDLER,
66235 ZEND_TICKS_SPEC_HANDLER,
66236 ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER,
66237 ZEND_NULL_HANDLER,
66238 ZEND_NULL_HANDLER,
66239 ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER,
66240 ZEND_NULL_HANDLER,
66241 ZEND_CATCH_SPEC_CONST_HANDLER,
66242 ZEND_THROW_SPEC_CONST_HANDLER,
66243 ZEND_THROW_SPEC_TMPVAR_HANDLER,
66244 ZEND_THROW_SPEC_TMPVAR_HANDLER,
66245 ZEND_NULL_HANDLER,
66246 ZEND_THROW_SPEC_CV_HANDLER,
66247 ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER,
66248 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
66249 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
66250 ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66251 ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER,
66252 ZEND_CLONE_SPEC_CONST_HANDLER,
66253 ZEND_CLONE_SPEC_TMPVAR_HANDLER,
66254 ZEND_CLONE_SPEC_TMPVAR_HANDLER,
66255 ZEND_CLONE_SPEC_UNUSED_HANDLER,
66256 ZEND_CLONE_SPEC_CV_HANDLER,
66257 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
66258 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66259 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
66260 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66261 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
66262 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66263 ZEND_NULL_HANDLER,
66264 ZEND_NULL_HANDLER,
66265 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
66266 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66267 ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
66268 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66269 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66270 ZEND_NULL_HANDLER,
66271 ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER,
66272 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
66273 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66274 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66275 ZEND_NULL_HANDLER,
66276 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
66277 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
66278 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66279 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66280 ZEND_NULL_HANDLER,
66281 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
66282 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
66283 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66284 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66285 ZEND_NULL_HANDLER,
66286 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
66287 ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER,
66288 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
66289 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
66290 ZEND_NULL_HANDLER,
66291 ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER,
66292 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
66293 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66294 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66295 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER,
66296 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER,
66297 ZEND_NULL_HANDLER,
66298 ZEND_NULL_HANDLER,
66299 ZEND_NULL_HANDLER,
66300 ZEND_NULL_HANDLER,
66301 ZEND_NULL_HANDLER,
66302 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
66303 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
66304 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
66305 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER,
66306 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER,
66307 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
66308 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66309 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66310 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER,
66311 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
66312 ZEND_NULL_HANDLER,
66313 ZEND_NULL_HANDLER,
66314 ZEND_NULL_HANDLER,
66315 ZEND_NULL_HANDLER,
66316 ZEND_NULL_HANDLER,
66317 ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER,
66318 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
66319 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
66320 ZEND_NULL_HANDLER,
66321 ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER,
66322 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER,
66323 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66324 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66325 ZEND_NULL_HANDLER,
66326 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER,
66327 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66328 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66329 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66330 ZEND_NULL_HANDLER,
66331 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
66332 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66333 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66334 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66335 ZEND_NULL_HANDLER,
66336 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
66337 ZEND_NULL_HANDLER,
66338 ZEND_NULL_HANDLER,
66339 ZEND_NULL_HANDLER,
66340 ZEND_NULL_HANDLER,
66341 ZEND_NULL_HANDLER,
66342 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER,
66343 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
66344 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
66345 ZEND_NULL_HANDLER,
66346 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER,
66347 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
66348 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
66349 ZEND_NULL_HANDLER,
66350 ZEND_NULL_HANDLER,
66351 ZEND_NULL_HANDLER,
66352 ZEND_NULL_HANDLER,
66353 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER,
66354 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER,
66355 ZEND_NULL_HANDLER,
66356 ZEND_NULL_HANDLER,
66357 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
66358 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
66359 ZEND_NULL_HANDLER,
66360 ZEND_NULL_HANDLER,
66361 ZEND_NULL_HANDLER,
66362 ZEND_NULL_HANDLER,
66363 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER,
66364 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER,
66365 ZEND_NULL_HANDLER,
66366 ZEND_NULL_HANDLER,
66367 ZEND_NULL_HANDLER,
66368 ZEND_NULL_HANDLER,
66369 ZEND_NULL_HANDLER,
66370 ZEND_NULL_HANDLER,
66371 ZEND_NULL_HANDLER,
66372 ZEND_NULL_HANDLER,
66373 ZEND_NULL_HANDLER,
66374 ZEND_NULL_HANDLER,
66375 ZEND_NULL_HANDLER,
66376 ZEND_NULL_HANDLER,
66377 ZEND_NULL_HANDLER,
66378 ZEND_NULL_HANDLER,
66379 ZEND_NULL_HANDLER,
66380 ZEND_NULL_HANDLER,
66381 ZEND_NULL_HANDLER,
66382 ZEND_NULL_HANDLER,
66383 ZEND_NULL_HANDLER,
66384 ZEND_NULL_HANDLER,
66385 ZEND_NULL_HANDLER,
66386 ZEND_NULL_HANDLER,
66387 ZEND_NULL_HANDLER,
66388 ZEND_NULL_HANDLER,
66389 ZEND_NULL_HANDLER,
66390 ZEND_NULL_HANDLER,
66391 ZEND_NULL_HANDLER,
66392 ZEND_NULL_HANDLER,
66393 ZEND_NULL_HANDLER,
66394 ZEND_NULL_HANDLER,
66395 ZEND_NULL_HANDLER,
66396 ZEND_NULL_HANDLER,
66397 ZEND_NULL_HANDLER,
66398 ZEND_NULL_HANDLER,
66399 ZEND_NULL_HANDLER,
66400 ZEND_NULL_HANDLER,
66401 ZEND_NULL_HANDLER,
66402 ZEND_NULL_HANDLER,
66403 ZEND_NULL_HANDLER,
66404 ZEND_NULL_HANDLER,
66405 ZEND_NULL_HANDLER,
66406 ZEND_NULL_HANDLER,
66407 ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER,
66408 ZEND_NULL_HANDLER,
66409 ZEND_NULL_HANDLER,
66410 ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER,
66411 ZEND_NULL_HANDLER,
66412 ZEND_NULL_HANDLER,
66413 ZEND_NULL_HANDLER,
66414 ZEND_NULL_HANDLER,
66415 ZEND_NULL_HANDLER,
66416 ZEND_NULL_HANDLER,
66417 ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER,
66418 ZEND_NULL_HANDLER,
66419 ZEND_NULL_HANDLER,
66420 ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER,
66421 ZEND_NULL_HANDLER,
66422 ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER,
66423 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
66424 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
66425 ZEND_NULL_HANDLER,
66426 ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER,
66427 ZEND_SEND_ARRAY_SPEC_HANDLER,
66428 ZEND_SEND_USER_SPEC_CONST_HANDLER,
66429 ZEND_SEND_USER_SPEC_TMP_HANDLER,
66430 ZEND_SEND_USER_SPEC_VAR_HANDLER,
66431 ZEND_NULL_HANDLER,
66432 ZEND_SEND_USER_SPEC_CV_HANDLER,
66433 ZEND_STRLEN_SPEC_CONST_HANDLER,
66434 ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
66435 ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
66436 ZEND_NULL_HANDLER,
66437 ZEND_STRLEN_SPEC_CV_HANDLER,
66438 ZEND_DEFINED_SPEC_CONST_HANDLER,
66439 ZEND_TYPE_CHECK_SPEC_CONST_HANDLER,
66440 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
66441 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
66442 ZEND_NULL_HANDLER,
66443 ZEND_TYPE_CHECK_SPEC_CV_HANDLER,
66444 ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER,
66445 ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER,
66446 ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER,
66447 ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
66448 ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER,
66449 ZEND_FE_RESET_RW_SPEC_CONST_HANDLER,
66450 ZEND_FE_RESET_RW_SPEC_TMP_HANDLER,
66451 ZEND_FE_RESET_RW_SPEC_VAR_HANDLER,
66452 ZEND_NULL_HANDLER,
66453 ZEND_FE_RESET_RW_SPEC_CV_HANDLER,
66454 ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER,
66455 ZEND_FE_FREE_SPEC_TMPVAR_HANDLER,
66456 ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER,
66457 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
66458 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
66459 ZEND_NULL_HANDLER,
66460 ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER,
66461 ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER,
66462 ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER,
66463 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
66464 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
66465 ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER,
66466 ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER,
66467 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
66468 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
66469 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER,
66470 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER,
66471 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER,
66472 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER,
66473 ZEND_NULL_HANDLER,
66474 ZEND_NULL_HANDLER,
66475 ZEND_NULL_HANDLER,
66476 ZEND_NULL_HANDLER,
66477 ZEND_NULL_HANDLER,
66478 ZEND_NULL_HANDLER,
66479 ZEND_NULL_HANDLER,
66480 ZEND_NULL_HANDLER,
66481 ZEND_NULL_HANDLER,
66482 ZEND_NULL_HANDLER,
66483 ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER,
66484 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66485 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66486 ZEND_NULL_HANDLER,
66487 ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER,
66488 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
66489 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66490 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66491 ZEND_NULL_HANDLER,
66492 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
66493 ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER,
66494 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66495 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66496 ZEND_NULL_HANDLER,
66497 ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER,
66498 ZEND_NULL_HANDLER,
66499 ZEND_NULL_HANDLER,
66500 ZEND_NULL_HANDLER,
66501 ZEND_NULL_HANDLER,
66502 ZEND_NULL_HANDLER,
66503 ZEND_NULL_HANDLER,
66504 ZEND_NULL_HANDLER,
66505 ZEND_NULL_HANDLER,
66506 ZEND_NULL_HANDLER,
66507 ZEND_NULL_HANDLER,
66508 ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER,
66509 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66510 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66511 ZEND_NULL_HANDLER,
66512 ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER,
66513 ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
66514 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66515 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66516 ZEND_NULL_HANDLER,
66517 ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
66518 ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER,
66519 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66520 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66521 ZEND_NULL_HANDLER,
66522 ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER,
66523 ZEND_ECHO_SPEC_CONST_HANDLER,
66524 ZEND_ECHO_SPEC_TMPVAR_HANDLER,
66525 ZEND_ECHO_SPEC_TMPVAR_HANDLER,
66526 ZEND_NULL_HANDLER,
66527 ZEND_ECHO_SPEC_CV_HANDLER,
66528 ZEND_NULL_HANDLER,
66529 ZEND_NULL_HANDLER,
66530 ZEND_NULL_HANDLER,
66531 ZEND_NULL_HANDLER,
66532 ZEND_NULL_HANDLER,
66533 ZEND_NULL_HANDLER,
66534 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
66535 ZEND_NULL_HANDLER,
66536 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
66537 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER,
66538 ZEND_NULL_HANDLER,
66539 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
66540 ZEND_NULL_HANDLER,
66541 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
66542 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER,
66543 ZEND_NULL_HANDLER,
66544 ZEND_NULL_HANDLER,
66545 ZEND_NULL_HANDLER,
66546 ZEND_NULL_HANDLER,
66547 ZEND_NULL_HANDLER,
66548 ZEND_NULL_HANDLER,
66549 ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER,
66550 ZEND_NULL_HANDLER,
66551 ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER,
66552 ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER,
66553 ZEND_NULL_HANDLER,
66554 ZEND_GENERATOR_CREATE_SPEC_HANDLER,
66555 ZEND_NULL_HANDLER,
66556 ZEND_NULL_HANDLER,
66557 ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER,
66558 ZEND_NULL_HANDLER,
66559 ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER,
66560 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
66561 ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER,
66562 ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER,
66563 ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER,
66564 ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER,
66565 ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER,
66566 ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER,
66567 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER,
66568 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66569 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66570 ZEND_NULL_HANDLER,
66571 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER,
66572 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66573 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66574 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66575 ZEND_NULL_HANDLER,
66576 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
66577 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66578 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66579 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66580 ZEND_NULL_HANDLER,
66581 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
66582 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER,
66583 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66584 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66585 ZEND_NULL_HANDLER,
66586 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER,
66587 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER,
66588 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
66589 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
66590 ZEND_NULL_HANDLER,
66591 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER,
66592 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
66593 ZEND_USER_OPCODE_SPEC_HANDLER,
66594 ZEND_ASSERT_CHECK_SPEC_HANDLER,
66595 ZEND_JMP_SET_SPEC_CONST_HANDLER,
66596 ZEND_JMP_SET_SPEC_TMP_HANDLER,
66597 ZEND_JMP_SET_SPEC_VAR_HANDLER,
66598 ZEND_NULL_HANDLER,
66599 ZEND_JMP_SET_SPEC_CV_HANDLER,
66600 ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER,
66601 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER,
66602 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER,
66603 ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER,
66604 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
66605 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
66606 ZEND_NULL_HANDLER,
66607 ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER,
66608 ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER,
66609 ZEND_NULL_HANDLER,
66610 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
66611 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
66612 ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER,
66613 ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER,
66614 ZEND_CALL_TRAMPOLINE_SPEC_HANDLER,
66615 ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER,
66616 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
66617 ZEND_YIELD_SPEC_CONST_CONST_HANDLER,
66618 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
66619 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
66620 ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER,
66621 ZEND_YIELD_SPEC_CONST_CV_HANDLER,
66622 ZEND_YIELD_SPEC_TMP_CONST_HANDLER,
66623 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
66624 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
66625 ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER,
66626 ZEND_YIELD_SPEC_TMP_CV_HANDLER,
66627 ZEND_YIELD_SPEC_VAR_CONST_HANDLER,
66628 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
66629 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
66630 ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER,
66631 ZEND_YIELD_SPEC_VAR_CV_HANDLER,
66632 ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER,
66633 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
66634 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
66635 ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER,
66636 ZEND_YIELD_SPEC_UNUSED_CV_HANDLER,
66637 ZEND_YIELD_SPEC_CV_CONST_HANDLER,
66638 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
66639 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
66640 ZEND_YIELD_SPEC_CV_UNUSED_HANDLER,
66641 ZEND_YIELD_SPEC_CV_CV_HANDLER,
66642 ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER,
66643 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66644 ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER,
66645 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66646 ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER,
66647 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66648 ZEND_NULL_HANDLER,
66649 ZEND_NULL_HANDLER,
66650 ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER,
66651 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66652 ZEND_FAST_CALL_SPEC_HANDLER,
66653 ZEND_FAST_RET_SPEC_HANDLER,
66654 ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER,
66655 ZEND_SEND_UNPACK_SPEC_HANDLER,
66656 ZEND_YIELD_FROM_SPEC_CONST_HANDLER,
66657 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
66658 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
66659 ZEND_NULL_HANDLER,
66660 ZEND_YIELD_FROM_SPEC_CV_HANDLER,
66661 ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER,
66662 ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER,
66663 ZEND_COALESCE_SPEC_CONST_HANDLER,
66664 ZEND_COALESCE_SPEC_TMP_HANDLER,
66665 ZEND_COALESCE_SPEC_VAR_HANDLER,
66666 ZEND_NULL_HANDLER,
66667 ZEND_COALESCE_SPEC_CV_HANDLER,
66668 ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER,
66669 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
66670 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
66671 ZEND_NULL_HANDLER,
66672 ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER,
66673 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
66674 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66675 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66676 ZEND_NULL_HANDLER,
66677 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
66678 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
66679 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66680 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66681 ZEND_NULL_HANDLER,
66682 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
66683 ZEND_NULL_HANDLER,
66684 ZEND_NULL_HANDLER,
66685 ZEND_NULL_HANDLER,
66686 ZEND_NULL_HANDLER,
66687 ZEND_NULL_HANDLER,
66688 ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER,
66689 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
66690 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
66691 ZEND_NULL_HANDLER,
66692 ZEND_SPACESHIP_SPEC_CV_CV_HANDLER,
66693 ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66694 ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER,
66695 ZEND_NULL_HANDLER,
66696 ZEND_NULL_HANDLER,
66697 ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66698 ZEND_NULL_HANDLER,
66699 ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER,
66700 ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER,
66701 ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER,
66702 ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER,
66703 ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER,
66704 ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER,
66705 ZEND_UNSET_STATIC_PROP_SPEC_HANDLER,
66706 ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER,
66707 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER,
66708 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66709 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66710 ZEND_NULL_HANDLER,
66711 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66712 ZEND_NULL_HANDLER,
66713 ZEND_NULL_HANDLER,
66714 ZEND_NULL_HANDLER,
66715 ZEND_NULL_HANDLER,
66716 ZEND_NULL_HANDLER,
66717 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER,
66718 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66719 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66720 ZEND_NULL_HANDLER,
66721 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66722 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
66723 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66724 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66725 ZEND_NULL_HANDLER,
66726 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66727 ZEND_NULL_HANDLER,
66728 ZEND_NULL_HANDLER,
66729 ZEND_NULL_HANDLER,
66730 ZEND_NULL_HANDLER,
66731 ZEND_NULL_HANDLER,
66732 ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER,
66733 ZEND_BIND_STATIC_SPEC_CV_HANDLER,
66734 ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER,
66735 ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66736 ZEND_NULL_HANDLER,
66737 ZEND_NULL_HANDLER,
66738 ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
66739 ZEND_NULL_HANDLER,
66740 ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER,
66741 ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER,
66742 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66743 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66744 ZEND_NULL_HANDLER,
66745 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66746 ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER,
66747 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66748 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66749 ZEND_NULL_HANDLER,
66750 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66751 ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER,
66752 ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER,
66753 ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER,
66754 ZEND_NULL_HANDLER,
66755 ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER,
66756 ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER,
66757 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
66758 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
66759 ZEND_NULL_HANDLER,
66760 ZEND_COUNT_SPEC_CV_UNUSED_HANDLER,
66761 ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER,
66762 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
66763 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
66764 ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66765 ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER,
66766 ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66767 ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER,
66768 ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER,
66769 ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER,
66770 ZEND_NULL_HANDLER,
66771 ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER,
66772 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER,
66773 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
66774 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
66775 ZEND_NULL_HANDLER,
66776 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER,
66777 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
66778 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66779 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66780 ZEND_NULL_HANDLER,
66781 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
66782 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
66783 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66784 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66785 ZEND_NULL_HANDLER,
66786 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
66787 ZEND_NULL_HANDLER,
66788 ZEND_NULL_HANDLER,
66789 ZEND_NULL_HANDLER,
66790 ZEND_NULL_HANDLER,
66791 ZEND_NULL_HANDLER,
66792 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER,
66793 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
66794 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
66795 ZEND_NULL_HANDLER,
66796 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER,
66797 ZEND_MATCH_SPEC_CONST_CONST_HANDLER,
66798 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66799 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66800 ZEND_NULL_HANDLER,
66801 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66802 ZEND_NULL_HANDLER,
66803 ZEND_NULL_HANDLER,
66804 ZEND_NULL_HANDLER,
66805 ZEND_NULL_HANDLER,
66806 ZEND_NULL_HANDLER,
66807 ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER,
66808 ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER,
66809 ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER,
66810 ZEND_NULL_HANDLER,
66811 ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER,
66812 ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER,
66813 ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER,
66814 ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER,
66815 ZEND_NULL_HANDLER,
66816 ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER,
66817 ZEND_NULL_HANDLER,
66818 ZEND_NULL_HANDLER,
66819 ZEND_NULL_HANDLER,
66820 ZEND_NULL_HANDLER,
66821 ZEND_NULL_HANDLER,
66822 ZEND_NULL_HANDLER,
66823 ZEND_NULL_HANDLER,
66824 ZEND_NULL_HANDLER,
66825 ZEND_NULL_HANDLER,
66826 ZEND_NULL_HANDLER,
66827 ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER,
66828 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66829 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66830 ZEND_NULL_HANDLER,
66831 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66832 ZEND_JMP_NULL_SPEC_CONST_HANDLER,
66833 ZEND_JMP_NULL_SPEC_TMP_HANDLER,
66834 ZEND_JMP_NULL_SPEC_VAR_HANDLER,
66835 ZEND_NULL_HANDLER,
66836 ZEND_JMP_NULL_SPEC_CV_HANDLER,
66837 ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66838 ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER,
66839 ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
66840 ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER,
66841 ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER,
66842 ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER,
66843 ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER,
66844 ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER,
66845 ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER,
66846 ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER,
66847 ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER,
66848 ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER,
66849 ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER,
66850 ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER,
66851 ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER,
66852 ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER,
66853 ZEND_RECV_NOTYPE_SPEC_HANDLER,
66854 ZEND_NULL_HANDLER,
66855 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
66856 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
66857 ZEND_NULL_HANDLER,
66858 ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER,
66859 ZEND_JMP_FORWARD_SPEC_HANDLER,
66860 ZEND_NULL_HANDLER,
66861 ZEND_NULL_HANDLER,
66862 ZEND_NULL_HANDLER,
66863 ZEND_NULL_HANDLER,
66864 ZEND_NULL_HANDLER,
66865 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66866 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66867 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66868 ZEND_NULL_HANDLER,
66869 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66870 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66871 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66872 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66873 ZEND_NULL_HANDLER,
66874 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66875 ZEND_NULL_HANDLER,
66876 ZEND_NULL_HANDLER,
66877 ZEND_NULL_HANDLER,
66878 ZEND_NULL_HANDLER,
66879 ZEND_NULL_HANDLER,
66880 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66881 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66882 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66883 ZEND_NULL_HANDLER,
66884 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66885 ZEND_NULL_HANDLER,
66886 ZEND_NULL_HANDLER,
66887 ZEND_NULL_HANDLER,
66888 ZEND_NULL_HANDLER,
66889 ZEND_NULL_HANDLER,
66890 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66891 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66892 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66893 ZEND_NULL_HANDLER,
66894 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66895 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66896 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66897 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66898 ZEND_NULL_HANDLER,
66899 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66900 ZEND_NULL_HANDLER,
66901 ZEND_NULL_HANDLER,
66902 ZEND_NULL_HANDLER,
66903 ZEND_NULL_HANDLER,
66904 ZEND_NULL_HANDLER,
66905 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66906 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66907 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66908 ZEND_NULL_HANDLER,
66909 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66910 ZEND_NULL_HANDLER,
66911 ZEND_NULL_HANDLER,
66912 ZEND_NULL_HANDLER,
66913 ZEND_NULL_HANDLER,
66914 ZEND_NULL_HANDLER,
66915 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66916 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66917 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66918 ZEND_NULL_HANDLER,
66919 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66920 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66921 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66922 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66923 ZEND_NULL_HANDLER,
66924 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66925 ZEND_NULL_HANDLER,
66926 ZEND_NULL_HANDLER,
66927 ZEND_NULL_HANDLER,
66928 ZEND_NULL_HANDLER,
66929 ZEND_NULL_HANDLER,
66930 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66931 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66932 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66933 ZEND_NULL_HANDLER,
66934 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66935 ZEND_NULL_HANDLER,
66936 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
66937 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
66938 ZEND_NULL_HANDLER,
66939 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
66940 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66941 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66942 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66943 ZEND_NULL_HANDLER,
66944 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66945 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66946 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66947 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66948 ZEND_NULL_HANDLER,
66949 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66950 ZEND_NULL_HANDLER,
66951 ZEND_NULL_HANDLER,
66952 ZEND_NULL_HANDLER,
66953 ZEND_NULL_HANDLER,
66954 ZEND_NULL_HANDLER,
66955 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66956 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66957 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66958 ZEND_NULL_HANDLER,
66959 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66960 ZEND_NULL_HANDLER,
66961 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66962 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66963 ZEND_NULL_HANDLER,
66964 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66965 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66966 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66967 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66968 ZEND_NULL_HANDLER,
66969 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66970 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66971 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66972 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66973 ZEND_NULL_HANDLER,
66974 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66975 ZEND_NULL_HANDLER,
66976 ZEND_NULL_HANDLER,
66977 ZEND_NULL_HANDLER,
66978 ZEND_NULL_HANDLER,
66979 ZEND_NULL_HANDLER,
66980 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66981 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66982 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66983 ZEND_NULL_HANDLER,
66984 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66985 ZEND_NULL_HANDLER,
66986 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66987 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66988 ZEND_NULL_HANDLER,
66989 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66990 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66991 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66992 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66993 ZEND_NULL_HANDLER,
66994 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66995 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66996 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66997 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66998 ZEND_NULL_HANDLER,
66999 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67000 ZEND_NULL_HANDLER,
67001 ZEND_NULL_HANDLER,
67002 ZEND_NULL_HANDLER,
67003 ZEND_NULL_HANDLER,
67004 ZEND_NULL_HANDLER,
67005 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67006 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67007 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67008 ZEND_NULL_HANDLER,
67009 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67010 ZEND_NULL_HANDLER,
67011 ZEND_NULL_HANDLER,
67012 ZEND_NULL_HANDLER,
67013 ZEND_NULL_HANDLER,
67014 ZEND_NULL_HANDLER,
67015 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67016 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67017 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67018 ZEND_NULL_HANDLER,
67019 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67020 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67021 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67022 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67023 ZEND_NULL_HANDLER,
67024 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67025 ZEND_NULL_HANDLER,
67026 ZEND_NULL_HANDLER,
67027 ZEND_NULL_HANDLER,
67028 ZEND_NULL_HANDLER,
67029 ZEND_NULL_HANDLER,
67030 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
67031 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67032 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67033 ZEND_NULL_HANDLER,
67034 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67035 ZEND_NULL_HANDLER,
67036 ZEND_NULL_HANDLER,
67037 ZEND_NULL_HANDLER,
67038 ZEND_NULL_HANDLER,
67039 ZEND_NULL_HANDLER,
67040 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67041 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67042 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67043 ZEND_NULL_HANDLER,
67044 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67045 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67046 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67047 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67048 ZEND_NULL_HANDLER,
67049 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67050 ZEND_NULL_HANDLER,
67051 ZEND_NULL_HANDLER,
67052 ZEND_NULL_HANDLER,
67053 ZEND_NULL_HANDLER,
67054 ZEND_NULL_HANDLER,
67055 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67056 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67057 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67058 ZEND_NULL_HANDLER,
67059 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67060 ZEND_NULL_HANDLER,
67061 ZEND_NULL_HANDLER,
67062 ZEND_NULL_HANDLER,
67063 ZEND_NULL_HANDLER,
67064 ZEND_NULL_HANDLER,
67065 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67066 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67067 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67068 ZEND_NULL_HANDLER,
67069 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67070 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67071 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67072 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67073 ZEND_NULL_HANDLER,
67074 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67075 ZEND_NULL_HANDLER,
67076 ZEND_NULL_HANDLER,
67077 ZEND_NULL_HANDLER,
67078 ZEND_NULL_HANDLER,
67079 ZEND_NULL_HANDLER,
67080 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67081 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67082 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67083 ZEND_NULL_HANDLER,
67084 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67085 ZEND_NULL_HANDLER,
67086 ZEND_NULL_HANDLER,
67087 ZEND_NULL_HANDLER,
67088 ZEND_NULL_HANDLER,
67089 ZEND_NULL_HANDLER,
67090 ZEND_NULL_HANDLER,
67091 ZEND_NULL_HANDLER,
67092 ZEND_NULL_HANDLER,
67093 ZEND_NULL_HANDLER,
67094 ZEND_NULL_HANDLER,
67095 ZEND_NULL_HANDLER,
67096 ZEND_NULL_HANDLER,
67097 ZEND_NULL_HANDLER,
67098 ZEND_NULL_HANDLER,
67099 ZEND_NULL_HANDLER,
67100 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67101 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67102 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67103 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67104 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67105 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67106 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67107 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67108 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67109 ZEND_NULL_HANDLER,
67110 ZEND_NULL_HANDLER,
67111 ZEND_NULL_HANDLER,
67112 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67113 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67114 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67115 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67116 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67117 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67118 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67119 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67120 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67121 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67122 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67123 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67124 ZEND_NULL_HANDLER,
67125 ZEND_NULL_HANDLER,
67126 ZEND_NULL_HANDLER,
67127 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67128 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67129 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67130 ZEND_NULL_HANDLER,
67131 ZEND_NULL_HANDLER,
67132 ZEND_NULL_HANDLER,
67133 ZEND_NULL_HANDLER,
67134 ZEND_NULL_HANDLER,
67135 ZEND_NULL_HANDLER,
67136 ZEND_NULL_HANDLER,
67137 ZEND_NULL_HANDLER,
67138 ZEND_NULL_HANDLER,
67139 ZEND_NULL_HANDLER,
67140 ZEND_NULL_HANDLER,
67141 ZEND_NULL_HANDLER,
67142 ZEND_NULL_HANDLER,
67143 ZEND_NULL_HANDLER,
67144 ZEND_NULL_HANDLER,
67145 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67146 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67147 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67148 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67149 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67150 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67151 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67152 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67153 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67154 ZEND_NULL_HANDLER,
67155 ZEND_NULL_HANDLER,
67156 ZEND_NULL_HANDLER,
67157 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67158 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67159 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67160 ZEND_NULL_HANDLER,
67161 ZEND_NULL_HANDLER,
67162 ZEND_NULL_HANDLER,
67163 ZEND_NULL_HANDLER,
67164 ZEND_NULL_HANDLER,
67165 ZEND_NULL_HANDLER,
67166 ZEND_NULL_HANDLER,
67167 ZEND_NULL_HANDLER,
67168 ZEND_NULL_HANDLER,
67169 ZEND_NULL_HANDLER,
67170 ZEND_NULL_HANDLER,
67171 ZEND_NULL_HANDLER,
67172 ZEND_NULL_HANDLER,
67173 ZEND_NULL_HANDLER,
67174 ZEND_NULL_HANDLER,
67175 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67176 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67177 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67178 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67179 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67180 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67181 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67182 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67183 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67184 ZEND_NULL_HANDLER,
67185 ZEND_NULL_HANDLER,
67186 ZEND_NULL_HANDLER,
67187 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67188 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67189 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67190 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67191 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67192 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67193 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67194 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67195 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67196 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67197 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67198 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67199 ZEND_NULL_HANDLER,
67200 ZEND_NULL_HANDLER,
67201 ZEND_NULL_HANDLER,
67202 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67203 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67204 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67205 ZEND_NULL_HANDLER,
67206 ZEND_NULL_HANDLER,
67207 ZEND_NULL_HANDLER,
67208 ZEND_NULL_HANDLER,
67209 ZEND_NULL_HANDLER,
67210 ZEND_NULL_HANDLER,
67211 ZEND_NULL_HANDLER,
67212 ZEND_NULL_HANDLER,
67213 ZEND_NULL_HANDLER,
67214 ZEND_NULL_HANDLER,
67215 ZEND_NULL_HANDLER,
67216 ZEND_NULL_HANDLER,
67217 ZEND_NULL_HANDLER,
67218 ZEND_NULL_HANDLER,
67219 ZEND_NULL_HANDLER,
67220 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67221 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67222 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67223 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67224 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67225 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67226 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67227 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67228 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67229 ZEND_NULL_HANDLER,
67230 ZEND_NULL_HANDLER,
67231 ZEND_NULL_HANDLER,
67232 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67233 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67234 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67235 ZEND_NULL_HANDLER,
67236 ZEND_NULL_HANDLER,
67237 ZEND_NULL_HANDLER,
67238 ZEND_NULL_HANDLER,
67239 ZEND_NULL_HANDLER,
67240 ZEND_NULL_HANDLER,
67241 ZEND_NULL_HANDLER,
67242 ZEND_NULL_HANDLER,
67243 ZEND_NULL_HANDLER,
67244 ZEND_NULL_HANDLER,
67245 ZEND_NULL_HANDLER,
67246 ZEND_NULL_HANDLER,
67247 ZEND_NULL_HANDLER,
67248 ZEND_NULL_HANDLER,
67249 ZEND_NULL_HANDLER,
67250 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67251 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67252 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67253 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67254 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67255 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67256 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67257 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67258 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67259 ZEND_NULL_HANDLER,
67260 ZEND_NULL_HANDLER,
67261 ZEND_NULL_HANDLER,
67262 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67263 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67264 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67265 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67266 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67267 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67268 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67269 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67270 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67271 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67272 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67273 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67274 ZEND_NULL_HANDLER,
67275 ZEND_NULL_HANDLER,
67276 ZEND_NULL_HANDLER,
67277 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67278 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67279 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67280 ZEND_NULL_HANDLER,
67281 ZEND_NULL_HANDLER,
67282 ZEND_NULL_HANDLER,
67283 ZEND_NULL_HANDLER,
67284 ZEND_NULL_HANDLER,
67285 ZEND_NULL_HANDLER,
67286 ZEND_NULL_HANDLER,
67287 ZEND_NULL_HANDLER,
67288 ZEND_NULL_HANDLER,
67289 ZEND_NULL_HANDLER,
67290 ZEND_NULL_HANDLER,
67291 ZEND_NULL_HANDLER,
67292 ZEND_NULL_HANDLER,
67293 ZEND_NULL_HANDLER,
67294 ZEND_NULL_HANDLER,
67295 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67296 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67297 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67298 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67299 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67300 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67301 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67302 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67303 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67304 ZEND_NULL_HANDLER,
67305 ZEND_NULL_HANDLER,
67306 ZEND_NULL_HANDLER,
67307 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67308 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67309 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67310 ZEND_NULL_HANDLER,
67311 ZEND_NULL_HANDLER,
67312 ZEND_NULL_HANDLER,
67313 ZEND_NULL_HANDLER,
67314 ZEND_NULL_HANDLER,
67315 ZEND_NULL_HANDLER,
67316 ZEND_NULL_HANDLER,
67317 ZEND_NULL_HANDLER,
67318 ZEND_NULL_HANDLER,
67319 ZEND_NULL_HANDLER,
67320 ZEND_NULL_HANDLER,
67321 ZEND_NULL_HANDLER,
67322 ZEND_NULL_HANDLER,
67323 ZEND_NULL_HANDLER,
67324 ZEND_NULL_HANDLER,
67325 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67326 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67327 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67328 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67329 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67330 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67331 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67332 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67333 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67334 ZEND_NULL_HANDLER,
67335 ZEND_NULL_HANDLER,
67336 ZEND_NULL_HANDLER,
67337 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67338 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67339 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67340 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67341 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67342 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67343 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67344 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67345 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67346 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67347 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67348 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67349 ZEND_NULL_HANDLER,
67350 ZEND_NULL_HANDLER,
67351 ZEND_NULL_HANDLER,
67352 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67353 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67354 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67355 ZEND_NULL_HANDLER,
67356 ZEND_NULL_HANDLER,
67357 ZEND_NULL_HANDLER,
67358 ZEND_NULL_HANDLER,
67359 ZEND_NULL_HANDLER,
67360 ZEND_NULL_HANDLER,
67361 ZEND_NULL_HANDLER,
67362 ZEND_NULL_HANDLER,
67363 ZEND_NULL_HANDLER,
67364 ZEND_NULL_HANDLER,
67365 ZEND_NULL_HANDLER,
67366 ZEND_NULL_HANDLER,
67367 ZEND_NULL_HANDLER,
67368 ZEND_NULL_HANDLER,
67369 ZEND_NULL_HANDLER,
67370 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67371 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67372 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67373 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67374 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67375 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67376 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67377 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67378 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67379 ZEND_NULL_HANDLER,
67380 ZEND_NULL_HANDLER,
67381 ZEND_NULL_HANDLER,
67382 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67383 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67384 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67385 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
67386 ZEND_NULL_HANDLER,
67387 ZEND_NULL_HANDLER,
67388 ZEND_NULL_HANDLER,
67389 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
67390 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
67391 ZEND_NULL_HANDLER,
67392 ZEND_NULL_HANDLER,
67393 ZEND_NULL_HANDLER,
67394 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
67395 ZEND_NULL_HANDLER,
67396 ZEND_NULL_HANDLER,
67397 ZEND_NULL_HANDLER,
67398 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67399 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67400 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67401 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67402 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67403 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67404 ZEND_NULL_HANDLER,
67405 ZEND_NULL_HANDLER,
67406 ZEND_NULL_HANDLER,
67407 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67408 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67409 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67410 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67411 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67412 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67413 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67414 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67415 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67416 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67417 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67418 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67419 ZEND_NULL_HANDLER,
67420 ZEND_NULL_HANDLER,
67421 ZEND_NULL_HANDLER,
67422 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67423 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67424 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67425 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67426 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67427 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67428 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67429 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67430 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67431 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67432 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67433 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67434 ZEND_NULL_HANDLER,
67435 ZEND_NULL_HANDLER,
67436 ZEND_NULL_HANDLER,
67437 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67438 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67439 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67440 ZEND_NULL_HANDLER,
67441 ZEND_NULL_HANDLER,
67442 ZEND_NULL_HANDLER,
67443 ZEND_NULL_HANDLER,
67444 ZEND_NULL_HANDLER,
67445 ZEND_NULL_HANDLER,
67446 ZEND_NULL_HANDLER,
67447 ZEND_NULL_HANDLER,
67448 ZEND_NULL_HANDLER,
67449 ZEND_NULL_HANDLER,
67450 ZEND_NULL_HANDLER,
67451 ZEND_NULL_HANDLER,
67452 ZEND_NULL_HANDLER,
67453 ZEND_NULL_HANDLER,
67454 ZEND_NULL_HANDLER,
67455 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67456 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67457 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67458 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67459 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67460 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67461 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67462 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67463 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67464 ZEND_NULL_HANDLER,
67465 ZEND_NULL_HANDLER,
67466 ZEND_NULL_HANDLER,
67467 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67468 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67469 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67470 ZEND_NULL_HANDLER,
67471 ZEND_NULL_HANDLER,
67472 ZEND_NULL_HANDLER,
67473 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67474 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67475 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67476 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67477 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67478 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67479 ZEND_NULL_HANDLER,
67480 ZEND_NULL_HANDLER,
67481 ZEND_NULL_HANDLER,
67482 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67483 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67484 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67485 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67486 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67487 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67488 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67489 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67490 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67491 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67492 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67493 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67494 ZEND_NULL_HANDLER,
67495 ZEND_NULL_HANDLER,
67496 ZEND_NULL_HANDLER,
67497 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67498 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67499 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67500 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67501 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67502 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67503 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67504 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67505 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67506 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67507 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67508 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67509 ZEND_NULL_HANDLER,
67510 ZEND_NULL_HANDLER,
67511 ZEND_NULL_HANDLER,
67512 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67513 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67514 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67515 ZEND_NULL_HANDLER,
67516 ZEND_NULL_HANDLER,
67517 ZEND_NULL_HANDLER,
67518 ZEND_NULL_HANDLER,
67519 ZEND_NULL_HANDLER,
67520 ZEND_NULL_HANDLER,
67521 ZEND_NULL_HANDLER,
67522 ZEND_NULL_HANDLER,
67523 ZEND_NULL_HANDLER,
67524 ZEND_NULL_HANDLER,
67525 ZEND_NULL_HANDLER,
67526 ZEND_NULL_HANDLER,
67527 ZEND_NULL_HANDLER,
67528 ZEND_NULL_HANDLER,
67529 ZEND_NULL_HANDLER,
67530 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67531 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67532 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67533 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67534 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67535 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67536 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67537 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67538 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67539 ZEND_NULL_HANDLER,
67540 ZEND_NULL_HANDLER,
67541 ZEND_NULL_HANDLER,
67542 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67543 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67544 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67545 ZEND_NULL_HANDLER,
67546 ZEND_NULL_HANDLER,
67547 ZEND_NULL_HANDLER,
67548 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67549 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67550 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67551 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67552 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67553 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67554 ZEND_NULL_HANDLER,
67555 ZEND_NULL_HANDLER,
67556 ZEND_NULL_HANDLER,
67557 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67558 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67559 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67560 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67561 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67562 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67563 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67564 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67565 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67566 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67567 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67568 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67569 ZEND_NULL_HANDLER,
67570 ZEND_NULL_HANDLER,
67571 ZEND_NULL_HANDLER,
67572 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67573 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67574 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67575 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67576 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67577 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67578 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67579 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67580 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67581 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67582 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67583 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67584 ZEND_NULL_HANDLER,
67585 ZEND_NULL_HANDLER,
67586 ZEND_NULL_HANDLER,
67587 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67588 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67589 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67590 ZEND_NULL_HANDLER,
67591 ZEND_NULL_HANDLER,
67592 ZEND_NULL_HANDLER,
67593 ZEND_NULL_HANDLER,
67594 ZEND_NULL_HANDLER,
67595 ZEND_NULL_HANDLER,
67596 ZEND_NULL_HANDLER,
67597 ZEND_NULL_HANDLER,
67598 ZEND_NULL_HANDLER,
67599 ZEND_NULL_HANDLER,
67600 ZEND_NULL_HANDLER,
67601 ZEND_NULL_HANDLER,
67602 ZEND_NULL_HANDLER,
67603 ZEND_NULL_HANDLER,
67604 ZEND_NULL_HANDLER,
67605 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67606 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67607 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67608 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67609 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67610 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67611 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67612 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67613 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67614 ZEND_NULL_HANDLER,
67615 ZEND_NULL_HANDLER,
67616 ZEND_NULL_HANDLER,
67617 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67618 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67619 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67620 ZEND_NULL_HANDLER,
67621 ZEND_NULL_HANDLER,
67622 ZEND_NULL_HANDLER,
67623 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67624 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67625 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67626 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67627 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67628 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67629 ZEND_NULL_HANDLER,
67630 ZEND_NULL_HANDLER,
67631 ZEND_NULL_HANDLER,
67632 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67633 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67634 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67635 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67636 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67637 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67638 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67639 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67640 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67641 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67642 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67643 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67644 ZEND_NULL_HANDLER,
67645 ZEND_NULL_HANDLER,
67646 ZEND_NULL_HANDLER,
67647 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67648 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67649 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67650 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67651 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67652 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67653 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67654 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67655 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67656 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67657 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67658 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67659 ZEND_NULL_HANDLER,
67660 ZEND_NULL_HANDLER,
67661 ZEND_NULL_HANDLER,
67662 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67663 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67664 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67665 ZEND_NULL_HANDLER,
67666 ZEND_NULL_HANDLER,
67667 ZEND_NULL_HANDLER,
67668 ZEND_NULL_HANDLER,
67669 ZEND_NULL_HANDLER,
67670 ZEND_NULL_HANDLER,
67671 ZEND_NULL_HANDLER,
67672 ZEND_NULL_HANDLER,
67673 ZEND_NULL_HANDLER,
67674 ZEND_NULL_HANDLER,
67675 ZEND_NULL_HANDLER,
67676 ZEND_NULL_HANDLER,
67677 ZEND_NULL_HANDLER,
67678 ZEND_NULL_HANDLER,
67679 ZEND_NULL_HANDLER,
67680 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67681 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67682 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67683 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67684 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67685 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67686 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67687 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67688 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67689 ZEND_NULL_HANDLER,
67690 ZEND_NULL_HANDLER,
67691 ZEND_NULL_HANDLER,
67692 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67693 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67694 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67695 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
67696 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
67697 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
67698 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
67699 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
67700 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
67701 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
67702 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
67703 ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
67704 ZEND_POST_INC_LONG_SPEC_CV_HANDLER,
67705 ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
67706 ZEND_POST_DEC_LONG_SPEC_CV_HANDLER,
67707 ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER,
67708 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67709 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67710 ZEND_NULL_HANDLER,
67711 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67712 ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER,
67713 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67714 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67715 ZEND_NULL_HANDLER,
67716 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67717 ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER,
67718 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67719 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67720 ZEND_NULL_HANDLER,
67721 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67722 ZEND_NULL_HANDLER,
67723 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67724 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67725 ZEND_NULL_HANDLER,
67726 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67727 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
67728 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67729 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67730 ZEND_NULL_HANDLER,
67731 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67732 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
67733 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67734 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67735 ZEND_NULL_HANDLER,
67736 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67737 ZEND_NULL_HANDLER,
67738 ZEND_NULL_HANDLER,
67739 ZEND_NULL_HANDLER,
67740 ZEND_NULL_HANDLER,
67741 ZEND_NULL_HANDLER,
67742 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER,
67743 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67744 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67745 ZEND_NULL_HANDLER,
67746 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67747 ZEND_NULL_HANDLER,
67748 ZEND_NULL_HANDLER,
67749 ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER,
67750 ZEND_NULL_HANDLER,
67751 ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER,
67752 ZEND_NULL_HANDLER,
67753 ZEND_NULL_HANDLER,
67754 ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER,
67755 ZEND_NULL_HANDLER,
67756 ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER,
67757 ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER,
67758 ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER,
67759 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
67760 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER,
67761 ZEND_NULL_HANDLER
67762 };
67763 static const uint32_t specs[] = {
67764 0,
67765 1 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67766 26 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67767 51 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67768 76 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67769 101 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67770 126 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67771 151 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67772 176 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67773 201 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67774 226 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67775 251 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67776 276 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67777 301 | SPEC_RULE_OP1,
67778 306 | SPEC_RULE_OP1,
67779 311 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67780 336 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67781 361 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67782 386 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
67783 461 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
67784 536 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
67785 611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
67786 686 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL,
67787 736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67788 861 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67789 986 | SPEC_RULE_OP_DATA,
67790 991 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67791 1016 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67792 1041 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67793 1066,
67794 1067 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67795 1092 | SPEC_RULE_OP1,
67796 1097 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67797 1222,
67798 1223 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
67799 1233 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
67800 1243 | SPEC_RULE_OP1,
67801 1248 | SPEC_RULE_OP1,
67802 1253,
67803 1253,
67804 1254,
67805 1254,
67806 1255,
67807 1256 | SPEC_RULE_OP1,
67808 1261 | SPEC_RULE_OP1,
67809 3486,
67810 1266 | SPEC_RULE_OP1,
67811 1271 | SPEC_RULE_OP1,
67812 1276 | SPEC_RULE_OP2,
67813 1281,
67814 1282 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67815 1292 | SPEC_RULE_OP1,
67816 1297 | SPEC_RULE_OP1,
67817 1302 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67818 1327 | SPEC_RULE_OP2,
67819 1332 | SPEC_RULE_OP2,
67820 1337 | SPEC_RULE_OP2,
67821 1342,
67822 1343,
67823 1344,
67824 1345 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
67825 1349,
67826 1350 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67827 1360,
67828 1361,
67829 1362 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67830 1387 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67831 1437 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67832 1462 | SPEC_RULE_OP1,
67833 1467,
67834 1468,
67835 1469 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67836 1494 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67837 1519 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67838 1529 | SPEC_RULE_OP1,
67839 1534 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67840 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67841 1584 | SPEC_RULE_OP1,
67842 1589,
67843 3486,
67844 1590 | SPEC_RULE_OP1,
67845 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67846 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67847 1645 | SPEC_RULE_OP1,
67848 1650 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67849 1675 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67850 1700 | SPEC_RULE_OP1,
67851 1705 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67852 1730 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67853 1755 | SPEC_RULE_OP1,
67854 1760 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67855 1785 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67856 1810 | SPEC_RULE_OP1,
67857 1815 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67858 1840 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67859 1865 | SPEC_RULE_OP1,
67860 1870 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67861 1895 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67862 1920 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67863 1945,
67864 1946 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67865 1956,
67866 1957,
67867 1958,
67868 1959,
67869 1960,
67870 1961 | SPEC_RULE_OP2,
67871 1966,
67872 1967 | SPEC_RULE_OP1,
67873 1972 | SPEC_RULE_OP2,
67874 1977 | SPEC_RULE_OP1,
67875 1982 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67876 1992 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67877 2017 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67878 2042 | SPEC_RULE_OP1,
67879 2047 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67880 2072 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67881 2122 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67882 2147 | SPEC_RULE_OP2,
67883 2152,
67884 2153 | SPEC_RULE_OP1,
67885 2158 | SPEC_RULE_OP1,
67886 2163,
67887 2164 | SPEC_RULE_OP1,
67888 2169 | SPEC_RULE_OP1,
67889 2174 | SPEC_RULE_OP1,
67890 2179,
67891 2180,
67892 2181 | SPEC_RULE_OP2,
67893 2186 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
67894 2190 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
67895 2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
67896 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67897 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67898 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67899 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67900 2248 | SPEC_RULE_OP1,
67901 2253,
67902 2254 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67903 2279,
67904 2280 | SPEC_RULE_OP1,
67905 2285,
67906 2286,
67907 2287,
67908 2288,
67909 2289,
67910 2290,
67911 2291,
67912 2292 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67913 2317,
67914 2318,
67915 2319,
67916 2320 | SPEC_RULE_OP1,
67917 2325,
67918 2326 | SPEC_RULE_ISSET,
67919 2328 | SPEC_RULE_OP2,
67920 2333,
67921 2334 | SPEC_RULE_OP1,
67922 2339 | SPEC_RULE_OBSERVER,
67923 2341,
67924 2342 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67925 2367 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67926 2377,
67927 2378,
67928 2379,
67929 2380,
67930 2381 | SPEC_RULE_OP1,
67931 2386,
67932 2387,
67933 2388 | SPEC_RULE_OP1,
67934 2393 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67935 2418,
67936 2419 | SPEC_RULE_OP1,
67937 2424,
67938 2425,
67939 2426,
67940 2427,
67941 2428,
67942 2429,
67943 2430,
67944 2431,
67945 2432 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67946 2457,
67947 2458,
67948 2459,
67949 2460 | SPEC_RULE_OP2,
67950 2465,
67951 2466 | SPEC_RULE_OP1,
67952 2471 | SPEC_RULE_OP1,
67953 2476 | SPEC_RULE_OP1,
67954 2481 | SPEC_RULE_OP1,
67955 2486 | SPEC_RULE_OP1,
67956 2491,
67957 2492 | SPEC_RULE_OP1,
67958 2497 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67959 2522 | SPEC_RULE_OP1,
67960 2527 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67961 2552 | SPEC_RULE_OP1,
67962 2557 | SPEC_RULE_OP1,
67963 2562,
67964 2563,
67965 2564,
67966 2565,
67967 2566,
67968 2567 | SPEC_RULE_OBSERVER,
67969 2569 | SPEC_RULE_OBSERVER,
67970 2571 | SPEC_RULE_OBSERVER,
67971 2573 | SPEC_RULE_OBSERVER,
67972 2575,
67973 2576,
67974 3486,
67975 3486,
67976 3486,
67977 3486,
67978 3486,
67979 3486,
67980 3486,
67981 3486,
67982 3486,
67983 3486,
67984 3486,
67985 3486,
67986 3486,
67987 3486,
67988 3486,
67989 3486,
67990 3486,
67991 3486,
67992 3486,
67993 3486,
67994 3486,
67995 3486,
67996 3486,
67997 3486,
67998 3486,
67999 3486,
68000 3486,
68001 3486,
68002 3486,
68003 3486,
68004 3486,
68005 3486,
68006 3486,
68007 3486,
68008 3486,
68009 3486,
68010 3486,
68011 3486,
68012 3486,
68013 3486,
68014 3486,
68015 3486,
68016 3486,
68017 3486,
68018 3486,
68019 3486,
68020 };
68021#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
68022 zend_opcode_handler_funcs = labels;
68023 zend_spec_handlers = specs;
68024 execute_ex(NULL);
68025#else
68026 zend_opcode_handlers = labels;
68027 zend_handlers_count = sizeof(labels) / sizeof(void*);
68028 zend_spec_handlers = specs;
68029#endif
68030 VM_TRACE_START();
68031}
68032
68033static HashTable *zend_handlers_table = NULL;
68034
68035void zend_vm_dtor(void)
68036{
68037 VM_TRACE_END();
68038 if (zend_handlers_table) {
68039 zend_hash_destroy(zend_handlers_table);
68040 free(zend_handlers_table);
68041 zend_handlers_table = NULL;
68042 }
68043}
68044
68045static void init_opcode_serialiser(void)
68046{
68047 int i;
68048 zval tmp;
68049
68050 zend_handlers_table = malloc(sizeof(HashTable));
68051 zend_hash_init(zend_handlers_table, zend_handlers_count, NULL, NULL, 1);
68052 zend_hash_real_init(zend_handlers_table, 0);
68053 Z_TYPE_INFO(tmp) = IS_LONG;
68054 for (i = 0; i < zend_handlers_count; i++) {
68055 Z_LVAL(tmp) = i;
68056 zend_hash_index_add(zend_handlers_table, (zend_long)(uintptr_t)zend_opcode_handlers[i], &tmp);
68057 }
68058}
68059
68060ZEND_API void ZEND_FASTCALL zend_serialize_opcode_handler(zend_op *op)
68061{
68062 zval *zv;
68063
68064 if (!zend_handlers_table) {
68065 init_opcode_serialiser();
68066 }
68067 zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
68068 ZEND_ASSERT(zv != NULL);
68069 op->handler = (const void *)(uintptr_t)Z_LVAL_P(zv);
68070}
68071
68072ZEND_API void ZEND_FASTCALL zend_deserialize_opcode_handler(zend_op *op)
68073{
68074 op->handler = zend_opcode_handlers[(uintptr_t)op->handler];
68075}
68076
68077ZEND_API const void* ZEND_FASTCALL zend_get_opcode_handler_func(const zend_op *op)
68078{
68079#if ZEND_VM_KIND == ZEND_VM_KIND_CALL
68080 return op->handler;
68081#elif ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68082 zval *zv;
68083
68084 if (!zend_handlers_table) {
68085 init_opcode_serialiser();
68086 }
68087 zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
68088 ZEND_ASSERT(zv != NULL);
68089 return zend_opcode_handler_funcs[Z_LVAL_P(zv)];
68090#else
68091 return NULL;
68092#endif
68093}
68094
68095ZEND_API const zend_op *zend_get_halt_op(void)
68096{
68097#if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68098 return &hybrid_halt_op;
68099#else
68100 return NULL;
68101#endif
68102}
68103
68104ZEND_API int zend_vm_kind(void)
68105{
68106 return ZEND_VM_KIND;
68107}
68108
68109static uint32_t ZEND_FASTCALL zend_vm_get_opcode_handler_idx(uint32_t spec, const zend_op* op)
68110{
68111 static const int zend_vm_decode[] = {
68112 _UNUSED_CODE, /* 0 = IS_UNUSED */
68113 _CONST_CODE, /* 1 = IS_CONST */
68114 _TMP_CODE, /* 2 = IS_TMP_VAR */
68115 _UNUSED_CODE, /* 3 */
68116 _VAR_CODE, /* 4 = IS_VAR */
68117 _UNUSED_CODE, /* 5 */
68118 _UNUSED_CODE, /* 6 */
68119 _UNUSED_CODE, /* 7 */
68120 _CV_CODE /* 8 = IS_CV */
68121 };
68122 uint32_t offset = 0;
68123 if (spec & SPEC_RULE_OP1) offset = offset * 5 + zend_vm_decode[op->op1_type];
68124 if (spec & SPEC_RULE_OP2) offset = offset * 5 + zend_vm_decode[op->op2_type];
68125 if (spec & SPEC_EXTRA_MASK) {
68126 if (spec & SPEC_RULE_RETVAL) {
68127 offset = offset * 2 + (op->result_type != IS_UNUSED);
68128 if ((spec & SPEC_RULE_OBSERVER) && ZEND_OBSERVER_ENABLED) {
68129 offset += 2;
68130 }
68131 } else if (spec & SPEC_RULE_QUICK_ARG) {
68132 offset = offset * 2 + (op->op2.num <= MAX_ARG_FLAG_NUM);
68133 } else if (spec & SPEC_RULE_OP_DATA) {
68134 offset = offset * 5 + zend_vm_decode[(op + 1)->op1_type];
68135 } else if (spec & SPEC_RULE_ISSET) {
68136 offset = offset * 2 + (op->extended_value & ZEND_ISEMPTY);
68137 } else if (spec & SPEC_RULE_SMART_BRANCH) {
68138 offset = offset * 3;
68139 if (op->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR)) {
68140 offset += 1;
68141 } else if (op->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)) {
68142 offset += 2;
68143 }
68144 } else if (spec & SPEC_RULE_OBSERVER) {
68145 offset = offset * 2;
68146 if (ZEND_OBSERVER_ENABLED) {
68147 offset += 1;
68148 }
68149 }
68150 }
68151 return (spec & SPEC_START_MASK) + offset;
68152}
68153
68154#if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC
68155static const void *zend_vm_get_opcode_handler(uint8_t opcode, const zend_op* op)
68156{
68157 return zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
68158}
68159#endif
68160
68161#if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68162static const void *zend_vm_get_opcode_handler_func(uint8_t opcode, const zend_op* op)
68163{
68164 uint32_t spec = zend_spec_handlers[opcode];
68165 return zend_opcode_handler_funcs[zend_vm_get_opcode_handler_idx(spec, op)];
68166}
68167
68168#endif
68169
68170ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler(zend_op* op)
68171{
68172 uint8_t opcode = zend_user_opcodes[op->opcode];
68173
68174 if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
68175 if (op->op1_type < op->op2_type) {
68176 zend_swap_operands(op);
68177 }
68178 }
68179 op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
68180}
68181
68182ZEND_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)
68183{
68184 uint8_t opcode = zend_user_opcodes[op->opcode];
68185 uint32_t spec = zend_spec_handlers[opcode];
68186 switch (opcode) {
68187 case ZEND_ADD:
68188 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68189 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68190 break;
68191 }
68192 spec = 2585 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68193 if (op->op1_type < op->op2_type) {
68194 zend_swap_operands(op);
68195 }
68196 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68197 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68198 break;
68199 }
68200 spec = 2610 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68201 if (op->op1_type < op->op2_type) {
68202 zend_swap_operands(op);
68203 }
68204 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68205 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68206 break;
68207 }
68208 spec = 2635 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68209 if (op->op1_type < op->op2_type) {
68210 zend_swap_operands(op);
68211 }
68212 }
68213 break;
68214 case ZEND_SUB:
68215 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68216 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68217 break;
68218 }
68219 spec = 2660 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68220 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68221 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68222 break;
68223 }
68224 spec = 2685 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68225 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68226 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68227 break;
68228 }
68229 spec = 2710 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68230 }
68231 break;
68232 case ZEND_MUL:
68233 if (op->op1_type < op->op2_type) {
68234 zend_swap_operands(op);
68235 }
68236 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68237 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68238 break;
68239 }
68240 spec = 2735 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68241 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68242 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68243 break;
68244 }
68245 spec = 2760 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68246 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68247 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68248 break;
68249 }
68250 spec = 2785 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68251 }
68252 break;
68253 case ZEND_IS_IDENTICAL:
68254 if (op->op1_type < op->op2_type) {
68255 zend_swap_operands(op);
68256 }
68257 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68258 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68259 break;
68260 }
68261 spec = 2810 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68262 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68263 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68264 break;
68265 }
68266 spec = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68267 } 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))) {
68268 spec = 3110 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68269 }
68270 break;
68271 case ZEND_IS_NOT_IDENTICAL:
68272 if (op->op1_type < op->op2_type) {
68273 zend_swap_operands(op);
68274 }
68275 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68276 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68277 break;
68278 }
68279 spec = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68280 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68281 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68282 break;
68283 }
68284 spec = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68285 } 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))) {
68286 spec = 3115 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68287 }
68288 break;
68289 case ZEND_IS_EQUAL:
68290 if (op->op1_type < op->op2_type) {
68291 zend_swap_operands(op);
68292 }
68293 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68294 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68295 break;
68296 }
68297 spec = 2810 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68298 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68299 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68300 break;
68301 }
68302 spec = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68303 }
68304 break;
68305 case ZEND_IS_NOT_EQUAL:
68306 if (op->op1_type < op->op2_type) {
68307 zend_swap_operands(op);
68308 }
68309 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68310 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68311 break;
68312 }
68313 spec = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68314 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68315 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68316 break;
68317 }
68318 spec = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68319 }
68320 break;
68321 case ZEND_IS_SMALLER:
68322 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68323 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68324 break;
68325 }
68326 spec = 3120 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68327 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68328 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68329 break;
68330 }
68331 spec = 3195 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68332 }
68333 break;
68334 case ZEND_IS_SMALLER_OR_EQUAL:
68335 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68336 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68337 break;
68338 }
68339 spec = 3270 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68340 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68341 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68342 break;
68343 }
68344 spec = 3345 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68345 }
68346 break;
68347 case ZEND_QM_ASSIGN:
68348 if (op1_info == MAY_BE_LONG) {
68349 spec = 3432 | SPEC_RULE_OP1;
68350 } else if (op1_info == MAY_BE_DOUBLE) {
68351 spec = 3437 | SPEC_RULE_OP1;
68352 } 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))))) {
68353 spec = 3442 | SPEC_RULE_OP1;
68354 }
68355 break;
68356 case ZEND_PRE_INC:
68357 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68358 spec = 3420 | SPEC_RULE_RETVAL;
68359 } else if (op1_info == MAY_BE_LONG) {
68360 spec = 3422 | SPEC_RULE_RETVAL;
68361 }
68362 break;
68363 case ZEND_PRE_DEC:
68364 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68365 spec = 3424 | SPEC_RULE_RETVAL;
68366 } else if (op1_info == MAY_BE_LONG) {
68367 spec = 3426 | SPEC_RULE_RETVAL;
68368 }
68369 break;
68370 case ZEND_POST_INC:
68371 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68372 spec = 3428;
68373 } else if (op1_info == MAY_BE_LONG) {
68374 spec = 3429;
68375 }
68376 break;
68377 case ZEND_POST_DEC:
68378 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68379 spec = 3430;
68380 } else if (op1_info == MAY_BE_LONG) {
68381 spec = 3431;
68382 }
68383 break;
68384 case ZEND_JMP:
68385 if (OP_JMP_ADDR(op, op->op1) > op) {
68386 spec = 2584;
68387 }
68388 break;
68389 case ZEND_INIT_FCALL:
68390 if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) {
68391 spec = 2577;
68392 }
68393 break;
68394 case ZEND_RECV:
68395 if (op->op2.num == MAY_BE_ANY) {
68396 spec = 2578;
68397 }
68398 break;
68399 case ZEND_SEND_VAL:
68400 if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
68401 spec = 3482;
68402 }
68403 break;
68404 case ZEND_SEND_VAR_EX:
68405 if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
68406 spec = 3477 | SPEC_RULE_OP1;
68407 }
68408 break;
68409 case ZEND_FE_FETCH_R:
68410 if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
68411 spec = 3484 | SPEC_RULE_RETVAL;
68412 }
68413 break;
68414 case ZEND_FETCH_DIM_R:
68415 if (!(op2_info & (MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))) {
68416 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68417 break;
68418 }
68419 spec = 3447 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68420 }
68421 break;
68422 case ZEND_SEND_VAL_EX:
68423 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))) {
68424 spec = 3483;
68425 }
68426 break;
68427 case ZEND_SEND_VAR:
68428 if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
68429 spec = 3472 | SPEC_RULE_OP1;
68430 }
68431 break;
68432 case ZEND_COUNT:
68433 if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) {
68434 spec = 2579 | SPEC_RULE_OP1;
68435 }
68436 break;
68437 case ZEND_BW_OR:
68438 case ZEND_BW_AND:
68439 case ZEND_BW_XOR:
68440 case ZEND_BOOL_XOR:
68441 if (op->op1_type < op->op2_type) {
68442 zend_swap_operands(op);
68443 }
68444 break;
68445 case ZEND_USER_OPCODE:
68446 if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
68447 if (op->op1_type < op->op2_type) {
68448 zend_swap_operands(op);
68449 }
68450 }
68451 break;
68452 default:
68453 break;
68454 }
68455 op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(spec, op)];
68456}
68457
68458ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data* ex)
68459{
68460#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
68461 opcode_handler_t handler;
68462#endif
68463 int ret;
68464#ifdef ZEND_VM_IP_GLOBAL_REG
68465 const zend_op *orig_opline = opline;
68466#endif
68467#ifdef ZEND_VM_FP_GLOBAL_REG
68468 zend_execute_data *orig_execute_data = execute_data;
68469 execute_data = ex;
68470#else
68471 zend_execute_data *execute_data = ex;
68472#endif
68473
68474 LOAD_OPLINE();
68475#if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
68476#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
68477 handler = (opcode_handler_t)zend_vm_get_opcode_handler_func(zend_user_opcodes[opline->opcode], opline);
68478 handler(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68479 if (EXPECTED(opline != &hybrid_halt_op)) {
68480#else
68481 ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68482 if (EXPECTED(opline)) {
68483#endif
68484 ret = execute_data != ex ? (int)(execute_data->prev_execute_data != ex) + 1 : 0;
68485 SAVE_OPLINE();
68486 } else {
68487 ret = -1;
68488 }
68489#else
68490 ret = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68491 SAVE_OPLINE();
68492#endif
68493#ifdef ZEND_VM_FP_GLOBAL_REG
68494 execute_data = orig_execute_data;
68495#endif
68496#ifdef ZEND_VM_IP_GLOBAL_REG
68497 opline = orig_opline;
68498#endif
68499 return ret;
68500}
68501
len
size_t len
Definition apprentice.c:174
exception
bool exception
Definition assert.c:30
count
count(Countable|array $value, int $mode=COUNT_NORMAL)
Definition basic_functions.stub.php:1577
error
error($message)
Definition ext_skel.php:22
type
zend_ffi_type * type
Definition ffi.c:3812
zv
zval * zv
Definition ffi.c:3975
size
new_type size
Definition ffi.c:4365
res
zend_string * res
Definition ffi.c:4692
memcpy
memcpy(ptr1, ptr2, size)
arg
zval * arg
Definition ffi.c:3975
memset
memset(ptr, 0, type->size)
val
zval * val
Definition ffi.c:4262
ht
HashTable * ht
Definition ffi.c:4838
old_type
zend_ffi_type * old_type
Definition ffi.c:3971
offset
zend_long offset
Definition func_interceptors.c:163
NULL
#define NULL
Definition gdcache.h:45
SUCCESS
#define SUCCESS
Definition hash_sha3.c:261
end
unsigned const char * end
Definition php_ffi.h:51
pos
unsigned const char * pos
Definition php_ffi.h:52
flags
flags
Definition php_http_parser.c:229
handlers
zend_stack handlers
Definition php_output.h:139
key
unsigned char key[REFLECTION_KEY_LEN]
Definition php_reflection.c:63
func_name
const char * func_name
Definition phpdbg_print.c:184
lcname
zend_string * lcname
Definition phpdbg_print.c:186
ex
zend_object * ex
Definition phpdbg_prompt.c:948
top
original_stack top
Definition phpdbg_prompt.c:952
p
p
Definition session.c:1105
get_iterator
spl_ce_SplDoublyLinkedList get_iterator
Definition spl_dllist.c:1259
_zend_arg_info::type
zend_type type
Definition zend_compile.h:490
_zend_array::nNumUsed
uint32_t nNumUsed
Definition zend_types.h:406
_zend_array::arData
Bucket * arData
Definition zend_types.h:403
_zend_array::arPacked
zval * arPacked
Definition zend_types.h:404
_zend_class_constant::ce
zend_class_entry * ce
Definition zend_compile.h:474
_zend_class_constant::value
zval value
Definition zend_compile.h:471
_zend_class_entry::properties_info
HashTable properties_info
Definition zend.h:164
_zend_class_entry::get_iterator
zend_object_iterator *(* get_iterator)(zend_class_entry *ce, zval *object, int by_ref)
Definition zend.h:198
_zend_class_entry::name
zend_string * name
Definition zend.h:149
_zend_class_entry::ce_flags
uint32_t ce_flags
Definition zend.h:156
_zend_class_entry::type
char type
Definition zend.h:148
_zend_class_entry::get_static_method
zend_function *(* get_static_method)(zend_class_entry *ce, zend_string *method)
Definition zend.h:199
_zend_class_entry::constructor
zend_function * constructor
Definition zend.h:172
_zend_class_entry::enum_backing_type
uint32_t enum_backing_type
Definition zend.h:221
_zend_class_entry::parent
zend_class_entry * parent
Definition zend.h:152
_zend_class_entry::clone
zend_function * clone
Definition zend.h:174
_zend_constant::value
zval value
Definition zend_constants.h:34
_zend_constant::name
zend_string * name
Definition zend_constants.h:35
_zend_execute_data::prev_execute_data
zend_execute_data * prev_execute_data
Definition zend_compile.h:621
_zend_execute_data::symbol_table
zend_array * symbol_table
Definition zend_compile.h:622
_zend_execute_data::func
zend_function * func
Definition zend_compile.h:619
_zend_execute_data::opline
const zend_op * opline
Definition zend_compile.h:616
_zend_execute_data::return_value
zval * return_value
Definition zend_compile.h:618
_zend_execute_data::This
zval This
Definition zend_compile.h:620
_zend_fcall_info_cache::function_handler
zend_function * function_handler
Definition zend_API.h:60
_zend_fcall_info_cache::called_scope
zend_class_entry * called_scope
Definition zend_API.h:62
_zend_fcall_info_cache::object
zend_object * object
Definition zend_API.h:63
_zend_generator::execute_data
zend_execute_data * execute_data
Definition zend_generators.h:62
_zend_generator::retval
zval retval
Definition zend_generators.h:72
_zend_object_handlers::get_method
zend_object_get_method_t get_method
Definition zend_object_handlers.h:222
_zend_object_iterator_funcs::get_current_key
void(* get_current_key)(zend_object_iterator *iter, zval *key)
Definition zend_iterators.h:48
_zend_object_iterator_funcs::rewind
void(* rewind)(zend_object_iterator *iter)
Definition zend_iterators.h:54
_zend_object_iterator_funcs::move_forward
void(* move_forward)(zend_object_iterator *iter)
Definition zend_iterators.h:51
_zend_object_iterator_funcs::valid
zend_result(* valid)(zend_object_iterator *iter)
Definition zend_iterators.h:39
_zend_object_iterator_funcs::get_current_data
zval *(* get_current_data)(zend_object_iterator *iter)
Definition zend_iterators.h:42
_zend_object_iterator::funcs
const zend_object_iterator_funcs * funcs
Definition zend_iterators.h:67
_zend_object_iterator::index
zend_ulong index
Definition zend_iterators.h:68
_zend_object_iterator::std
zend_object std
Definition zend_iterators.h:65
_zend_object::ce
zend_class_entry * ce
Definition zend_types.h:560
_zend_object::handlers
const zend_object_handlers * handlers
Definition zend_types.h:561
_zend_op_array::last_var
int last_var
Definition zend_compile.h:524
_zend_op_array::opcodes
zend_op * opcodes
Definition zend_compile.h:527
_zend_op::op1
znode_op op1
Definition zend_compile.h:139
_zend_op::result_type
uint8_t result_type
Definition zend_compile.h:147
_zend_op::op2
znode_op op2
Definition zend_compile.h:140
_zend_op::result
znode_op result
Definition zend_compile.h:141
_zend_op::opcode
uint8_t opcode
Definition zend_compile.h:144
_zend_op::op1_type
uint8_t op1_type
Definition zend_compile.h:145
_zend_op::extended_value
uint32_t extended_value
Definition zend_compile.h:142
_zend_op::handler
const void * handler
Definition zend_compile.h:138
_zend_op::op2_type
uint8_t op2_type
Definition zend_compile.h:146
_zend_reference::val
zval val
Definition zend_types.h:590
_zend_reference::sources
zend_property_info_source_list sources
Definition zend_types.h:591
_zend_try_catch_element::finally_end
uint32_t finally_end
Definition zend_compile.h:176
_zend_try_catch_element::finally_op
uint32_t finally_op
Definition zend_compile.h:175
_zend_try_catch_element::catch_op
uint32_t catch_op
Definition zend_compile.h:174
_zend_try_catch_element::try_op
uint32_t try_op
Definition zend_compile.h:173
zend_ast_evaluate_ctx
Definition zend_ast.h:310
zend_ast_evaluate_ctx::had_side_effects
bool had_side_effects
Definition zend_ast.h:311
_zend_function::scope
zend_class_entry * scope
Definition zend_compile.h:599
_zend_function::type
uint8_t type
Definition zend_compile.h:591
_zend_function::op_array
zend_op_array op_array
Definition zend_compile.h:611
_zend_function::common
struct _zend_function::@236135173067030250234125302313220025134003177336 common
_zend_function::fn_flags
uint32_t fn_flags
Definition zend_compile.h:597
_znode_op::var
uint32_t var
Definition zend_compile.h:70
_znode_op::num
uint32_t num
Definition zend_compile.h:71
zend_property_info_source_list::ptr
struct _zend_property_info * ptr
Definition zend_types.h:580
zend_error_unchecked
ZEND_API ZEND_COLD void zend_error_unchecked(int type, const char *format,...)
Definition zend.c:1670
zend_error_noreturn
ZEND_API ZEND_COLD ZEND_NORETURN void zend_error_noreturn(int type, const char *format,...)
Definition zend.c:1703
zend_throw_error
ZEND_API ZEND_COLD void zend_throw_error(zend_class_entry *exception_ce, const char *format,...)
Definition zend.c:1772
zend_standard_class_def
ZEND_API zend_class_entry * zend_standard_class_def
Definition zend.c:83
zend_type_error
ZEND_API ZEND_COLD void zend_type_error(const char *format,...)
Definition zend.c:1824
zend_error
ZEND_API ZEND_COLD void zend_error(int type, const char *format,...)
Definition zend.c:1666
zend_ticks_function
ZEND_API void(* zend_ticks_function)(int ticks)
Definition zend.c:88
zend_interrupt_function
ZEND_API void(* zend_interrupt_function)(zend_execute_data *execute_data)
Definition zend.c:89
zend_write
ZEND_API zend_write_func_t zend_write
Definition zend.c:85
zend_parse_arg_long_weak
ZEND_API bool ZEND_FASTCALL zend_parse_arg_long_weak(const zval *arg, zend_long *dest, uint32_t arg_num)
Definition zend_API.c:557
zend_update_class_constants
ZEND_API zend_result zend_update_class_constants(zend_class_entry *class_type)
Definition zend_API.c:1518
zend_zval_value_name
ZEND_API const char * zend_zval_value_name(const zval *arg)
Definition zend_API.c:148
zend_zval_type_name
ZEND_API const char * zend_zval_type_name(const zval *arg)
Definition zend_API.c:167
object_init_ex
ZEND_API zend_result object_init_ex(zval *arg, zend_class_entry *class_type)
Definition zend_API.c:1849
zend_wrong_property_read
ZEND_API ZEND_COLD void zend_wrong_property_read(zval *object, zval *property)
Definition zend_API.c:103
zend_is_callable_ex
ZEND_API bool zend_is_callable_ex(zval *callable, zend_object *object, uint32_t check_flags, zend_string **callable_name, zend_fcall_info_cache *fcc, char **error)
Definition zend_API.c:4271
zend_zval_get_legacy_type
ZEND_API zend_string * zend_zval_get_legacy_type(const zval *arg)
Definition zend_API.c:184
zend_update_class_constant
ZEND_API zend_result zend_update_class_constant(zend_class_constant *c, const zend_string *name, zend_class_entry *scope)
Definition zend_API.c:1490
zend_parse_arg_str_weak
ZEND_API bool ZEND_FASTCALL zend_parse_arg_str_weak(zval *arg, zend_string **dest, uint32_t arg_num)
Definition zend_API.c:751
zend_fcall_info_cache
struct _zend_fcall_info_cache zend_fcall_info_cache
ZVAL_STRING
#define ZVAL_STRING(z, s)
Definition zend_API.h:956
array_init_size
#define array_init_size(arg, size)
Definition zend_API.h:538
zend_detach_symbol_table
ZEND_API void zend_detach_symbol_table(zend_execute_data *execute_data)
Definition zend_execute_API.c:1880
CE_CONSTANTS_TABLE
#define CE_CONSTANTS_TABLE(ce)
Definition zend_API.h:331
ZEND_THIS
#define ZEND_THIS
Definition zend_API.h:523
zend_attach_symbol_table
ZEND_API void zend_attach_symbol_table(zend_execute_data *execute_data)
Definition zend_execute_API.c:1845
zend_rebuild_symbol_table
ZEND_API zend_array * zend_rebuild_symbol_table(void)
Definition zend_execute_API.c:1798
ZVAL_STRINGL
#define ZVAL_STRINGL(z, s, l)
Definition zend_API.h:952
efree_size
#define efree_size(ptr, size)
Definition zend_alloc.h:138
efree
#define efree(ptr)
Definition zend_alloc.h:155
ALLOC_HASHTABLE
#define ALLOC_HASHTABLE(ht)
Definition zend_alloc.h:231
emalloc
#define emalloc(size)
Definition zend_alloc.h:151
zval
struct _zval_struct zval
Definition zend_builtin_functions.h:25
error_reporting
error_reporting(?int $error_level=null)
Definition zend_builtin_functions.stub.php:39
RETURN_VALUE_USED
#define RETURN_VALUE_USED(opline)
Definition zend_cfg.h:113
zend_create_closure
ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr)
Definition zend_closures.c:836
num_args
uint32_t num_args
Definition zend_closures.c:47
zend_ce_closure
ZEND_API zend_class_entry * zend_ce_closure
Definition zend_closures.c:40
zend_string_release_ex
zend_string_release_ex(func->internal_function.function_name, 0)
func
execute_data func
Definition zend_closures.c:68
zend_closure_bind_var_ex
void zend_closure_bind_var_ex(zval *closure_zv, uint32_t offset, zval *val)
Definition zend_closures.c:910
zend_closure_from_frame
void zend_closure_from_frame(zval *return_value, zend_execute_data *call)
Definition zend_closures.c:856
args
zval * args
Definition zend_closures.c:46
ZEND_CLOSURE_OBJECT
#define ZEND_CLOSURE_OBJECT(op_array)
Definition zend_closures.h:28
zend_is_smart_branch
ZEND_API bool zend_is_smart_branch(const zend_op *opline)
Definition zend_compile.c:2366
do_bind_class
ZEND_API zend_result do_bind_class(zval *lcname, zend_string *lc_parent_name)
Definition zend_compile.c:1356
zend_bind_class_in_slot
ZEND_API zend_class_entry * zend_bind_class_in_slot(zval *class_table_slot, zval *lcname, zend_string *lc_parent_name)
Definition zend_compile.c:1314
do_bind_function
ZEND_API zend_result do_bind_function(zend_function *func, zval *lcname)
Definition zend_compile.c:1295
zend_unmangle_property_name_ex
ZEND_API zend_result zend_unmangle_property_name_ex(const zend_string *name, const char **class_name, const char **prop_name, size_t *prop_len)
Definition zend_compile.c:1587
BP_VAR_R
#define BP_VAR_R
Definition zend_compile.h:1050
ZEND_JMP_NULL_BP_VAR_IS
#define ZEND_JMP_NULL_BP_VAR_IS
Definition zend_compile.h:434
ZEND_BIND_REF
#define ZEND_BIND_REF
Definition zend_compile.h:1183
ZEND_FETCH_CLASS_SELF
#define ZEND_FETCH_CLASS_SELF
Definition zend_compile.h:1019
ZEND_CALL_CLOSURE
#define ZEND_CALL_CLOSURE
Definition zend_compile.h:638
QUICK_ARG_SHOULD_BE_SENT_BY_REF
#define QUICK_ARG_SHOULD_BE_SENT_BY_REF(zf, arg_num)
Definition zend_compile.h:1173
ZEND_ACC_ENUM
#define ZEND_ACC_ENUM
Definition zend_compile.h:277
zend_op
struct _zend_op zend_op
Definition zend_compile.h:55
ZEND_USER_CODE
#define ZEND_USER_CODE(type)
Definition zend_compile.h:1061
EX_VAR_NUM
#define EX_VAR_NUM(n)
Definition zend_compile.h:726
ZEND_SHORT_CIRCUITING_CHAIN_EXPR
#define ZEND_SHORT_CIRCUITING_CHAIN_EXPR
Definition zend_compile.h:429
ARG_MUST_BE_SENT_BY_REF
#define ARG_MUST_BE_SENT_BY_REF(zf, arg_num)
Definition zend_compile.h:1144
IS_UNUSED
#define IS_UNUSED
Definition zend_compile.h:833
ZEND_CALL_TOP_FUNCTION
#define ZEND_CALL_TOP_FUNCTION
Definition zend_compile.h:653
ZEND_ACC_FAKE_CLOSURE
#define ZEND_ACC_FAKE_CLOSURE
Definition zend_compile.h:376
ZEND_FETCH_CLASS_MASK
#define ZEND_FETCH_CLASS_MASK
Definition zend_compile.h:1025
ZEND_CALL_ALLOCATED
#define ZEND_CALL_ALLOCATED
Definition zend_compile.h:634
QUICK_ARG_MAY_BE_SENT_BY_REF
#define QUICK_ARG_MAY_BE_SENT_BY_REF(zf, arg_num)
Definition zend_compile.h:1176
ZEND_CALL_TOP_CODE
#define ZEND_CALL_TOP_CODE
Definition zend_compile.h:654
ZEND_CALL_NESTED_CODE
#define ZEND_CALL_NESTED_CODE
Definition zend_compile.h:652
destroy_op_array
ZEND_API void destroy_op_array(zend_op_array *op_array)
Definition zend_opcode.c:555
ZEND_FETCH_GLOBAL_LOCK
#define ZEND_FETCH_GLOBAL_LOCK
Definition zend_compile.h:1075
IS_CONST
#define IS_CONST
Definition zend_compile.h:834
ZEND_ARRAY_NOT_PACKED
#define ZEND_ARRAY_NOT_PACKED
Definition zend_compile.h:1191
ZEND_ACC_HAS_TYPE_HINTS
#define ZEND_ACC_HAS_TYPE_HINTS
Definition zend_compile.h:243
BP_VAR_W
#define BP_VAR_W
Definition zend_compile.h:1051
IS_SMART_BRANCH_JMPNZ
#define IS_SMART_BRANCH_JMPNZ
Definition zend_compile.h:841
ZEND_INTERNAL_FUNCTION
#define ZEND_INTERNAL_FUNCTION
Definition zend_compile.h:1057
IS_VAR
#define IS_VAR
Definition zend_compile.h:836
ZEND_CLASS_CONST_FLAGS
#define ZEND_CLASS_CONST_FLAGS(c)
Definition zend_compile.h:478
EX_NUM_ARGS
#define EX_NUM_ARGS()
Definition zend_compile.h:704
ZEND_CALL_FRAME_SLOT
#define ZEND_CALL_FRAME_SLOT
Definition zend_compile.h:688
ZEND_SHORT_CIRCUITING_CHAIN_EMPTY
#define ZEND_SHORT_CIRCUITING_CHAIN_EMPTY
Definition zend_compile.h:431
ZEND_FREE_ON_RETURN
#define ZEND_FREE_ON_RETURN
Definition zend_compile.h:1095
QUICK_ARG_MUST_BE_SENT_BY_REF
#define QUICK_ARG_MUST_BE_SENT_BY_REF(zf, arg_num)
Definition zend_compile.h:1170
ZEND_ACC_LINKED
#define ZEND_ACC_LINKED
Definition zend_compile.h:280
ZEND_CALL_TOP
#define ZEND_CALL_TOP
Definition zend_compile.h:633
ZEND_ACC_READONLY
#define ZEND_ACC_READONLY
Definition zend_compile.h:236
RUN_TIME_CACHE
#define RUN_TIME_CACHE(op_array)
Definition zend_compile.h:827
IS_SMART_BRANCH_JMPZ
#define IS_SMART_BRANCH_JMPZ
Definition zend_compile.h:840
ZEND_RETURNS_VALUE
#define ZEND_RETURNS_VALUE
Definition zend_compile.h:1188
ZEND_FETCH_CLASS_NO_AUTOLOAD
#define ZEND_FETCH_CLASS_NO_AUTOLOAD
Definition zend_compile.h:1026
ZEND_CALL_NESTED_FUNCTION
#define ZEND_CALL_NESTED_FUNCTION
Definition zend_compile.h:651
EX
#define EX(element)
Definition zend_compile.h:700
ZEND_CALL_NEEDS_REATTACH
#define ZEND_CALL_NEEDS_REATTACH
Definition zend_compile.h:648
ZEND_USER_FUNCTION
#define ZEND_USER_FUNCTION
Definition zend_compile.h:1058
ZEND_CALL_VAR
#define ZEND_CALL_VAR(call, n)
Definition zend_compile.h:691
EX_CALL_INFO
#define EX_CALL_INFO()
Definition zend_compile.h:702
ZEND_CALL_NESTED
#define ZEND_CALL_NESTED
Definition zend_compile.h:632
user_opcode_handler_t
int(* user_opcode_handler_t)(zend_execute_data *execute_data)
Definition zend_compile.h:135
ZEND_CALL_HAS_SYMBOL_TABLE
#define ZEND_CALL_HAS_SYMBOL_TABLE
Definition zend_compile.h:636
ZEND_ACC_CALL_VIA_TRAMPOLINE
#define ZEND_ACC_CALL_VIA_TRAMPOLINE
Definition zend_compile.h:363
ZEND_CALL_GENERATOR
#define ZEND_CALL_GENERATOR
Definition zend_compile.h:640
ZEND_CALL_OBSERVED
#define ZEND_CALL_OBSERVED
Definition zend_compile.h:644
zend_op_array
struct _zend_op_array zend_op_array
Definition zend_compile.h:54
ZEND_CALL_HAS_THIS
#define ZEND_CALL_HAS_THIS
Definition zend_compile.h:627
EX_USES_STRICT_TYPES
#define EX_USES_STRICT_TYPES()
Definition zend_compile.h:709
OBJ_PROP
#define OBJ_PROP(obj, offset)
Definition zend_compile.h:459
zend_class_constant
struct _zend_class_constant zend_class_constant
zend_property_info
struct _zend_property_info zend_property_info
Definition zend_compile.h:192
ZEND_CALL_HAS_EXTRA_NAMED_PARAMS
#define ZEND_CALL_HAS_EXTRA_NAMED_PARAMS
Definition zend_compile.h:643
ZEND_ACC_TRAIT
#define ZEND_ACC_TRAIT
Definition zend_compile.h:275
ZEND_FETCH_REF
#define ZEND_FETCH_REF
Definition zend_compile.h:1080
ZEND_BIND_IMPLICIT
#define ZEND_BIND_IMPLICIT
Definition zend_compile.h:1184
ZEND_CALL_CODE
#define ZEND_CALL_CODE
Definition zend_compile.h:631
zend_destroy_static_vars
ZEND_API void zend_destroy_static_vars(zend_op_array *op_array)
Definition zend_opcode.c:544
ZEND_ACC_PRIVATE
#define ZEND_ACC_PRIVATE
Definition zend_compile.h:220
ZEND_FETCH_CLASS_STATIC
#define ZEND_FETCH_CLASS_STATIC
Definition zend_compile.h:1021
ZEND_FETCH_CLASS_DEFAULT
#define ZEND_FETCH_CLASS_DEFAULT
Definition zend_compile.h:1018
ZEND_ACC_CONSTANTS_UPDATED
#define ZEND_ACC_CONSTANTS_UPDATED
Definition zend_compile.h:291
ZEND_EXTRA_VALUE
#define ZEND_EXTRA_VALUE
Definition zend_compile.h:843
ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES
#define ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES
Definition zend_compile.h:301
ZEND_CALL_NUM_ARGS
#define ZEND_CALL_NUM_ARGS(call)
Definition zend_compile.h:681
RT_CONSTANT
#define RT_CONSTANT(opline, node)
Definition zend_compile.h:810
ZEND_ACC_STATIC
#define ZEND_ACC_STATIC
Definition zend_compile.h:226
MAX_ARG_FLAG_NUM
#define MAX_ARG_FLAG_NUM
Definition zend_compile.h:1154
ZEND_FETCH_CLASS_EXCEPTION
#define ZEND_FETCH_CLASS_EXCEPTION
Definition zend_compile.h:1028
ZEND_CALL_INFO
#define ZEND_CALL_INFO(call)
Definition zend_compile.h:656
ZEND_FETCH_CLASS_PARENT
#define ZEND_FETCH_CLASS_PARENT
Definition zend_compile.h:1020
ZEND_ACC_PUBLIC
#define ZEND_ACC_PUBLIC
Definition zend_compile.h:218
ZEND_CALL_FUNCTION
#define ZEND_CALL_FUNCTION
Definition zend_compile.h:630
ZEND_ARRAY_ELEMENT_REF
#define ZEND_ARRAY_ELEMENT_REF
Definition zend_compile.h:1190
ZEND_ACC_HAS_RETURN_TYPE
#define ZEND_ACC_HAS_RETURN_TYPE
Definition zend_compile.h:346
zend_arg_info
struct _zend_arg_info zend_arg_info
OP_JMP_ADDR
#define OP_JMP_ADDR(opline, node)
Definition zend_compile.h:766
EX_VAR
#define EX_VAR(n)
Definition zend_compile.h:725
ZEND_CALL_DYNAMIC
#define ZEND_CALL_DYNAMIC
Definition zend_compile.h:641
ZEND_FETCH_OBJ_FLAGS
#define ZEND_FETCH_OBJ_FLAGS
Definition zend_compile.h:1082
ZEND_CALL_SEND_ARG_BY_REF
#define ZEND_CALL_SEND_ARG_BY_REF
Definition zend_compile.h:649
ZEND_FETCH_GLOBAL
#define ZEND_FETCH_GLOBAL
Definition zend_compile.h:1073
ZEND_ADD_CALL_FLAG_EX
#define ZEND_ADD_CALL_FLAG_EX(call_info, flag)
Definition zend_compile.h:665
ZEND_ACC_VARIADIC
#define ZEND_ACC_VARIADIC
Definition zend_compile.h:349
ZEND_USER_CLASS
#define ZEND_USER_CLASS
Definition zend_compile.h:1064
ZEND_ADD_CALL_FLAG
#define ZEND_ADD_CALL_FLAG(call, flag)
Definition zend_compile.h:673
ZEND_CALL_FREE_EXTRA_ARGS
#define ZEND_CALL_FREE_EXTRA_ARGS
Definition zend_compile.h:635
ZEND_ARRAY_SIZE_SHIFT
#define ZEND_ARRAY_SIZE_SHIFT
Definition zend_compile.h:1192
ARG_SHOULD_BE_SENT_BY_REF
#define ARG_SHOULD_BE_SENT_BY_REF(zf, arg_num)
Definition zend_compile.h:1147
ZEND_ISEMPTY
#define ZEND_ISEMPTY
Definition zend_compile.h:1091
ZEND_CALL_MAY_HAVE_UNDEF
#define ZEND_CALL_MAY_HAVE_UNDEF
Definition zend_compile.h:642
IS_CV
#define IS_CV
Definition zend_compile.h:837
IS_TMP_VAR
#define IS_TMP_VAR
Definition zend_compile.h:835
zend_try_catch_element
struct _zend_try_catch_element zend_try_catch_element
ZEND_DEL_CALL_FLAG
#define ZEND_DEL_CALL_FLAG(call, flag)
Definition zend_compile.h:677
BP_VAR_RW
#define BP_VAR_RW
Definition zend_compile.h:1052
zend_live_range
struct _zend_live_range zend_live_range
ZEND_ACC_DEPRECATED
#define ZEND_ACC_DEPRECATED
Definition zend_compile.h:340
ZEND_CALL_RELEASE_THIS
#define ZEND_CALL_RELEASE_THIS
Definition zend_compile.h:637
ZEND_FETCH_CLASS_SILENT
#define ZEND_FETCH_CLASS_SILENT
Definition zend_compile.h:1027
ZEND_ACC_RETURN_REFERENCE
#define ZEND_ACC_RETURN_REFERENCE
Definition zend_compile.h:343
ZEND_RETURNS_FUNCTION
#define ZEND_RETURNS_FUNCTION
Definition zend_compile.h:1187
zend_visibility_string
char * zend_visibility_string(uint32_t fn_flags)
Definition zend_inheritance.c:202
ARG_MAY_BE_SENT_BY_REF
#define ARG_MAY_BE_SENT_BY_REF(zf, arg_num)
Definition zend_compile.h:1150
ZEND_LAST_CATCH
#define ZEND_LAST_CATCH
Definition zend_compile.h:1093
BP_VAR_IS
#define BP_VAR_IS
Definition zend_compile.h:1053
ZEND_SHORT_CIRCUITING_CHAIN_MASK
#define ZEND_SHORT_CIRCUITING_CHAIN_MASK
Definition zend_compile.h:428
ZEND_ACC_CLOSURE
#define ZEND_ACC_CLOSURE
Definition zend_compile.h:375
ZEND_ACC_NEVER_CACHE
#define ZEND_ACC_NEVER_CACHE
Definition zend_compile.h:366
BP_VAR_UNSET
#define BP_VAR_UNSET
Definition zend_compile.h:1055
ZEND_BIND_EXPLICIT
#define ZEND_BIND_EXPLICIT
Definition zend_compile.h:1185
ZEND_CALL_ARG
#define ZEND_CALL_ARG(call, n)
Definition zend_compile.h:697
ZEND_CALL_FAKE_CLOSURE
#define ZEND_CALL_FAKE_CLOSURE
Definition zend_compile.h:639
ZEND_SHORT_CIRCUITING_CHAIN_ISSET
#define ZEND_SHORT_CIRCUITING_CHAIN_ISSET
Definition zend_compile.h:430
ZEND_API
#define ZEND_API
Definition zend_config.w32.h:50
zend_register_constant
ZEND_API zend_result zend_register_constant(zend_constant *c)
Definition zend_constants.c:477
zend_verify_const_access
ZEND_API bool zend_verify_const_access(zend_class_constant *c, zend_class_entry *scope)
Definition zend_constants.c:234
ZEND_CONSTANT_SET_FLAGS
#define ZEND_CONSTANT_SET_FLAGS(c, _flags, _module_number)
Definition zend_constants.h:44
zend_constant
struct _zend_constant zend_constant
PHP_USER_CONSTANT
#define PHP_USER_CONSTANT
Definition zend_constants.h:31
E_NOTICE
#define E_NOTICE
Definition zend_errors.h:26
E_ERROR
#define E_ERROR
Definition zend_errors.h:23
E_WARNING
#define E_WARNING
Definition zend_errors.h:24
E_CORE_ERROR
#define E_CORE_ERROR
Definition zend_errors.h:27
E_FATAL_ERRORS
#define E_FATAL_ERRORS
Definition zend_errors.h:47
E_HAS_ONLY_FATAL_ERRORS
#define E_HAS_ONLY_FATAL_ERRORS(mask)
Definition zend_errors.h:49
E_DEPRECATED
#define E_DEPRECATED
Definition zend_errors.h:37
zend_exception_restore
void zend_exception_restore(void)
Definition zend_exceptions.c:153
zend_is_unwind_exit
ZEND_API bool zend_is_unwind_exit(const zend_object *ex)
Definition zend_exceptions.c:1034
zend_throw_exception_object
ZEND_API ZEND_COLD void zend_throw_exception_object(zval *exception)
Definition zend_exceptions.c:990
zend_exception_save
void zend_exception_save(void)
Definition zend_exceptions.c:141
zend_is_graceful_exit
ZEND_API bool zend_is_graceful_exit(const zend_object *ex)
Definition zend_exceptions.c:1039
zend_ce_division_by_zero_error
ZEND_API zend_class_entry * zend_ce_division_by_zero_error
Definition zend_exceptions.c:43
zend_throw_exception_ex
ZEND_API ZEND_COLD zend_object * zend_throw_exception_ex(zend_class_entry *exception_ce, zend_long code, const char *format,...)
Definition zend_exceptions.c:858
zend_exception_set_previous
void zend_exception_set_previous(zend_object *exception, zend_object *add_previous)
Definition zend_exceptions.c:96
zend_free_extra_named_params
ZEND_API void ZEND_FASTCALL zend_free_extra_named_params(zend_array *extra_named_params)
Definition zend_execute.c:5474
zend_verify_ref_array_assignable
ZEND_API bool zend_verify_ref_array_assignable(zend_reference *ref)
Definition zend_execute.c:3284
zend_frameless_observed_call
ZEND_API void zend_frameless_observed_call(zend_execute_data *execute_data)
Definition zend_execute.c:1594
ZEND_VM_SET_OPCODE_NO_INTERRUPT
#define ZEND_VM_SET_OPCODE_NO_INTERRUPT(new_op)
Definition zend_execute.c:5543
EXECUTE_DATA_CC
#define EXECUTE_DATA_CC
Definition zend_execute.c:90
ZEND_FAKE_OP_ARRAY
#define ZEND_FAKE_OP_ARRAY
Definition zend_execute.c:5074
ZEND_VM_SMART_BRANCH_FALSE
#define ZEND_VM_SMART_BRANCH_FALSE()
Definition zend_execute.c:5644
zend_pass_function
ZEND_API const zend_internal_function zend_pass_function
Definition zend_execute.c:141
_zend_vm_stack_push_call_frame
#define _zend_vm_stack_push_call_frame
Definition zend_execute.c:5510
ZEND_VM_FCALL_INTERRUPT_CHECK
#define ZEND_VM_FCALL_INTERRUPT_CHECK(call)
Definition zend_execute.c:4103
zend_clean_and_cache_symbol_table
ZEND_API void zend_clean_and_cache_symbol_table(zend_array *symbol_table)
Definition zend_execute.c:4049
zend_invalid_class_constant_type_error
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_invalid_class_constant_type_error(uint8_t type)
Definition zend_execute.c:910
get_zval_ptr_undef
#define get_zval_ptr_undef(op_type, node, type)
Definition zend_execute.c:123
UNDEF_RESULT
#define UNDEF_RESULT()
Definition zend_execute.c:5674
zend_match_unhandled_error
ZEND_COLD void zend_match_unhandled_error(const zval *value)
Definition zend_execute.c:875
ZEND_VM_SMART_BRANCH_NONE
#define ZEND_VM_SMART_BRANCH_NONE(_result, _check)
Definition zend_execute.c:5616
ZEND_VM_SMART_BRANCH
#define ZEND_VM_SMART_BRANCH(_result, _check)
Definition zend_execute.c:5575
get_op_data_zval_ptr_r
#define get_op_data_zval_ptr_r(op_type, node)
Definition zend_execute.c:124
ZEND_VM_JMP
#define ZEND_VM_JMP(new_op)
Definition zend_execute.c:5562
zend_verify_property_type
ZEND_API bool zend_never_inline zend_verify_property_type(const zend_property_info *info, zval *property, bool strict)
Definition zend_execute.c:1056
zend_deprecated_class_constant
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_deprecated_class_constant(const zend_class_constant *c, const zend_string *constant_name)
Definition zend_execute.c:1908
get_zval_ptr_ptr
#define get_zval_ptr_ptr(op_type, node, type)
Definition zend_execute.c:126
zend_deprecated_function
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_deprecated_function(const zend_function *fbc)
Definition zend_execute.c:1882
get_zval_ptr
#define get_zval_ptr(op_type, node, type)
Definition zend_execute.c:121
zend_verify_never_error
ZEND_API ZEND_COLD void zend_verify_never_error(const zend_function *zf)
Definition zend_execute.c:1454
OPLINE_CC
#define OPLINE_CC
Definition zend_execute.c:103
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION
#define ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION()
Definition zend_execute.c:5533
ZEND_VM_SMART_BRANCH_JMPNZ
#define ZEND_VM_SMART_BRANCH_JMPNZ(_result, _check)
Definition zend_execute.c:5606
ZEND_VM_JMP_EX
#define ZEND_VM_JMP_EX(new_op, check_exception)
Definition zend_execute.c:5554
zend_handle_undef_args
ZEND_API zend_result ZEND_FASTCALL zend_handle_undef_args(zend_execute_data *call)
Definition zend_execute.c:5369
EXECUTE_DATA_C
#define EXECUTE_DATA_C
Definition zend_execute.c:88
ZEND_VM_SMART_BRANCH_TRUE_JMPZ
#define ZEND_VM_SMART_BRANCH_TRUE_JMPZ()
Definition zend_execute.c:5632
ZVAL_UNDEFINED_OP1
#define ZVAL_UNDEFINED_OP1()
Definition zend_execute.c:294
ZEND_VM_SMART_BRANCH_FALSE_JMPNZ
#define ZEND_VM_SMART_BRANCH_FALSE_JMPNZ()
Definition zend_execute.c:5659
ZEND_VM_REPEAT_OPCODE
#define ZEND_VM_REPEAT_OPCODE(_opcode)
Definition zend_execute.c:5571
zend_use_resource_as_offset
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_use_resource_as_offset(const zval *dim)
Definition zend_execute.c:2493
get_op_data_zval_ptr_deref_r
#define get_op_data_zval_ptr_deref_r(op_type, node)
Definition zend_execute.c:125
_UNUSED_CODE
#define _UNUSED_CODE
Definition zend_execute.c:116
ZEND_VM_SMART_BRANCH_FALSE_NONE
#define ZEND_VM_SMART_BRANCH_FALSE_NONE()
Definition zend_execute.c:5663
zend_param_must_be_ref
ZEND_COLD void ZEND_FASTCALL zend_param_must_be_ref(const zend_function *func, uint32_t arg_num)
Definition zend_execute.c:2468
ZEND_VM_INC_OPCODE
#define ZEND_VM_INC_OPCODE()
Definition zend_execute.c:5565
ZEND_VM_SMART_BRANCH_TRUE_JMPNZ
#define ZEND_VM_SMART_BRANCH_TRUE_JMPNZ()
Definition zend_execute.c:5636
ZEND_VM_NEXT_OPCODE_EX
#define ZEND_VM_NEXT_OPCODE_EX(check_exception, skip)
Definition zend_execute.c:5523
ZEND_VM_REPEATABLE_OPCODE
#define ZEND_VM_REPEATABLE_OPCODE
Definition zend_execute.c:5569
get_zval_ptr_deref
#define get_zval_ptr_deref(op_type, node, type)
Definition zend_execute.c:122
FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY
#define FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_var)
Definition zend_execute.c:162
ZEND_VM_SMART_BRANCH_TRUE_NONE
#define ZEND_VM_SMART_BRANCH_TRUE_NONE()
Definition zend_execute.c:5640
ZEND_VM_LOOP_INTERRUPT_CHECK
#define ZEND_VM_LOOP_INTERRUPT_CHECK()
Definition zend_execute.c:4097
ZEND_VM_NEXT_OPCODE
#define ZEND_VM_NEXT_OPCODE()
Definition zend_execute.c:5536
FREE_OP
#define FREE_OP(type, var)
Definition zend_execute.c:176
ZEND_VM_SET_RELATIVE_OPCODE
#define ZEND_VM_SET_RELATIVE_OPCODE(opline, offset)
Definition zend_execute.c:5551
_CONST_CODE
#define _CONST_CODE
Definition zend_execute.c:113
ZEND_VM_SMART_BRANCH_TRUE
#define ZEND_VM_SMART_BRANCH_TRUE()
Definition zend_execute.c:5621
_zend_vm_stack_push_call_frame_ex
#define _zend_vm_stack_push_call_frame_ex
Definition zend_execute.c:5509
zend_missing_arg_error
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_missing_arg_error(zend_execute_data *execute_data)
Definition zend_execute.c:1413
ZVAL_UNDEFINED_OP2
#define ZVAL_UNDEFINED_OP2()
Definition zend_execute.c:295
ZEND_VM_SMART_BRANCH_JMPZ
#define ZEND_VM_SMART_BRANCH_JMPZ(_result, _check)
Definition zend_execute.c:5596
_TMP_CODE
#define _TMP_CODE
Definition zend_execute.c:114
zend_cannot_add_element
ZEND_API zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_cannot_add_element(void)
Definition zend_execute.c:2488
ZEND_VM_SMART_BRANCH_FALSE_JMPZ
#define ZEND_VM_SMART_BRANCH_FALSE_JMPZ()
Definition zend_execute.c:5655
zend_cannot_pass_by_reference
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_cannot_pass_by_reference(uint32_t arg_num)
Definition zend_execute.c:599
zend_handle_named_arg
zval *ZEND_FASTCALL zend_handle_named_arg(zend_execute_data **call_ptr, zend_string *arg_name, uint32_t *arg_num_ptr, void **cache_slot)
Definition zend_execute.c:5290
zend_false_to_array_deprecated
ZEND_API ZEND_COLD void ZEND_FASTCALL zend_false_to_array_deprecated(void)
Definition zend_execute.c:1929
_VAR_CODE
#define _VAR_CODE
Definition zend_execute.c:115
_CV_CODE
#define _CV_CODE
Definition zend_execute.c:117
zend_verify_return_error
ZEND_API ZEND_COLD void zend_verify_return_error(const zend_function *zf, zval *value)
Definition zend_execute.c:1438
CACHED_PTR_EX
#define CACHED_PTR_EX(slot)
Definition zend_execute.h:467
zend_get_called_scope
ZEND_API zend_class_entry * zend_get_called_scope(zend_execute_data *ex)
Definition zend_execute_API.c:1291
ZEND_REF_HAS_TYPE_SOURCES
#define ZEND_REF_HAS_TYPE_SOURCES(ref)
Definition zend_execute.h:119
ZEND_USER_OPCODE_ENTER
#define ZEND_USER_OPCODE_ENTER
Definition zend_execute.h:422
zend_execute_ex
ZEND_API void(* zend_execute_ex)(zend_execute_data *execute_data)
Definition zend_execute_API.c:52
zend_execute_internal
ZEND_API void(* zend_execute_internal)(zend_execute_data *execute_data, zval *return_value)
Definition zend_execute_API.c:53
zend_get_this_object
ZEND_API zend_object * zend_get_this_object(zend_execute_data *ex)
Definition zend_execute_API.c:1309
execute_ex
ZEND_API void execute_ex(zend_execute_data *execute_data)
Definition zend_vm_execute.h:55053
zend_fetch_class
ZEND_API zend_class_entry * zend_fetch_class(zend_string *class_name, uint32_t fetch_type)
Definition zend_execute_API.c:1700
ZEND_USER_OPCODE_RETURN
#define ZEND_USER_OPCODE_RETURN
Definition zend_execute.h:420
zend_fetch_class_by_name
ZEND_API zend_class_entry * zend_fetch_class_by_name(zend_string *class_name, zend_string *lcname, uint32_t fetch_type)
Definition zend_execute_API.c:1781
ZEND_USER_OPCODE_LEAVE
#define ZEND_USER_OPCODE_LEAVE
Definition zend_execute.h:423
zval_update_constant_with_ctx
ZEND_API zend_result ZEND_FASTCALL zval_update_constant_with_ctx(zval *pp, zend_class_entry *scope, zend_ast_evaluate_ctx *ctx)
Definition zend_execute_API.c:722
zval_update_constant_ex
ZEND_API zend_result ZEND_FASTCALL zval_update_constant_ex(zval *pp, zend_class_entry *scope)
Definition zend_execute_API.c:763
DECODE_SPECIAL_CACHE_NUM
#define DECODE_SPECIAL_CACHE_NUM(ptr)
Definition zend_execute.h:490
IS_SPECIAL_CACHE_VAL
#define IS_SPECIAL_CACHE_VAL(ptr)
Definition zend_execute.h:484
CACHED_PTR
#define CACHED_PTR(num)
Definition zend_execute.h:449
CACHE_PTR_EX
#define CACHE_PTR_EX(slot, ptr)
Definition zend_execute.h:470
zend_call_stack_size_error
ZEND_API zend_never_inline ZEND_COLD void ZEND_FASTCALL zend_call_stack_size_error(void)
ENCODE_SPECIAL_CACHE_NUM
#define ENCODE_SPECIAL_CACHE_NUM(num)
Definition zend_execute.h:487
ZEND_USER_OPCODE_DISPATCH
#define ZEND_USER_OPCODE_DISPATCH
Definition zend_execute.h:421
zend_timeout
ZEND_API ZEND_NORETURN void ZEND_FASTCALL zend_timeout(void)
Definition zend_execute_API.c:1413
CACHE_PTR
#define CACHE_PTR(num, ptr)
Definition zend_execute.h:452
ZEND_REF_ADD_TYPE_SOURCE
#define ZEND_REF_ADD_TYPE_SOURCE(ref, source)
Definition zend_execute.h:517
CACHE_ADDR
#define CACHE_ADDR(num)
Definition zend_execute.h:446
ZEND_USER_OPCODE_CONTINUE
#define ZEND_USER_OPCODE_CONTINUE
Definition zend_execute.h:419
zend_lookup_class_ex
ZEND_API zend_class_entry * zend_lookup_class_ex(zend_string *name, zend_string *lcname, uint32_t flags)
Definition zend_execute_API.c:1161
CACHE_POLYMORPHIC_PTR
#define CACHE_POLYMORPHIC_PTR(num, ce, ptr)
Definition zend_execute.h:461
zend_extensions
ZEND_API zend_llist zend_extensions
Definition zend_extensions.c:23
zend_fiber_switch_unblock
ZEND_API void zend_fiber_switch_unblock(void)
Definition zend_fibers.c:402
zend_fiber_switch_block
ZEND_API void zend_fiber_switch_block(void)
Definition zend_fibers.c:397
zend_function
union _zend_function zend_function
Definition zend_frameless_function.h:108
zend_frameless_function_1
void(* zend_frameless_function_1)(zval *return_value, zval *op1)
Definition zend_frameless_function.h:111
zend_jmp_fl_result
zend_jmp_fl_result
Definition zend_frameless_function.h:125
ZEND_JMP_FL_MISS
@ ZEND_JMP_FL_MISS
Definition zend_frameless_function.h:127
ZEND_JMP_FL_UNPRIMED
@ ZEND_JMP_FL_UNPRIMED
Definition zend_frameless_function.h:126
ZEND_JMP_FL_HIT
@ ZEND_JMP_FL_HIT
Definition zend_frameless_function.h:128
ZEND_FLF_HANDLER
#define ZEND_FLF_HANDLER(opline)
Definition zend_frameless_function.h:40
zend_frameless_function_3
void(* zend_frameless_function_3)(zval *return_value, zval *op1, zval *op2, zval *op3)
Definition zend_frameless_function.h:113
zend_frameless_function_0
void(* zend_frameless_function_0)(zval *return_value)
Definition zend_frameless_function.h:110
ZEND_FLF_FUNC
#define ZEND_FLF_FUNC(opline)
Definition zend_frameless_function.h:39
zend_frameless_function_2
void(* zend_frameless_function_2)(zval *return_value, zval *op1, zval *op2)
Definition zend_frameless_function.h:112
gc_possible_root
ZEND_API void ZEND_FASTCALL gc_possible_root(zend_refcounted *ref)
Definition zend_gc.c:698
GC_MAY_LEAK
#define GC_MAY_LEAK(ref)
Definition zend_gc.h:84
zend_generator_close
ZEND_API void zend_generator_close(zend_generator *generator, bool finished_execution)
Definition zend_generators.c:134
zend_generator_yield_from
void zend_generator_yield_from(zend_generator *generator, zend_generator *from)
Definition zend_generators.c:546
zend_ce_generator
ZEND_API zend_class_entry * zend_ce_generator
Definition zend_generators.c:31
zend_generator
struct _zend_generator zend_generator
Definition zend_generators.h:33
zend_ini_entry
struct _zend_ini_entry zend_ini_entry
Definition zend_globals.h:74
EG
#define EG(v)
Definition zend_globals_macros.h:46
zend_hash_destroy
ZEND_API void ZEND_FASTCALL zend_hash_destroy(HashTable *ht)
Definition zend_hash.c:1727
zend_proptable_to_symtable
ZEND_API HashTable *ZEND_FASTCALL zend_proptable_to_symtable(HashTable *ht, bool always_duplicate)
Definition zend_hash.c:3387
zend_symtable_to_proptable
ZEND_API HashTable *ZEND_FASTCALL zend_symtable_to_proptable(HashTable *ht)
Definition zend_hash.c:3334
zend_hash_real_init_packed
ZEND_API void ZEND_FASTCALL zend_hash_real_init_packed(HashTable *ht)
Definition zend_hash.c:330
zend_hash_index_add
ZEND_API zval *ZEND_FASTCALL zend_hash_index_add(HashTable *ht, zend_ulong h, zval *pData)
Definition zend_hash.c:1209
zend_hash_iterator_add
ZEND_API uint32_t ZEND_FASTCALL zend_hash_iterator_add(HashTable *ht, HashPosition pos)
Definition zend_hash.c:537
zend_hash_next_index_insert
ZEND_API zval *ZEND_FASTCALL zend_hash_next_index_insert(HashTable *ht, zval *pData)
Definition zend_hash.c:1224
zend_hash_real_init
ZEND_API void ZEND_FASTCALL zend_hash_real_init(HashTable *ht, bool packed)
Definition zend_hash.c:322
zend_hash_index_add_new
ZEND_API zval *ZEND_FASTCALL zend_hash_index_add_new(HashTable *ht, zend_ulong h, zval *pData)
Definition zend_hash.c:1214
zend_hash_add_new
ZEND_API zval *ZEND_FASTCALL zend_hash_add_new(HashTable *ht, zend_string *key, zval *pData)
Definition zend_hash.c:1007
zend_hash_index_del
ZEND_API zend_result ZEND_FASTCALL zend_hash_index_del(HashTable *ht, zend_ulong h)
Definition zend_hash.c:1692
zend_hash_find_known_hash
ZEND_API zval *ZEND_FASTCALL zend_hash_find_known_hash(const HashTable *ht, const zend_string *key)
Definition zend_hash.c:2679
zend_hash_iterator_pos
ZEND_API HashPosition ZEND_FASTCALL zend_hash_iterator_pos(uint32_t idx, HashTable *ht)
Definition zend_hash.c:608
zend_hash_index_update
ZEND_API zval *ZEND_FASTCALL zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData)
Definition zend_hash.c:1219
zend_hash_extend
ZEND_API void ZEND_FASTCALL zend_hash_extend(HashTable *ht, uint32_t nSize, bool packed)
Definition zend_hash.c:396
zend_hash_del_ind
ZEND_API zend_result ZEND_FASTCALL zend_hash_del_ind(HashTable *ht, zend_string *key)
Definition zend_hash.c:1566
zend_hash_copy
ZEND_API void ZEND_FASTCALL zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor)
Definition zend_hash.c:2240
zend_array_destroy
ZEND_API void ZEND_FASTCALL zend_array_destroy(HashTable *ht)
Definition zend_hash.c:1808
zend_hash_iterator_pos_ex
ZEND_API HashPosition ZEND_FASTCALL zend_hash_iterator_pos_ex(uint32_t idx, zval *array)
Definition zend_hash.c:627
zend_array_dup
ZEND_API HashTable *ZEND_FASTCALL zend_array_dup(HashTable *source)
Definition zend_hash.c:2438
zend_hash_update
ZEND_API zval *ZEND_FASTCALL zend_hash_update(HashTable *ht, zend_string *key, zval *pData)
Definition zend_hash.c:997
zend_hash_real_init_mixed
ZEND_API void ZEND_FASTCALL zend_hash_real_init_mixed(HashTable *ht)
Definition zend_hash.c:338
zend_hash_del
ZEND_API zend_result ZEND_FASTCALL zend_hash_del(HashTable *ht, zend_string *key)
Definition zend_hash.c:1534
zend_hash_find
ZEND_API zval *ZEND_FASTCALL zend_hash_find(const HashTable *ht, zend_string *key)
Definition zend_hash.c:2668
zend_hash_index_find
ZEND_API zval *ZEND_FASTCALL zend_hash_index_find(const HashTable *ht, zend_ulong h)
Definition zend_hash.c:2701
zend_hash_iterator_del
ZEND_API void ZEND_FASTCALL zend_hash_iterator_del(uint32_t idx)
Definition zend_hash.c:649
ZEND_HASH_FILL_ADD
#define ZEND_HASH_FILL_ADD(_val)
Definition zend_hash.h:1570
zend_hash_init
#define zend_hash_init(ht, nSize, pHashFunction, pDestructor, persistent)
Definition zend_hash.h:108
ZEND_HASH_FILL_PACKED
#define ZEND_HASH_FILL_PACKED(ht)
Definition zend_hash.h:1528
ZEND_HASH_FILL_SET
#define ZEND_HASH_FILL_SET(_val)
Definition zend_hash.h:1544
ZEND_HASH_FILL_END
#define ZEND_HASH_FILL_END()
Definition zend_hash.h:1582
ZEND_HASH_FILL_SET_NULL
#define ZEND_HASH_FILL_SET_NULL()
Definition zend_hash.h:1547
HT_IS_PACKED
#define HT_IS_PACKED(ht)
Definition zend_hash.h:59
zend_new_array
#define zend_new_array(size)
Definition zend_hash.h:338
ZEND_HASH_INDEX_FIND
#define ZEND_HASH_INDEX_FIND(_ht, _h, _ret, _not_found)
Definition zend_hash.h:196
ZEND_HANDLE_NUMERIC
#define ZEND_HANDLE_NUMERIC(key, idx)
Definition zend_hash.h:420
ZEND_HASH_FOREACH_STR_KEY_VAL
#define ZEND_HASH_FOREACH_STR_KEY_VAL(ht, _key, _val)
Definition zend_hash.h:1166
ZEND_HASH_MAP_FOREACH_STR_KEY
#define ZEND_HASH_MAP_FOREACH_STR_KEY(ht, _key)
Definition zend_hash.h:1346
ZEND_HASH_FILL_FINISH
#define ZEND_HASH_FILL_FINISH()
Definition zend_hash.h:1575
ZEND_HASH_PACKED_FOREACH_VAL
#define ZEND_HASH_PACKED_FOREACH_VAL(ht, _val)
Definition zend_hash.h:1479
ZEND_HASH_FOREACH_END
#define ZEND_HASH_FOREACH_END()
Definition zend_hash.h:1086
ZEND_HASH_FILL_NEXT
#define ZEND_HASH_FILL_NEXT()
Definition zend_hash.h:1565
ZVAL_EMPTY_ARRAY
#define ZVAL_EMPTY_ARRAY(z)
Definition zend_hash.h:87
ZEND_HASH_MAP_FOREACH_STR_KEY_VAL
#define ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(ht, _key, _val)
Definition zend_hash.h:1374
ZEND_HASH_FOREACH_VAL
#define ZEND_HASH_FOREACH_VAL(ht, _val)
Definition zend_hash.h:1102
zend_do_link_class
ZEND_API zend_class_entry * zend_do_link_class(zend_class_entry *ce, zend_string *lc_parent_name, zend_string *key)
Definition zend_inheritance.c:3477
zend_ce_countable
ZEND_API zend_class_entry * zend_ce_countable
Definition zend_interfaces.c:31
zend_iterator_unwrap
ZEND_API zend_object_iterator * zend_iterator_unwrap(zval *array_ptr)
Definition zend_iterators.c:98
zend_iterator_dtor
ZEND_API void zend_iterator_dtor(zend_object_iterator *iter)
Definition zend_iterators.c:89
zend_object_iterator
struct _zend_object_iterator zend_object_iterator
Definition zend_iterators.h:32
zend_object_iterator_funcs
struct _zend_object_iterator_funcs zend_object_iterator_funcs
zend_lazy_object_init
ZEND_API zend_object * zend_lazy_object_init(zend_object *obj)
Definition zend_lazy_objects.c:560
zend_rsrc_list_get_rsrc_type
const char * zend_rsrc_list_get_rsrc_type(zend_resource *res)
Definition zend_list.c:316
zend_llist_apply_with_argument
ZEND_API void zend_llist_apply_with_argument(zend_llist *l, llist_apply_with_arg_func_t func, void *arg)
Definition zend_llist.c:231
llist_apply_with_arg_func_t
void(* llist_apply_with_arg_func_t)(void *data, void *arg)
Definition zend_llist.h:34
zend_long
int32_t zend_long
Definition zend_long.h:42
zend_ulong
uint32_t zend_ulong
Definition zend_long.h:43
SIZEOF_ZEND_LONG
#define SIZEOF_ZEND_LONG
Definition zend_long.h:50
zend_string
struct _zend_string zend_string
Definition zend_map_ptr.h:24
ZEND_MAP_PTR_GET
#define ZEND_MAP_PTR_GET(ptr)
Definition zend_map_ptr.h:54
ZEND_MAP_PTR_SET
#define ZEND_MAP_PTR_SET(ptr, val)
Definition zend_map_ptr.h:60
ZEND_SIGNED_MULTIPLY_LONG
#define ZEND_SIGNED_MULTIPLY_LONG(a, b, lval, dval, usedval)
Definition zend_multiply.h:142
zend_check_property_access
ZEND_API zend_result zend_check_property_access(const zend_object *zobj, zend_string *prop_info_name, bool is_dynamic)
Definition zend_object_handlers.c:534
zend_get_properties_for
ZEND_API HashTable * zend_get_properties_for(zval *obj, zend_prop_purpose purpose)
Definition zend_object_handlers.c:2528
zend_check_protected
ZEND_API bool zend_check_protected(const zend_class_entry *ce, const zend_class_entry *scope)
Definition zend_object_handlers.c:1639
zend_std_unset_static_property
ZEND_API ZEND_COLD bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name)
Definition zend_object_handlers.c:2086
std_object_handlers
ZEND_API const zend_object_handlers std_object_handlers
Definition zend_object_handlers.c:2538
zend_std_build_object_properties_array
ZEND_API HashTable * zend_std_build_object_properties_array(zend_object *zobj)
Definition zend_object_handlers.c:107
zend_get_property_info
ZEND_API zend_property_info * zend_get_property_info(const zend_class_entry *ce, zend_string *member, int silent)
Definition zend_object_handlers.c:469
zend_std_read_property
ZEND_API zval * zend_std_read_property(zend_object *zobj, zend_string *name, int type, void **cache_slot, zval *rv)
Definition zend_object_handlers.c:727
zend_get_property_hook_trampoline
ZEND_API zend_function * zend_get_property_hook_trampoline(const zend_property_info *prop_info, zend_property_hook_kind kind, zend_string *prop_name)
Definition zend_object_handlers.c:1775
rebuild_object_properties_internal
ZEND_API HashTable * rebuild_object_properties_internal(zend_object *zobj)
Definition zend_object_handlers.c:75
zend_std_get_static_method
ZEND_API zend_function * zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name, const zval *key)
Definition zend_object_handlers.c:1932
ZEND_WRONG_PROPERTY_INFO
#define ZEND_WRONG_PROPERTY_INFO
Definition zend_object_handlers.h:32
zend_release_properties
#define zend_release_properties(ht)
Definition zend_object_handlers.h:334
ZEND_IS_PROPERTY_HOOK_SIMPLE_READ
#define ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(offset)
Definition zend_object_handlers.h:50
ZEND_DECODE_DYN_PROP_OFFSET
#define ZEND_DECODE_DYN_PROP_OFFSET(offset)
Definition zend_object_handlers.h:79
zend_get_function_root_class
#define zend_get_function_root_class(fbc)
Definition zend_object_handlers.h:241
ZEND_IS_PROPERTY_HOOK_SIMPLE_GET
#define ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(offset)
Definition zend_object_handlers.h:54
zend_object_clone_obj_t
zend_object *(* zend_object_clone_obj_t)(zend_object *object)
Definition zend_object_handlers.h:182
ZEND_ENCODE_DYN_PROP_OFFSET
#define ZEND_ENCODE_DYN_PROP_OFFSET(offset)
Definition zend_object_handlers.h:80
IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET
#define IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(offset)
Definition zend_object_handlers.h:78
ZEND_PROP_PURPOSE_ARRAY_CAST
@ ZEND_PROP_PURPOSE_ARRAY_CAST
Definition zend_object_handlers.h:134
IS_HOOKED_PROPERTY_OFFSET
#define IS_HOOKED_PROPERTY_OFFSET(offset)
Definition zend_object_handlers.h:43
ZEND_DYNAMIC_PROPERTY_OFFSET
#define ZEND_DYNAMIC_PROPERTY_OFFSET
Definition zend_object_handlers.h:35
ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE
#define ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(offset)
Definition zend_object_handlers.h:52
IS_VALID_PROPERTY_OFFSET
#define IS_VALID_PROPERTY_OFFSET(offset)
Definition zend_object_handlers.h:41
ZEND_STD_BUILD_OBJECT_PROPERTIES_ARRAY_COMPATIBLE
#define ZEND_STD_BUILD_OBJECT_PROPERTIES_ARRAY_COMPATIBLE(object)
Definition zend_object_handlers.h:290
zend_free_trampoline
#define zend_free_trampoline(func)
Definition zend_object_handlers.h:340
IS_DYNAMIC_PROPERTY_OFFSET
#define IS_DYNAMIC_PROPERTY_OFFSET(offset)
Definition zend_object_handlers.h:45
zend_objects_new
ZEND_API zend_object *ZEND_FASTCALL zend_objects_new(zend_class_entry *ce)
Definition zend_objects.c:208
zend_objects_store_del
ZEND_API void ZEND_FASTCALL zend_objects_store_del(zend_object *object)
Definition zend_objects_API.c:160
OBJ_RELEASE
#define OBJ_RELEASE(obj)
Definition zend_objects_API.h:45
zend_observer_fcall_op_array_extension
int zend_observer_fcall_op_array_extension
Definition zend_observer.c:37
ZEND_OBSERVER_DATA
#define ZEND_OBSERVER_DATA(function)
Definition zend_observer.h:39
ZEND_OBSERVER_ENABLED
#define ZEND_OBSERVER_ENABLED
Definition zend_observer.h:47
ZEND_OBSERVER_FCALL_BEGIN
#define ZEND_OBSERVER_FCALL_BEGIN(execute_data)
Definition zend_observer.h:49
decrement_function
ZEND_API zend_result ZEND_FASTCALL decrement_function(zval *op1)
Definition zend_operators.c:2711
compare_function
ZEND_API zend_result ZEND_FASTCALL compare_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:2199
shift_right_function
ZEND_API zend_result ZEND_FASTCALL shift_right_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1925
boolean_xor_function
ZEND_API zend_result ZEND_FASTCALL boolean_xor_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1516
bitwise_not_function
ZEND_API zend_result ZEND_FASTCALL bitwise_not_function(zval *result, zval *op1)
Definition zend_operators.c:1591
mod_function
ZEND_API zend_result ZEND_FASTCALL mod_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1482
mul_function
ZEND_API zend_result ZEND_FASTCALL mul_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1278
div_function
ZEND_API zend_result ZEND_FASTCALL div_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1437
shift_left_function
ZEND_API zend_result ZEND_FASTCALL shift_left_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1888
zend_compare
ZEND_API int ZEND_FASTCALL zend_compare(zval *op1, zval *op2)
Definition zend_operators.c:2250
concat_function
ZEND_API zend_result ZEND_FASTCALL concat_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1961
bitwise_xor_function
ZEND_API zend_result ZEND_FASTCALL bitwise_xor_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1806
pow_function
ZEND_API zend_result ZEND_FASTCALL pow_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1359
increment_function
ZEND_API zend_result ZEND_FASTCALL increment_function(zval *op1)
Definition zend_operators.c:2626
bitwise_and_function
ZEND_API zend_result ZEND_FASTCALL bitwise_and_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1724
bitwise_or_function
ZEND_API zend_result ZEND_FASTCALL bitwise_or_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1642
add_function
ZEND_API zend_result ZEND_FASTCALL add_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1144
sub_function
ZEND_API zend_result ZEND_FASTCALL sub_function(zval *result, zval *op1, zval *op2)
Definition zend_operators.c:1209
zval_get_string_func
ZEND_API zend_string *ZEND_FASTCALL zval_get_string_func(zval *op)
Definition zend_operators.c:1051
zend_class_implements_interface
ZEND_API bool ZEND_FASTCALL zend_class_implements_interface(const zend_class_entry *class_ce, const zend_class_entry *interface_ce)
Definition zend_operators.c:2458
zend_never_inline
#define zend_never_inline
Definition zend_portability.h:380
EXPECTED
#define EXPECTED(condition)
Definition zend_portability.h:389
zend_always_inline
#define zend_always_inline
Definition zend_portability.h:375
ZEND_FASTCALL
#define ZEND_FASTCALL
Definition zend_portability.h:312
ZEND_ASSERT
#define ZEND_ASSERT(c)
Definition zend_portability.h:106
ZEND_COLD
#define ZEND_COLD
Definition zend_portability.h:292
EMPTY_SWITCH_DEFAULT_CASE
#define EMPTY_SWITCH_DEFAULT_CASE()
Definition zend_portability.h:130
UNEXPECTED
#define UNEXPECTED(condition)
Definition zend_portability.h:390
zend_array
struct _zend_array zend_array
Definition zend_property_hooks.h:26
zend_property_hook_kind
zend_property_hook_kind
Definition zend_property_hooks.h:32
ZEND_PROPERTY_HOOK_GET
@ ZEND_PROPERTY_HOOK_GET
Definition zend_property_hooks.h:33
zend_class_entry
struct _zend_class_entry zend_class_entry
Definition zend_property_hooks.h:27
zend_object
struct _zend_object zend_object
Definition zend_property_hooks.h:28
ZSTR_H
#define ZSTR_H(zstr)
Definition zend_string.h:70
ZSTR_COPY_CONCAT_PROPERTIES_BOTH
#define ZSTR_COPY_CONCAT_PROPERTIES_BOTH(out, in1, in2)
Definition zend_string.h:102
ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH
#define ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(s1, s2)
Definition zend_string.h:94
ZSTR_IS_INTERNED
#define ZSTR_IS_INTERNED(s)
Definition zend_string.h:84
ZSTR_VAL
#define ZSTR_VAL(zstr)
Definition zend_string.h:68
ZSTR_COPYABLE_CONCAT_PROPERTIES
#define ZSTR_COPYABLE_CONCAT_PROPERTIES
Definition zend_string.h:90
ZSTR_MAX_LEN
#define ZSTR_MAX_LEN
Definition zend_string.h:117
ZSTR_KNOWN
#define ZSTR_KNOWN(idx)
Definition zend_string.h:110
ZSTR_EMPTY_ALLOC
#define ZSTR_EMPTY_ALLOC()
Definition zend_string.h:108
ZSTR_LEN
#define ZSTR_LEN(zstr)
Definition zend_string.h:69
zend_string_equals_literal_ci
#define zend_string_equals_literal_ci(str, c)
Definition zend_string.h:397
ZSTR_GET_COPYABLE_CONCAT_PROPERTIES
#define ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(s)
Definition zend_string.h:92
d1
#define d1
Definition zend_vm_def.h:521
MAY_BE_REF
#define MAY_BE_REF
Definition zend_type_info.h:36
MAY_BE_STRING
#define MAY_BE_STRING
Definition zend_type_info.h:31
MAY_BE_FALSE
#define MAY_BE_FALSE
Definition zend_type_info.h:26
MAY_BE_UNDEF
#define MAY_BE_UNDEF
Definition zend_type_info.h:24
MAY_BE_NULL
#define MAY_BE_NULL
Definition zend_type_info.h:25
MAY_BE_DOUBLE
#define MAY_BE_DOUBLE
Definition zend_type_info.h:30
MAY_BE_LONG
#define MAY_BE_LONG
Definition zend_type_info.h:29
MAY_BE_TRUE
#define MAY_BE_TRUE
Definition zend_type_info.h:27
MAY_BE_ANY
#define MAY_BE_ANY
Definition zend_type_info.h:35
MAY_BE_OBJECT
#define MAY_BE_OBJECT
Definition zend_type_info.h:33
MAY_BE_RESOURCE
#define MAY_BE_RESOURCE
Definition zend_type_info.h:34
MAY_BE_ARRAY
#define MAY_BE_ARRAY
Definition zend_type_info.h:32
Z_TYPE_P
#define Z_TYPE_P(zval_p)
Definition zend_types.h:660
IS_TRUE
#define IS_TRUE
Definition zend_types.h:603
ZVAL_STR
#define ZVAL_STR(z, s)
Definition zend_types.h:1078
Z_SET_REFCOUNT_P
#define Z_SET_REFCOUNT_P(pz, rc)
Definition zend_types.h:1266
ZVAL_FALSE
#define ZVAL_FALSE(z)
Definition zend_types.h:1053
GC_DTOR
#define GC_DTOR(p)
Definition zend_types.h:716
Z_ISREF_P
#define Z_ISREF_P(zval_p)
Definition zend_types.h:954
Z_TRY_ADDREF_P
#define Z_TRY_ADDREF_P(pz)
Definition zend_types.h:1275
ZVAL_NEW_EMPTY_REF
#define ZVAL_NEW_EMPTY_REF(z)
Definition zend_types.h:1185
ZVAL_UNDEF
#define ZVAL_UNDEF(z)
Definition zend_types.h:1045
GC_SET_REFCOUNT
#define GC_SET_REFCOUNT(p, rc)
Definition zend_types.h:708
Z_REFVAL_P
#define Z_REFVAL_P(zval_p)
Definition zend_types.h:1023
IS_FALSE
#define IS_FALSE
Definition zend_types.h:602
Z_STRVAL_P
#define Z_STRVAL_P(zval_p)
Definition zend_types.h:975
IS_UNDEF
#define IS_UNDEF
Definition zend_types.h:600
Z_ISUNDEF_P
#define Z_ISUNDEF_P(zval_p)
Definition zend_types.h:957
Z_ARRVAL_P
#define Z_ARRVAL_P(zval_p)
Definition zend_types.h:987
ZVAL_TRUE
#define ZVAL_TRUE(z)
Definition zend_types.h:1057
ZVAL_NULL
#define ZVAL_NULL(z)
Definition zend_types.h:1049
ZVAL_DEREF
#define ZVAL_DEREF(z)
Definition zend_types.h:1462
ZVAL_LONG
#define ZVAL_LONG(z, l)
Definition zend_types.h:1066
GC_REFERENCE
#define GC_REFERENCE
Definition zend_types.h:789
IS_STRING
#define IS_STRING
Definition zend_types.h:606
GC_DTOR_NO_REF
#define GC_DTOR_NO_REF(p)
Definition zend_types.h:726
Z_OPT_REFCOUNTED_P
#define Z_OPT_REFCOUNTED_P(zval_p)
Definition zend_types.h:944
Z_FE_POS_P
#define Z_FE_POS_P(zval_p)
Definition zend_types.h:684
Z_CE
#define Z_CE(zval)
Definition zend_types.h:1036
Z_REFCOUNTED_P
#define Z_REFCOUNTED_P(zval_p)
Definition zend_types.h:921
ZVAL_STR_COPY
#define ZVAL_STR_COPY(z, s)
Definition zend_types.h:1102
Z_FE_ITER_P
#define Z_FE_ITER_P(zval_p)
Definition zend_types.h:687
ZVAL_INDIRECT
#define ZVAL_INDIRECT(z, v)
Definition zend_types.h:1236
HashTable
struct _zend_array HashTable
Definition zend_types.h:386
IS_RESOURCE
#define IS_RESOURCE
Definition zend_types.h:609
Z_OBJ_P
#define Z_OBJ_P(zval_p)
Definition zend_types.h:990
IS_ARRAY
#define IS_ARRAY
Definition zend_types.h:607
ZVAL_COPY_OR_DUP
#define ZVAL_COPY_OR_DUP(z, v)
Definition zend_types.h:1444
Z_OBJ_HT_P
#define Z_OBJ_HT_P(zval_p)
Definition zend_types.h:993
ZVAL_COPY_DEREF
#define ZVAL_COPY_DEREF(z, v)
Definition zend_types.h:1496
IS_DOUBLE
#define IS_DOUBLE
Definition zend_types.h:605
Z_TYPE_INFO_P
#define Z_TYPE_INFO_P(zval_p)
Definition zend_types.h:669
Z_ISUNDEF
#define Z_ISUNDEF(zval)
Definition zend_types.h:956
ZVAL_OPT_DEREF
#define ZVAL_OPT_DEREF(z)
Definition zend_types.h:1474
Z_OPT_ISREF_P
#define Z_OPT_ISREF_P(zval_p)
Definition zend_types.h:951
Z_COUNTED_P
#define Z_COUNTED_P(zval_p)
Definition zend_types.h:699
IS_REFERENCE_EX
#define IS_REFERENCE_EX
Definition zend_types.h:811
Z_STR_P
#define Z_STR_P(zval_p)
Definition zend_types.h:972
Z_TYPE_MASK
#define Z_TYPE_MASK
Definition zend_types.h:701
Z_PTR_P
#define Z_PTR_P(zval_p)
Definition zend_types.h:1043
ZVAL_NEW_REF
#define ZVAL_NEW_REF(z, r)
Definition zend_types.h:1195
Z_STR
#define Z_STR(zval)
Definition zend_types.h:971
GC_DELREF
#define GC_DELREF(p)
Definition zend_types.h:710
GC_FLAGS
#define GC_FLAGS(p)
Definition zend_types.h:756
GC_ADDREF
#define GC_ADDREF(p)
Definition zend_types.h:709
Z_FUNC_P
#define Z_FUNC_P(zval_p)
Definition zend_types.h:1040
ZEND_TYPE_FULL_MASK
#define ZEND_TYPE_FULL_MASK(t)
Definition zend_types.h:254
Z_ADDREF_P
#define Z_ADDREF_P(pz)
Definition zend_types.h:1267
Z_PTR
#define Z_PTR(zval)
Definition zend_types.h:1042
Z_STRLEN_P
#define Z_STRLEN_P(zval_p)
Definition zend_types.h:978
ZVAL_UNREF
#define ZVAL_UNREF(z)
Definition zend_types.h:1487
Z_OPLINE_NUM_P
#define Z_OPLINE_NUM_P(zval_p)
Definition zend_types.h:681
IS_NULL
#define IS_NULL
Definition zend_types.h:601
Z_OBJCE_P
#define Z_OBJCE_P(zval_p)
Definition zend_types.h:1002
ZVAL_OBJ
#define ZVAL_OBJ(z, o)
Definition zend_types.h:1130
FAILURE
@ FAILURE
Definition zend_types.h:61
Z_FE_POS
#define Z_FE_POS(zval)
Definition zend_types.h:683
IS_OBJECT
#define IS_OBJECT
Definition zend_types.h:608
Z_ADDREF
#define Z_ADDREF(z)
Definition zend_types.h:1272
IS_LONG
#define IS_LONG
Definition zend_types.h:604
ZVAL_ARR
#define ZVAL_ARR(z, a)
Definition zend_types.h:1115
ZEND_TYPE_IS_SET
#define ZEND_TYPE_IS_SET(t)
Definition zend_types.h:166
Z_DELREF_P
#define Z_DELREF_P(pz)
Definition zend_types.h:1268
IS_REFERENCE
#define IS_REFERENCE
Definition zend_types.h:610
Z_RES_HANDLE_P
#define Z_RES_HANDLE_P(zval_p)
Definition zend_types.h:1011
ZVAL_NEW_STR
#define ZVAL_NEW_STR(z, s)
Definition zend_types.h:1095
ZVAL_COPY
#define ZVAL_COPY(z, v)
Definition zend_types.h:1412
HashPosition
uint32_t HashPosition
Definition zend_types.h:548
_IS_BOOL
#define _IS_BOOL
Definition zend_types.h:629
Z_OPT_REFCOUNTED
#define Z_OPT_REFCOUNTED(zval)
Definition zend_types.h:943
zend_refcounted
struct _zend_refcounted zend_refcounted
Definition zend_types.h:95
Z_TYPE_INFO
#define Z_TYPE_INFO(zval)
Definition zend_types.h:668
Bucket
struct _Bucket Bucket
Z_TYPE_INFO_REFCOUNTED
#define Z_TYPE_INFO_REFCOUNTED(t)
Definition zend_types.h:799
Z_INDIRECT_P
#define Z_INDIRECT_P(zval_p)
Definition zend_types.h:1034
Z_REF_P
#define Z_REF_P(zval_p)
Definition zend_types.h:1020
Z_OBJPROP_P
#define Z_OBJPROP_P(zval_p)
Definition zend_types.h:1005
ZVAL_DOUBLE
#define ZVAL_DOUBLE(z, d)
Definition zend_types.h:1072
Z_REFCOUNT_P
#define Z_REFCOUNT_P(pz)
Definition zend_types.h:1265
ZVAL_MAKE_REF_EX
#define ZVAL_MAKE_REF_EX(z, refcount)
Definition zend_types.h:1206
zend_result
ZEND_RESULT_CODE zend_result
Definition zend_types.h:64
IS_ARRAY_IMMUTABLE
#define IS_ARRAY_IMMUTABLE
Definition zend_types.h:823
Z_ISERROR_P
#define Z_ISERROR_P(zval_p)
Definition zend_types.h:963
IS_CONSTANT_AST
#define IS_CONSTANT_AST
Definition zend_types.h:611
Z_CE_P
#define Z_CE_P(zval_p)
Definition zend_types.h:1037
ZVAL_REF
#define ZVAL_REF(z, r)
Definition zend_types.h:1179
Z_RES_P
#define Z_RES_P(zval_p)
Definition zend_types.h:1008
SEPARATE_ARRAY
#define SEPARATE_ARRAY(zv)
Definition zend_types.h:1524
Z_CACHE_SLOT_P
#define Z_CACHE_SLOT_P(zval_p)
Definition zend_types.h:675
GC_REFCOUNT
#define GC_REFCOUNT(p)
Definition zend_types.h:707
GC_IS_RECURSIVE
#define GC_IS_RECURSIVE(p)
Definition zend_types.h:865
Z_TYPE
#define Z_TYPE(zval)
Definition zend_types.h:659
ZVAL_INTERNED_STR
#define ZVAL_INTERNED_STR(z, s)
Definition zend_types.h:1088
ZEND_TYPE_CONTAINS_CODE
#define ZEND_TYPE_CONTAINS_CODE(t, code)
Definition zend_types.h:266
Z_DVAL_P
#define Z_DVAL_P(zval_p)
Definition zend_types.h:969
IS_INDIRECT
#define IS_INDIRECT
Definition zend_types.h:623
zend_execute_data
struct _zend_execute_data zend_execute_data
Definition zend_types.h:91
Z_ARR_P
#define Z_ARR_P(zval_p)
Definition zend_types.h:984
Z_LVAL_P
#define Z_LVAL_P(zval_p)
Definition zend_types.h:966
ZVAL_COPY_VALUE
#define ZVAL_COPY_VALUE(z, v)
Definition zend_types.h:1403
Z_EXTRA_P
#define Z_EXTRA_P(zval_p)
Definition zend_types.h:696
zend_reference
struct _zend_reference zend_reference
Definition zend_types.h:100
ZVAL_BOOL
#define ZVAL_BOOL(z, b)
Definition zend_types.h:1061
Z_LVAL
#define Z_LVAL(zval)
Definition zend_types.h:965
Z_OPT_CONSTANT
#define Z_OPT_CONSTANT(zval)
Definition zend_types.h:940
GC_ADD_FLAGS
#define GC_ADD_FLAGS(p, flags)
Definition zend_types.h:759
Z_OBJCE
#define Z_OBJCE(zval)
Definition zend_types.h:1001
GC_TYPE_INFO
#define GC_TYPE_INFO(p)
Definition zend_types.h:754
Z_OPT_TYPE_P
#define Z_OPT_TYPE_P(zval_p)
Definition zend_types.h:938
Z_OBJ
#define Z_OBJ(zval)
Definition zend_types.h:989
rc_dtor_func
ZEND_API void ZEND_FASTCALL rc_dtor_func(zend_refcounted *p)
Definition zend_variables.c:54
zval_ptr_dtor
ZEND_API void zval_ptr_dtor(zval *zval_ptr)
Definition zend_variables.c:82
zval_add_ref
ZEND_API void zval_add_ref(zval *p)
Definition zend_variables.c:113
container
container
Definition zend_vm_def.h:2842
retval
zval retval
Definition zend_vm_def.h:4055
d2
double d2
Definition zend_vm_def.h:169
call_info
uint32_t call_info
Definition zend_vm_def.h:4091
tmp_name
zend_string * tmp_name
Definition zend_vm_def.h:2429
new_op_array
new_op_array
Definition zend_vm_def.h:6494
return_value
zval * return_value
Definition zend_vm_def.h:4441
varptr
varptr
Definition zend_vm_def.h:5083
arg1
zval * arg1
Definition zend_vm_def.h:9690
prev_execute_data
call prev_execute_data
Definition zend_vm_def.h:4060
arg2
zval * arg2
Definition zend_vm_def.h:9717
prop_info
zend_property_info * prop_info
Definition zend_vm_def.h:2582
call_args
zval * call_args
Definition zend_vm_def.h:8890
retval_ptr
retval_ptr
Definition zend_vm_def.h:4444
arg_num
uint32_t arg_num
Definition zend_vm_def.h:4837
orig_object_ptr
orig_object_ptr
Definition zend_vm_def.h:2624
dim
zval * dim
Definition zend_vm_def.h:2620
generator
zend_generator * generator
Definition zend_vm_def.h:4664
name
zend_string * name
Definition zend_vm_def.h:2429
inc_filename
zval * inc_filename
Definition zend_vm_def.h:6490
arg3
zval * arg3
Definition zend_vm_def.h:9752
handler
fbc internal_function handler(call, ret)
fbc
zend_function * fbc
Definition zend_vm_def.h:4053
value_ptr
value_ptr
Definition zend_vm_def.h:2845
result
bool result
Definition zend_vm_def.h:455
op2
op2
Definition zend_vm_def.h:172
function
function(EX_VAR(opline->result.var))
op1
op1
Definition zend_vm_def.h:171
variable_ptr
zval * variable_ptr
Definition zend_vm_def.h:2619
execute_data
execute_data
Definition zend_vm_def.h:4130
object
object
Definition zend_vm_def.h:2433
garbage
zend_refcounted * garbage
Definition zend_vm_def.h:2430
ret
zval * ret
Definition zend_vm_def.h:4054
value
value
Definition zend_vm_def.h:2434
var_ptr
var_ptr
Definition zend_vm_def.h:1507
call
zend_execute_data * call
Definition zend_vm_def.h:6525
property
property
Definition zend_vm_def.h:2843
scope
new_op_array scope
Definition zend_vm_def.h:6530
zobj
zend_object * zobj
Definition zend_vm_def.h:2428
zend_get_opcode_handler_func
ZEND_API const void *ZEND_FASTCALL zend_get_opcode_handler_func(const zend_op *op)
Definition zend_vm_execute.h:68077
ZEND_VM_ENTER
#define ZEND_VM_ENTER()
Definition zend_vm_execute.h:437
execute_ex
ZEND_API void execute_ex(zend_execute_data *ex)
Definition zend_vm_execute.h:55053
SPEC_RULE_QUICK_ARG
#define SPEC_RULE_QUICK_ARG
Definition zend_vm_execute.h:315
zend_vm_set_opcode_handler
ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler(zend_op *op)
Definition zend_vm_execute.h:68170
HANDLE_EXCEPTION_LEAVE
#define HANDLE_EXCEPTION_LEAVE()
Definition zend_vm_execute.h:426
ZEND_OPCODE_HANDLER_RET
#define ZEND_OPCODE_HANDLER_RET
Definition zend_vm_execute.h:397
ZEND_VM_COLD
#define ZEND_VM_COLD
Definition zend_vm_execute.h:402
ZEND_VM_HOT
#define ZEND_VM_HOT
Definition zend_vm_execute.h:401
OPLINE
#define OPLINE
Definition zend_vm_execute.h:417
zend_vm_init
void zend_vm_init(void)
Definition zend_vm_execute.h:64272
opcode_handler_t
ZEND_OPCODE_HANDLER_RET(ZEND_FASTCALL * opcode_handler_t)(ZEND_OPCODE_HANDLER_ARGS)
Definition zend_vm_execute.h:405
ZEND_VM_LEAVE
#define ZEND_VM_LEAVE()
Definition zend_vm_execute.h:438
HYBRID_DEFAULT
#define HYBRID_DEFAULT
Definition zend_vm_execute.h:364
VM_TRACE_OP_END
#define VM_TRACE_OP_END(op)
Definition zend_vm_execute.h:342
SPEC_RULE_OP2
#define SPEC_RULE_OP2
Definition zend_vm_execute.h:312
ZEND_VM_ENTER_EX
#define ZEND_VM_ENTER_EX()
Definition zend_vm_execute.h:436
SPEC_EXTRA_MASK
#define SPEC_EXTRA_MASK
Definition zend_vm_execute.h:310
zend_execute
ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value)
Definition zend_vm_execute.h:64239
VM_TRACE
#define VM_TRACE(op)
Definition zend_vm_execute.h:339
SAVE_OPLINE_EX
#define SAVE_OPLINE_EX()
Definition zend_vm_execute.h:423
zend_vm_call_opcode_handler
ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data *ex)
Definition zend_vm_execute.h:68458
SPEC_RULE_COMMUTATIVE
#define SPEC_RULE_COMMUTATIVE
Definition zend_vm_execute.h:317
SAVE_OPLINE
#define SAVE_OPLINE()
Definition zend_vm_execute.h:422
SPEC_RULE_OP1
#define SPEC_RULE_OP1
Definition zend_vm_execute.h:311
ZEND_OPCODE_HANDLER_ARGS_PASSTHRU
#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU
Definition zend_vm_execute.h:374
LOAD_OPLINE
#define LOAD_OPLINE()
Definition zend_vm_execute.h:419
zend_vm_kind
ZEND_API int zend_vm_kind(void)
Definition zend_vm_execute.h:68104
SPEC_RULE_SMART_BRANCH
#define SPEC_RULE_SMART_BRANCH
Definition zend_vm_execute.h:316
HYBRID_SWITCH
#define HYBRID_SWITCH()
Definition zend_vm_execute.h:361
DCL_OPLINE
#define DCL_OPLINE
Definition zend_vm_execute.h:407
HANDLE_EXCEPTION
#define HANDLE_EXCEPTION()
Definition zend_vm_execute.h:425
HYBRID_CASE
#define HYBRID_CASE(op)
Definition zend_vm_execute.h:362
SPEC_RULE_OBSERVER
#define SPEC_RULE_OBSERVER
Definition zend_vm_execute.h:319
USE_OPLINE
#define USE_OPLINE
Definition zend_vm_execute.h:418
zend_get_halt_op
ZEND_API const zend_op * zend_get_halt_op(void)
Definition zend_vm_execute.h:68095
ZEND_VM_RETURN
#define ZEND_VM_RETURN()
Definition zend_vm_execute.h:400
ZEND_VM_DISPATCH
#define ZEND_VM_DISPATCH(opcode, opline)
Definition zend_vm_execute.h:442
zend_serialize_opcode_handler
ZEND_API void ZEND_FASTCALL zend_serialize_opcode_handler(zend_op *op)
Definition zend_vm_execute.h:68060
zend_vm_set_opcode_handler_ex
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)
Definition zend_vm_execute.h:68182
SPEC_RULE_RETVAL
#define SPEC_RULE_RETVAL
Definition zend_vm_execute.h:314
ZEND_VM_TAIL_CALL
#define ZEND_VM_TAIL_CALL(call)
Definition zend_vm_execute.h:398
zend_deserialize_opcode_handler
ZEND_API void ZEND_FASTCALL zend_deserialize_opcode_handler(zend_op *op)
Definition zend_vm_execute.h:68072
SPEC_RULE_ISSET
#define SPEC_RULE_ISSET
Definition zend_vm_execute.h:318
LOAD_OPLINE_EX
#define LOAD_OPLINE_EX()
Definition zend_vm_execute.h:420
ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC
#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC
Definition zend_vm_execute.h:376
LOAD_NEXT_OPLINE
#define LOAD_NEXT_OPLINE()
Definition zend_vm_execute.h:421
VM_TRACE_START
#define VM_TRACE_START()
Definition zend_vm_execute.h:345
VM_TRACE_END
#define VM_TRACE_END()
Definition zend_vm_execute.h:348
ZEND_VM_CONTINUE
#define ZEND_VM_CONTINUE()
Definition zend_vm_execute.h:399
SPEC_RULE_OP_DATA
#define SPEC_RULE_OP_DATA
Definition zend_vm_execute.h:313
SPEC_START_MASK
#define SPEC_START_MASK
Definition zend_vm_execute.h:309
HYBRID_BREAK
#define HYBRID_BREAK()
Definition zend_vm_execute.h:363
zend_vm_dtor
void zend_vm_dtor(void)
Definition zend_vm_execute.h:68035
ZEND_OPCODE_HANDLER_ARGS
#define ZEND_OPCODE_HANDLER_ARGS
Definition zend_vm_execute.h:373
ZEND_OPCODE_HANDLER_ARGS_DC
#define ZEND_OPCODE_HANDLER_ARGS_DC
Definition zend_vm_execute.h:375
ZEND_FE_FREE
#define ZEND_FE_FREE
Definition zend_vm_opcodes.h:211
ZEND_SEND_VAR_EX
#define ZEND_SEND_VAR_EX
Definition zend_vm_opcodes.h:151
ZEND_IS_IDENTICAL
#define ZEND_IS_IDENTICAL
Definition zend_vm_opcodes.h:102
ZEND_DECLARE_ANON_CLASS
#define ZEND_DECLARE_ANON_CLASS
Definition zend_vm_opcodes.h:230
ZEND_RECV_INIT
#define ZEND_RECV_INIT
Definition zend_vm_opcodes.h:149
ZEND_SEND_VAL_EX
#define ZEND_SEND_VAL_EX
Definition zend_vm_opcodes.h:200
ZEND_USER_OPCODE
#define ZEND_USER_OPCODE
Definition zend_vm_opcodes.h:234
ZEND_RETURN
#define ZEND_RETURN
Definition zend_vm_opcodes.h:147
ZEND_FE_FETCH_R
#define ZEND_FE_FETCH_R
Definition zend_vm_opcodes.h:163
ZEND_ROPE_INIT
#define ZEND_ROPE_INIT
Definition zend_vm_opcodes.h:139
ZEND_INIT_FCALL
#define ZEND_INIT_FCALL
Definition zend_vm_opcodes.h:146
ZEND_SEND_VAL
#define ZEND_SEND_VAL
Definition zend_vm_opcodes.h:150
ZEND_BOOL_XOR
#define ZEND_BOOL_XOR
Definition zend_vm_opcodes.h:101
ZEND_SUB
#define ZEND_SUB
Definition zend_vm_opcodes.h:88
ZEND_VM_KIND
#define ZEND_VM_KIND
Definition zend_vm_opcodes.h:34
ZEND_IS_SMALLER
#define ZEND_IS_SMALLER
Definition zend_vm_opcodes.h:106
ZEND_PRE_INC
#define ZEND_PRE_INC
Definition zend_vm_opcodes.h:120
ZEND_POST_INC
#define ZEND_POST_INC
Definition zend_vm_opcodes.h:122
ZEND_PRE_DEC
#define ZEND_PRE_DEC
Definition zend_vm_opcodes.h:121
ZEND_BW_XOR
#define ZEND_BW_XOR
Definition zend_vm_opcodes.h:97
ZEND_IS_NOT_EQUAL
#define ZEND_IS_NOT_EQUAL
Definition zend_vm_opcodes.h:105
ZEND_IS_NOT_IDENTICAL
#define ZEND_IS_NOT_IDENTICAL
Definition zend_vm_opcodes.h:103
ZEND_ROPE_ADD
#define ZEND_ROPE_ADD
Definition zend_vm_opcodes.h:140
ZEND_SEND_VAR
#define ZEND_SEND_VAR
Definition zend_vm_opcodes.h:201
ZEND_BW_OR
#define ZEND_BW_OR
Definition zend_vm_opcodes.h:95
ZEND_RECV
#define ZEND_RECV
Definition zend_vm_opcodes.h:148
ZEND_DO_FCALL
#define ZEND_DO_FCALL
Definition zend_vm_opcodes.h:145
ZEND_ADD_ARRAY_ELEMENT
#define ZEND_ADD_ARRAY_ELEMENT
Definition zend_vm_opcodes.h:157
ZEND_IS_EQUAL
#define ZEND_IS_EQUAL
Definition zend_vm_opcodes.h:104
ZEND_IS_SMALLER_OR_EQUAL
#define ZEND_IS_SMALLER_OR_EQUAL
Definition zend_vm_opcodes.h:107
ZEND_POST_DEC
#define ZEND_POST_DEC
Definition zend_vm_opcodes.h:123
ZEND_MUL
#define ZEND_MUL
Definition zend_vm_opcodes.h:89
ZEND_FETCH_CLASS
#define ZEND_FETCH_CLASS
Definition zend_vm_opcodes.h:193
ZEND_BIND_GLOBAL
#define ZEND_BIND_GLOBAL
Definition zend_vm_opcodes.h:252
ZEND_BW_AND
#define ZEND_BW_AND
Definition zend_vm_opcodes.h:96
ZEND_ADD_ARRAY_UNPACK
#define ZEND_ADD_ARRAY_UNPACK
Definition zend_vm_opcodes.h:231
ZEND_JMP
#define ZEND_JMP
Definition zend_vm_opcodes.h:128
ZEND_FREE
#define ZEND_FREE
Definition zend_vm_opcodes.h:155
ZEND_COUNT
#define ZEND_COUNT
Definition zend_vm_opcodes.h:274
ZEND_FETCH_DIM_R
#define ZEND_FETCH_DIM_R
Definition zend_vm_opcodes.h:165
ZEND_QM_ASSIGN
#define ZEND_QM_ASSIGN
Definition zend_vm_opcodes.h:117
ZEND_ADD
#define ZEND_ADD
Definition zend_vm_opcodes.h:87