1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 2.00 of the Zend license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.zend.com/license/2_00.txt. |
11 | If you did not receive a copy of the Zend license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@zend.com so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Andi Gutmans <andi@php.net> |
16 | Zeev Suraski <zeev@php.net> |
17 | Dmitry Stogov <dmitry@php.net> |
18 +----------------------------------------------------------------------+
19 */
20
21 #ifdef ZEND_WIN32
22 # pragma warning(disable : 4101)
23 # pragma warning(once : 6235)
24 # pragma warning(once : 6237)
25 # pragma warning(once : 6239)
26 # pragma warning(once : 6240)
27 # pragma warning(once : 6285)
28 # pragma warning(once : 6286)
29 # pragma warning(once : 6326)
30 #endif
31 static user_opcode_handler_t zend_user_opcode_handlers[256] = {
32 (user_opcode_handler_t)NULL,
33 (user_opcode_handler_t)NULL,
34 (user_opcode_handler_t)NULL,
35 (user_opcode_handler_t)NULL,
36 (user_opcode_handler_t)NULL,
37 (user_opcode_handler_t)NULL,
38 (user_opcode_handler_t)NULL,
39 (user_opcode_handler_t)NULL,
40 (user_opcode_handler_t)NULL,
41 (user_opcode_handler_t)NULL,
42 (user_opcode_handler_t)NULL,
43 (user_opcode_handler_t)NULL,
44 (user_opcode_handler_t)NULL,
45 (user_opcode_handler_t)NULL,
46 (user_opcode_handler_t)NULL,
47 (user_opcode_handler_t)NULL,
48 (user_opcode_handler_t)NULL,
49 (user_opcode_handler_t)NULL,
50 (user_opcode_handler_t)NULL,
51 (user_opcode_handler_t)NULL,
52 (user_opcode_handler_t)NULL,
53 (user_opcode_handler_t)NULL,
54 (user_opcode_handler_t)NULL,
55 (user_opcode_handler_t)NULL,
56 (user_opcode_handler_t)NULL,
57 (user_opcode_handler_t)NULL,
58 (user_opcode_handler_t)NULL,
59 (user_opcode_handler_t)NULL,
60 (user_opcode_handler_t)NULL,
61 (user_opcode_handler_t)NULL,
62 (user_opcode_handler_t)NULL,
63 (user_opcode_handler_t)NULL,
64 (user_opcode_handler_t)NULL,
65 (user_opcode_handler_t)NULL,
66 (user_opcode_handler_t)NULL,
67 (user_opcode_handler_t)NULL,
68 (user_opcode_handler_t)NULL,
69 (user_opcode_handler_t)NULL,
70 (user_opcode_handler_t)NULL,
71 (user_opcode_handler_t)NULL,
72 (user_opcode_handler_t)NULL,
73 (user_opcode_handler_t)NULL,
74 (user_opcode_handler_t)NULL,
75 (user_opcode_handler_t)NULL,
76 (user_opcode_handler_t)NULL,
77 (user_opcode_handler_t)NULL,
78 (user_opcode_handler_t)NULL,
79 (user_opcode_handler_t)NULL,
80 (user_opcode_handler_t)NULL,
81 (user_opcode_handler_t)NULL,
82 (user_opcode_handler_t)NULL,
83 (user_opcode_handler_t)NULL,
84 (user_opcode_handler_t)NULL,
85 (user_opcode_handler_t)NULL,
86 (user_opcode_handler_t)NULL,
87 (user_opcode_handler_t)NULL,
88 (user_opcode_handler_t)NULL,
89 (user_opcode_handler_t)NULL,
90 (user_opcode_handler_t)NULL,
91 (user_opcode_handler_t)NULL,
92 (user_opcode_handler_t)NULL,
93 (user_opcode_handler_t)NULL,
94 (user_opcode_handler_t)NULL,
95 (user_opcode_handler_t)NULL,
96 (user_opcode_handler_t)NULL,
97 (user_opcode_handler_t)NULL,
98 (user_opcode_handler_t)NULL,
99 (user_opcode_handler_t)NULL,
100 (user_opcode_handler_t)NULL,
101 (user_opcode_handler_t)NULL,
102 (user_opcode_handler_t)NULL,
103 (user_opcode_handler_t)NULL,
104 (user_opcode_handler_t)NULL,
105 (user_opcode_handler_t)NULL,
106 (user_opcode_handler_t)NULL,
107 (user_opcode_handler_t)NULL,
108 (user_opcode_handler_t)NULL,
109 (user_opcode_handler_t)NULL,
110 (user_opcode_handler_t)NULL,
111 (user_opcode_handler_t)NULL,
112 (user_opcode_handler_t)NULL,
113 (user_opcode_handler_t)NULL,
114 (user_opcode_handler_t)NULL,
115 (user_opcode_handler_t)NULL,
116 (user_opcode_handler_t)NULL,
117 (user_opcode_handler_t)NULL,
118 (user_opcode_handler_t)NULL,
119 (user_opcode_handler_t)NULL,
120 (user_opcode_handler_t)NULL,
121 (user_opcode_handler_t)NULL,
122 (user_opcode_handler_t)NULL,
123 (user_opcode_handler_t)NULL,
124 (user_opcode_handler_t)NULL,
125 (user_opcode_handler_t)NULL,
126 (user_opcode_handler_t)NULL,
127 (user_opcode_handler_t)NULL,
128 (user_opcode_handler_t)NULL,
129 (user_opcode_handler_t)NULL,
130 (user_opcode_handler_t)NULL,
131 (user_opcode_handler_t)NULL,
132 (user_opcode_handler_t)NULL,
133 (user_opcode_handler_t)NULL,
134 (user_opcode_handler_t)NULL,
135 (user_opcode_handler_t)NULL,
136 (user_opcode_handler_t)NULL,
137 (user_opcode_handler_t)NULL,
138 (user_opcode_handler_t)NULL,
139 (user_opcode_handler_t)NULL,
140 (user_opcode_handler_t)NULL,
141 (user_opcode_handler_t)NULL,
142 (user_opcode_handler_t)NULL,
143 (user_opcode_handler_t)NULL,
144 (user_opcode_handler_t)NULL,
145 (user_opcode_handler_t)NULL,
146 (user_opcode_handler_t)NULL,
147 (user_opcode_handler_t)NULL,
148 (user_opcode_handler_t)NULL,
149 (user_opcode_handler_t)NULL,
150 (user_opcode_handler_t)NULL,
151 (user_opcode_handler_t)NULL,
152 (user_opcode_handler_t)NULL,
153 (user_opcode_handler_t)NULL,
154 (user_opcode_handler_t)NULL,
155 (user_opcode_handler_t)NULL,
156 (user_opcode_handler_t)NULL,
157 (user_opcode_handler_t)NULL,
158 (user_opcode_handler_t)NULL,
159 (user_opcode_handler_t)NULL,
160 (user_opcode_handler_t)NULL,
161 (user_opcode_handler_t)NULL,
162 (user_opcode_handler_t)NULL,
163 (user_opcode_handler_t)NULL,
164 (user_opcode_handler_t)NULL,
165 (user_opcode_handler_t)NULL,
166 (user_opcode_handler_t)NULL,
167 (user_opcode_handler_t)NULL,
168 (user_opcode_handler_t)NULL,
169 (user_opcode_handler_t)NULL,
170 (user_opcode_handler_t)NULL,
171 (user_opcode_handler_t)NULL,
172 (user_opcode_handler_t)NULL,
173 (user_opcode_handler_t)NULL,
174 (user_opcode_handler_t)NULL,
175 (user_opcode_handler_t)NULL,
176 (user_opcode_handler_t)NULL,
177 (user_opcode_handler_t)NULL,
178 (user_opcode_handler_t)NULL,
179 (user_opcode_handler_t)NULL,
180 (user_opcode_handler_t)NULL,
181 (user_opcode_handler_t)NULL,
182 (user_opcode_handler_t)NULL,
183 (user_opcode_handler_t)NULL,
184 (user_opcode_handler_t)NULL,
185 (user_opcode_handler_t)NULL,
186 (user_opcode_handler_t)NULL,
187 (user_opcode_handler_t)NULL,
188 (user_opcode_handler_t)NULL,
189 (user_opcode_handler_t)NULL,
190 (user_opcode_handler_t)NULL,
191 (user_opcode_handler_t)NULL,
192 (user_opcode_handler_t)NULL,
193 (user_opcode_handler_t)NULL,
194 (user_opcode_handler_t)NULL,
195 (user_opcode_handler_t)NULL,
196 (user_opcode_handler_t)NULL,
197 (user_opcode_handler_t)NULL,
198 (user_opcode_handler_t)NULL,
199 (user_opcode_handler_t)NULL,
200 (user_opcode_handler_t)NULL,
201 (user_opcode_handler_t)NULL,
202 (user_opcode_handler_t)NULL,
203 (user_opcode_handler_t)NULL,
204 (user_opcode_handler_t)NULL,
205 (user_opcode_handler_t)NULL,
206 (user_opcode_handler_t)NULL,
207 (user_opcode_handler_t)NULL,
208 (user_opcode_handler_t)NULL,
209 (user_opcode_handler_t)NULL,
210 (user_opcode_handler_t)NULL,
211 (user_opcode_handler_t)NULL,
212 (user_opcode_handler_t)NULL,
213 (user_opcode_handler_t)NULL,
214 (user_opcode_handler_t)NULL,
215 (user_opcode_handler_t)NULL,
216 (user_opcode_handler_t)NULL,
217 (user_opcode_handler_t)NULL,
218 (user_opcode_handler_t)NULL,
219 (user_opcode_handler_t)NULL,
220 (user_opcode_handler_t)NULL,
221 (user_opcode_handler_t)NULL,
222 (user_opcode_handler_t)NULL,
223 (user_opcode_handler_t)NULL,
224 (user_opcode_handler_t)NULL,
225 (user_opcode_handler_t)NULL,
226 (user_opcode_handler_t)NULL,
227 (user_opcode_handler_t)NULL,
228 (user_opcode_handler_t)NULL,
229 (user_opcode_handler_t)NULL,
230 (user_opcode_handler_t)NULL,
231 (user_opcode_handler_t)NULL,
232 (user_opcode_handler_t)NULL,
233 (user_opcode_handler_t)NULL,
234 (user_opcode_handler_t)NULL,
235 (user_opcode_handler_t)NULL,
236 (user_opcode_handler_t)NULL,
237 (user_opcode_handler_t)NULL,
238 (user_opcode_handler_t)NULL,
239 (user_opcode_handler_t)NULL,
240 (user_opcode_handler_t)NULL,
241 (user_opcode_handler_t)NULL,
242 (user_opcode_handler_t)NULL,
243 (user_opcode_handler_t)NULL,
244 (user_opcode_handler_t)NULL,
245 (user_opcode_handler_t)NULL,
246 (user_opcode_handler_t)NULL,
247 (user_opcode_handler_t)NULL,
248 (user_opcode_handler_t)NULL,
249 (user_opcode_handler_t)NULL,
250 (user_opcode_handler_t)NULL,
251 (user_opcode_handler_t)NULL,
252 (user_opcode_handler_t)NULL,
253 (user_opcode_handler_t)NULL,
254 (user_opcode_handler_t)NULL,
255 (user_opcode_handler_t)NULL,
256 (user_opcode_handler_t)NULL,
257 (user_opcode_handler_t)NULL,
258 (user_opcode_handler_t)NULL,
259 (user_opcode_handler_t)NULL,
260 (user_opcode_handler_t)NULL,
261 (user_opcode_handler_t)NULL,
262 (user_opcode_handler_t)NULL,
263 (user_opcode_handler_t)NULL,
264 (user_opcode_handler_t)NULL,
265 (user_opcode_handler_t)NULL,
266 (user_opcode_handler_t)NULL,
267 (user_opcode_handler_t)NULL,
268 (user_opcode_handler_t)NULL,
269 (user_opcode_handler_t)NULL,
270 (user_opcode_handler_t)NULL,
271 (user_opcode_handler_t)NULL,
272 (user_opcode_handler_t)NULL,
273 (user_opcode_handler_t)NULL,
274 (user_opcode_handler_t)NULL,
275 (user_opcode_handler_t)NULL,
276 (user_opcode_handler_t)NULL,
277 (user_opcode_handler_t)NULL,
278 (user_opcode_handler_t)NULL,
279 (user_opcode_handler_t)NULL,
280 (user_opcode_handler_t)NULL,
281 (user_opcode_handler_t)NULL,
282 (user_opcode_handler_t)NULL,
283 (user_opcode_handler_t)NULL,
284 (user_opcode_handler_t)NULL,
285 (user_opcode_handler_t)NULL,
286 (user_opcode_handler_t)NULL,
287 (user_opcode_handler_t)NULL
288 };
289
290 static uint8_t zend_user_opcodes[256] = {0,
291 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
292 17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,
293 33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,
294 49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,
295 65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,
296 81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,
297 97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,
298 113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,
299 129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,
300 145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,
301 161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,
302 177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,
303 193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,
304 209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,
305 225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,
306 241,242,243,244,245,246,247,248,249,250,251,252,253,254,255
307 };
308
309 #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
321 static const uint32_t *zend_spec_handlers;
322 static const void * const *zend_opcode_handlers;
323 static int zend_handlers_count;
324 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
325 static const void * const * zend_opcode_handler_funcs;
326 static zend_op hybrid_halt_op;
327 #endif
328 #if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC
329 static 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)
333 static 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
405 typedef 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
444 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS);
445 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS);
446
zend_add_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)447 static 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
zend_sub_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)468 static 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
zend_mul_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)489 static 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
zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)510 static 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
zend_mod_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)520 static 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
zend_shift_left_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)541 static 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
zend_shift_right_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)562 static 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
zend_is_equal_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)583 static 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
zend_is_not_equal_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)605 static 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
zend_is_smaller_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)627 static 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
zend_is_smaller_or_equal_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)649 static 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
zend_bw_or_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)671 static 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
zend_bw_and_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)692 static 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
zend_bw_xor_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)713 static 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
zend_bw_not_helper_SPEC(zval * op_1 ZEND_OPCODE_HANDLER_ARGS_DC)734 static 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
zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)747 static 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
zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)757 static 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
ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)768 static 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
ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)814 static 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) */
ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)834 static 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) */
zend_fetch_static_prop_helper_SPEC(int type ZEND_OPCODE_HANDLER_ARGS_DC)854 static 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) */
ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)875 static 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) */
ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)881 static 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) */
ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)887 static 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) */
ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)893 static 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) */
ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)902 static 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) */
ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)908 static 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
zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)913 static 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
zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)925 static 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
ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)937 static 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
ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)973 static 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
ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1009 static 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
ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1045 static 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
ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1081 static 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
zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)1120 static 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
ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1259 static 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
ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1266 static 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
ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1330 static 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
ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1394 static 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
ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1459 static 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
ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1483 static 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
ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1507 static 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
ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1532 static 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) {
1607 fcall_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
ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1634 static 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) {
1709 fcall_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
ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1736 static 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) {
1813 fcall_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
ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1840 static 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) {
1933 fcall_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
ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1958 static 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) {
2051 fcall_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
ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2076 static 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) {
2170 fcall_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
ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2195 static 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
zend_cannot_pass_by_ref_helper_SPEC(uint32_t _arg_num,zval * _arg ZEND_OPCODE_HANDLER_ARGS_DC)2273 static 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
ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2285 static 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
2295 send_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
ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2498 static 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
2522 send_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
zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)2649 static 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
zend_verify_recv_arg_type_helper_SPEC(zval * op_1 ZEND_OPCODE_HANDLER_ARGS_DC)2660 static 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
ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2672 static 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
zend_case_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)2684 static 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
ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2703 static 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
2713 add_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
ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2837 static 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
zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)2889 static 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 }
2964 fe_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
ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3007 static 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
ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3028 static 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
ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3062 static 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
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3074 static 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
ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3086 static 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
ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3098 static 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
ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3123 static 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
ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3134 static 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
ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3151 static 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
ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3158 static 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
zend_dispatch_try_catch_finally_helper_SPEC(uint32_t try_catch_offset,uint32_t op_num ZEND_OPCODE_HANDLER_ARGS_DC)3165 static 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
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3242 static 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
ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3315 static 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
zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)3347 static 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
ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3359 static 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
ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3383 static 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
ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3394 static 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
ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3414 static 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
ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3429 static 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
ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3572 static 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
ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3716 static 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
ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3750 static 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
ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3784 static 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
ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3824 static 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
ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3864 static 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
zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)3872 static 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 }
ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3898 static 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
ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3926 static 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
3935 try_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
ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3979 static 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
ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4012 static 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
ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4041 static 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
ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4059 static 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 {
4096 recv_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
ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4109 static 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
4118 try_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
ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4162 static 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
ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4181 static 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
ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4253 static 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
ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4279 static 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
ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4305 static 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
4314 try_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
ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4358 static 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
ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4372 static 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
ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4398 static 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
ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4426 static 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
ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4460 static 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
ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4494 static 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
ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4530 static 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
ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4565 static 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
ZEND_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4642 static 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
ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4720 static 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
ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4783 static 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
ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4849 static 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
ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4894 static 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
ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4941 static 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
ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4977 static 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
ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5028 static 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
ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5048 static 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
ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5074 static 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
ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5137 static 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
ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5228 static 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
ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5311 static 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
ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5394 static 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
ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5469 static 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
ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5567 static 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
ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5613 static 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
ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5654 static 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
ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5698 static 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
ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5736 static 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
ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5745 static 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
ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5772 static 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
5788 yield_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
ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5872 static 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
ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5934 static 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) {
5942 type_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
ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5970 static 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)) {
5978 defined_true:
5979 ZEND_VM_SMART_BRANCH_TRUE();
5980 } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
5981 defined_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
ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5993 static 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);
5997 try_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
ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6016 static 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
ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6026 static 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
ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6036 static 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
ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6046 static 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
ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6057 static 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
ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6072 static 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);
6096 add_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
ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6110 static 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);
6134 sub_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
ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6148 static 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);
6175 mul_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
ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6189 static 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
ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6203 static 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
ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6230 static 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
ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6251 static 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
ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6270 static 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
ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6284 static 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
ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6299 static 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
ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6314 static 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))) {
6327 is_equal_true:
6328 ZEND_VM_SMART_BRANCH_TRUE();
6329 } else {
6330 is_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);
6342 is_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
ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6372 static 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))) {
6385 is_not_equal_true:
6386 ZEND_VM_SMART_BRANCH_TRUE();
6387 } else {
6388 is_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);
6400 is_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
ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6430 static 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))) {
6443 is_smaller_true:
6444 ZEND_VM_SMART_BRANCH_TRUE();
6445 } else {
6446 is_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);
6458 is_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
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6473 static 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))) {
6486 is_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 {
6491 is_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);
6505 is_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
ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6520 static 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
ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6534 static 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
ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6552 static 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
ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6570 static 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
ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6588 static 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
ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6602 static 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)) {
6612 fetch_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 {
6623 fetch_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
ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6637 static 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
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6650 static 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
ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6669 static 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))) {
6709 fetch_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 {
6715 fetch_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)) {
6824 fetch_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
6831 fetch_obj_r_finish:
6832
6833
6834 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6835 }
6836
ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6837 static 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))) {
6876 fetch_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 {
6882 fetch_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)) {
6945 fetch_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
6952 fetch_obj_is_finish:
6953
6954
6955 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6956 }
6957
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6958 static 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
ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6975 static 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
ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6987 static 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
ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7112 static 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(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
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7267 static 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
ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7400 static 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 func = fcc.function_handler;
7416 object_or_called_scope = fcc.called_scope;
7417 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
7418 /* Delay closure destruction until its invocation */
7419 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
7420 call_info |= ZEND_CALL_CLOSURE;
7421 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
7422 call_info |= ZEND_CALL_FAKE_CLOSURE;
7423 }
7424 if (fcc.object) {
7425 object_or_called_scope = fcc.object;
7426 call_info |= ZEND_CALL_HAS_THIS;
7427 }
7428 } else if (fcc.object) {
7429 GC_ADDREF(fcc.object); /* For $this pointer */
7430 object_or_called_scope = fcc.object;
7431 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
7432 }
7433
7434 if ((IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
7435 if (call_info & ZEND_CALL_CLOSURE) {
7436 zend_object_release(ZEND_CLOSURE_OBJECT(func));
7437 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
7438 zend_object_release(fcc.object);
7439 }
7440 HANDLE_EXCEPTION();
7441 }
7442
7443 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
7444 init_func_run_time_cache(&func->op_array);
7445 }
7446 } else {
7447 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
7448 efree(error);
7449
7450 HANDLE_EXCEPTION();
7451 }
7452
7453 call = zend_vm_stack_push_call_frame(call_info,
7454 func, opline->extended_value, object_or_called_scope);
7455 call->prev_execute_data = EX(call);
7456 EX(call) = call;
7457
7458 ZEND_VM_NEXT_OPCODE();
7459 }
7460
ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7461 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7462 {
7463 USE_OPLINE
7464 zval *value, *arg;
7465
7466 if (IS_CONST == IS_CONST) {
7467 SAVE_OPLINE();
7468 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7469 uint32_t arg_num;
7470 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7471 if (UNEXPECTED(!arg)) {
7472
7473 HANDLE_EXCEPTION();
7474 }
7475 } else {
7476 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7477 }
7478
7479 value = RT_CONSTANT(opline, opline->op1);
7480 ZVAL_COPY_VALUE(arg, value);
7481 if (IS_CONST == IS_CONST) {
7482 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7483 Z_ADDREF_P(arg);
7484 }
7485 }
7486 ZEND_VM_NEXT_OPCODE();
7487 }
7488
ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7489 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7490 {
7491 USE_OPLINE
7492 zval *value, *arg;
7493 uint32_t arg_num;
7494
7495 if (IS_CONST == IS_CONST) {
7496 SAVE_OPLINE();
7497 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7498 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7499 if (UNEXPECTED(!arg)) {
7500
7501 HANDLE_EXCEPTION();
7502 }
7503 } else {
7504 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7505 arg_num = opline->op2.num;
7506 }
7507
7508 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
7509 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7510 goto send_val_by_ref;
7511 }
7512 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7513 send_val_by_ref:
7514 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
7515 }
7516 value = RT_CONSTANT(opline, opline->op1);
7517 ZVAL_COPY_VALUE(arg, value);
7518 if (IS_CONST == IS_CONST) {
7519 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7520 Z_ADDREF_P(arg);
7521 }
7522 }
7523 ZEND_VM_NEXT_OPCODE();
7524 }
7525
ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7526 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7527 {
7528 zend_class_entry *ce, *scope;
7529 zend_class_constant *c;
7530 zval *value, *zv, *constant_zv;
7531 zend_string *constant_name;
7532 USE_OPLINE
7533
7534 SAVE_OPLINE();
7535
7536 do {
7537 if (IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
7538 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
7539 value = CACHED_PTR(opline->extended_value + sizeof(void*));
7540 break;
7541 }
7542 }
7543 if (IS_CONST == IS_CONST) {
7544 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
7545 ce = CACHED_PTR(opline->extended_value);
7546 } else {
7547 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);
7548 if (UNEXPECTED(ce == NULL)) {
7549 ZVAL_UNDEF(EX_VAR(opline->result.var));
7550
7551 HANDLE_EXCEPTION();
7552 }
7553 CACHE_PTR(opline->extended_value, ce);
7554 }
7555 } else if (IS_CONST == IS_UNUSED) {
7556 ce = zend_fetch_class(NULL, opline->op1.num);
7557 if (UNEXPECTED(ce == NULL)) {
7558 ZVAL_UNDEF(EX_VAR(opline->result.var));
7559
7560 HANDLE_EXCEPTION();
7561 }
7562 } else {
7563 ce = Z_CE_P(EX_VAR(opline->op1.var));
7564 }
7565 if (IS_CONST != IS_CONST
7566 && IS_CONST == IS_CONST
7567 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
7568 value = CACHED_PTR(opline->extended_value + sizeof(void*));
7569 break;
7570 }
7571
7572 constant_zv = RT_CONSTANT(opline, opline->op2);
7573 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
7574 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
7575 ZVAL_UNDEF(EX_VAR(opline->result.var));
7576
7577 HANDLE_EXCEPTION();
7578 }
7579 constant_name = Z_STR_P(constant_zv);
7580 /* Magic 'class' for constant OP2 is caught at compile-time */
7581 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
7582 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
7583
7584 ZEND_VM_NEXT_OPCODE();
7585 }
7586 zv = IS_CONST == IS_CONST
7587 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
7588 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
7589
7590 if (EXPECTED(zv != NULL)) {
7591 c = Z_PTR_P(zv);
7592 scope = EX(func)->op_array.scope;
7593 if (!zend_verify_const_access(c, scope)) {
7594 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));
7595 ZVAL_UNDEF(EX_VAR(opline->result.var));
7596
7597 HANDLE_EXCEPTION();
7598 }
7599
7600 if (ce->ce_flags & ZEND_ACC_TRAIT) {
7601 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7602 ZVAL_UNDEF(EX_VAR(opline->result.var));
7603
7604 HANDLE_EXCEPTION();
7605 }
7606
7607 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
7608 if (UNEXPECTED(is_constant_deprecated)) {
7609 zend_deprecated_class_constant(c, constant_name);
7610
7611 if (EG(exception)) {
7612 ZVAL_UNDEF(EX_VAR(opline->result.var));
7613
7614 HANDLE_EXCEPTION();
7615 }
7616 }
7617
7618 value = &c->value;
7619 // Enums require loading of all class constants to build the backed enum table
7620 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)) {
7621 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
7622 ZVAL_UNDEF(EX_VAR(opline->result.var));
7623
7624 HANDLE_EXCEPTION();
7625 }
7626 }
7627 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
7628 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
7629 ZVAL_UNDEF(EX_VAR(opline->result.var));
7630
7631 HANDLE_EXCEPTION();
7632 }
7633 }
7634 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
7635 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
7636 }
7637 } else {
7638 zend_throw_error(NULL, "Undefined constant %s::%s",
7639 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7640 ZVAL_UNDEF(EX_VAR(opline->result.var));
7641
7642 HANDLE_EXCEPTION();
7643 }
7644 } while (0);
7645
7646 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
7647
7648 ZEND_VM_NEXT_OPCODE();
7649 }
7650
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7651 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7652 {
7653 USE_OPLINE
7654 zval *expr_ptr, new_expr;
7655
7656 SAVE_OPLINE();
7657 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
7658 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
7659 expr_ptr = zend_get_bad_ptr();
7660 if (Z_ISREF_P(expr_ptr)) {
7661 Z_ADDREF_P(expr_ptr);
7662 } else {
7663 ZVAL_MAKE_REF_EX(expr_ptr, 2);
7664 }
7665
7666 } else {
7667 expr_ptr = RT_CONSTANT(opline, opline->op1);
7668 if (IS_CONST == IS_TMP_VAR) {
7669 /* pass */
7670 } else if (IS_CONST == IS_CONST) {
7671 Z_TRY_ADDREF_P(expr_ptr);
7672 } else if (IS_CONST == IS_CV) {
7673 ZVAL_DEREF(expr_ptr);
7674 Z_TRY_ADDREF_P(expr_ptr);
7675 } else /* if (IS_CONST == IS_VAR) */ {
7676 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
7677 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
7678
7679 expr_ptr = Z_REFVAL_P(expr_ptr);
7680 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
7681 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
7682 expr_ptr = &new_expr;
7683 efree_size(ref, sizeof(zend_reference));
7684 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
7685 Z_ADDREF_P(expr_ptr);
7686 }
7687 }
7688 }
7689 }
7690
7691 if (IS_CONST != IS_UNUSED) {
7692 zval *offset = RT_CONSTANT(opline, opline->op2);
7693 zend_string *str;
7694 zend_ulong hval;
7695
7696 add_again:
7697 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7698 str = Z_STR_P(offset);
7699 if (IS_CONST != IS_CONST) {
7700 if (ZEND_HANDLE_NUMERIC(str, hval)) {
7701 goto num_index;
7702 }
7703 }
7704 str_index:
7705 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
7706 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7707 hval = Z_LVAL_P(offset);
7708 num_index:
7709 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
7710 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
7711 offset = Z_REFVAL_P(offset);
7712 goto add_again;
7713 } else if (Z_TYPE_P(offset) == IS_NULL) {
7714 str = ZSTR_EMPTY_ALLOC();
7715 goto str_index;
7716 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
7717 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
7718 goto num_index;
7719 } else if (Z_TYPE_P(offset) == IS_FALSE) {
7720 hval = 0;
7721 goto num_index;
7722 } else if (Z_TYPE_P(offset) == IS_TRUE) {
7723 hval = 1;
7724 goto num_index;
7725 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
7726 zend_use_resource_as_offset(offset);
7727 hval = Z_RES_HANDLE_P(offset);
7728 goto num_index;
7729 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
7730 ZVAL_UNDEFINED_OP2();
7731 str = ZSTR_EMPTY_ALLOC();
7732 goto str_index;
7733 } else {
7734 zend_illegal_array_offset_access(offset);
7735 zval_ptr_dtor_nogc(expr_ptr);
7736 }
7737
7738 } else {
7739 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
7740 zend_cannot_add_element();
7741 zval_ptr_dtor_nogc(expr_ptr);
7742 }
7743 }
7744 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7745 }
7746
ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7747 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7748 {
7749 zval *array;
7750 uint32_t size;
7751 USE_OPLINE
7752
7753 array = EX_VAR(opline->result.var);
7754 if (IS_CONST != IS_UNUSED) {
7755 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
7756 ZVAL_ARR(array, zend_new_array(size));
7757 /* Explicitly initialize array as not-packed if flag is set */
7758 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
7759 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
7760 }
7761 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7762 } else {
7763 ZVAL_ARR(array, zend_new_array(0));
7764 ZEND_VM_NEXT_OPCODE();
7765 }
7766 }
7767
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7768 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7769 {
7770 USE_OPLINE
7771 zval *container;
7772 bool result;
7773 zend_ulong hval;
7774 zval *offset;
7775
7776 SAVE_OPLINE();
7777 container = RT_CONSTANT(opline, opline->op1);
7778 offset = RT_CONSTANT(opline, opline->op2);
7779
7780 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7781 HashTable *ht;
7782 zval *value;
7783 zend_string *str;
7784
7785 isset_dim_obj_array:
7786 ht = Z_ARRVAL_P(container);
7787 isset_again:
7788 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7789 str = Z_STR_P(offset);
7790 if (IS_CONST != IS_CONST) {
7791 if (ZEND_HANDLE_NUMERIC(str, hval)) {
7792 goto num_index_prop;
7793 }
7794 }
7795 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
7796 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7797 hval = Z_LVAL_P(offset);
7798 num_index_prop:
7799 value = zend_hash_index_find(ht, hval);
7800 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
7801 offset = Z_REFVAL_P(offset);
7802 goto isset_again;
7803 } else {
7804 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
7805 if (UNEXPECTED(EG(exception))) {
7806 result = 0;
7807 goto isset_dim_obj_exit;
7808 }
7809 }
7810
7811 if (!(opline->extended_value & ZEND_ISEMPTY)) {
7812 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
7813 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
7814 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
7815
7816 if (IS_CONST & (IS_CONST|IS_CV)) {
7817 /* avoid exception check */
7818
7819 ZEND_VM_SMART_BRANCH(result, 0);
7820 }
7821 } else {
7822 result = (value == NULL || !i_zend_is_true(value));
7823 }
7824 goto isset_dim_obj_exit;
7825 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
7826 container = Z_REFVAL_P(container);
7827 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7828 goto isset_dim_obj_array;
7829 }
7830 }
7831
7832 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
7833 offset++;
7834 }
7835 if (!(opline->extended_value & ZEND_ISEMPTY)) {
7836 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
7837 } else {
7838 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
7839 }
7840
7841 isset_dim_obj_exit:
7842
7843
7844 ZEND_VM_SMART_BRANCH(result, 1);
7845 }
7846
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7847 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7848 {
7849 USE_OPLINE
7850 zval *container;
7851 int result;
7852 zval *offset;
7853 zend_string *name, *tmp_name;
7854
7855 SAVE_OPLINE();
7856 container = RT_CONSTANT(opline, opline->op1);
7857 offset = RT_CONSTANT(opline, opline->op2);
7858
7859 if (IS_CONST == IS_CONST ||
7860 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
7861 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
7862 container = Z_REFVAL_P(container);
7863 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
7864 result = (opline->extended_value & ZEND_ISEMPTY);
7865 goto isset_object_finish;
7866 }
7867 } else {
7868 result = (opline->extended_value & ZEND_ISEMPTY);
7869 goto isset_object_finish;
7870 }
7871 }
7872
7873 if (IS_CONST == IS_CONST) {
7874 name = Z_STR_P(offset);
7875 } else {
7876 name = zval_try_get_tmp_string(offset, &tmp_name);
7877 if (UNEXPECTED(!name)) {
7878 result = 0;
7879 goto isset_object_finish;
7880 }
7881 }
7882
7883 result =
7884 (opline->extended_value & ZEND_ISEMPTY) ^
7885 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));
7886
7887 if (IS_CONST != IS_CONST) {
7888 zend_tmp_string_release(tmp_name);
7889 }
7890
7891 isset_object_finish:
7892
7893
7894 ZEND_VM_SMART_BRANCH(result, 1);
7895 }
7896
ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7897 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7898 {
7899 USE_OPLINE
7900
7901 zval *key, *subject;
7902 HashTable *ht;
7903 bool result;
7904
7905 SAVE_OPLINE();
7906
7907 key = RT_CONSTANT(opline, opline->op1);
7908 subject = RT_CONSTANT(opline, opline->op2);
7909
7910 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7911 array_key_exists_array:
7912 ht = Z_ARRVAL_P(subject);
7913 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
7914 } else {
7915 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
7916 subject = Z_REFVAL_P(subject);
7917 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7918 goto array_key_exists_array;
7919 }
7920 }
7921 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
7922 result = 0;
7923 }
7924
7925
7926 ZEND_VM_SMART_BRANCH(result, 1);
7927 }
7928
ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7929 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7930 {
7931 USE_OPLINE
7932
7933 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
7934 if (ce == NULL) {
7935 zval *lcname = RT_CONSTANT(opline, opline->op1);
7936 zval *zv = zend_hash_find_known_hash(EG(class_table), Z_STR_P(lcname + 1));
7937 if (zv) {
7938 SAVE_OPLINE();
7939 ce = zend_bind_class_in_slot(zv, lcname, Z_STR_P(RT_CONSTANT(opline, opline->op2)));
7940 if (!ce) {
7941 HANDLE_EXCEPTION();
7942 }
7943 }
7944 CACHE_PTR(opline->extended_value, ce);
7945 }
7946 ZEND_VM_NEXT_OPCODE();
7947 }
7948
ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7949 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7950 {
7951 USE_OPLINE
7952 zval *name;
7953 zval *val;
7954 zend_constant c;
7955
7956 SAVE_OPLINE();
7957 name = RT_CONSTANT(opline, opline->op1);
7958 val = RT_CONSTANT(opline, opline->op2);
7959
7960 ZVAL_COPY(&c.value, val);
7961 if (Z_OPT_CONSTANT(c.value)) {
7962 if (UNEXPECTED(zval_update_constant_ex(&c.value, EX(func)->op_array.scope) != SUCCESS)) {
7963 zval_ptr_dtor_nogc(&c.value);
7964
7965
7966 HANDLE_EXCEPTION();
7967 }
7968 }
7969 /* non persistent, case sensitive */
7970 ZEND_CONSTANT_SET_FLAGS(&c, 0, PHP_USER_CONSTANT);
7971 c.name = zend_string_copy(Z_STR_P(name));
7972
7973 if (zend_register_constant(&c) == FAILURE) {
7974 }
7975
7976
7977 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7978 }
7979
ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7980 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7981 {
7982 USE_OPLINE
7983
7984 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
7985
7986 SAVE_OPLINE();
7987 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
7988 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7989 }
7990
7991 /* Destroy the previously yielded value */
7992 zval_ptr_dtor(&generator->value);
7993
7994 /* Destroy the previously yielded key */
7995 zval_ptr_dtor(&generator->key);
7996
7997 /* Set the new yielded value */
7998 if (IS_CONST != IS_UNUSED) {
7999 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
8000 /* Constants and temporary variables aren't yieldable by reference,
8001 * but we still allow them with a notice. */
8002 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
8003 zval *value;
8004
8005 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
8006
8007 value = RT_CONSTANT(opline, opline->op1);
8008 ZVAL_COPY_VALUE(&generator->value, value);
8009 if (IS_CONST == IS_CONST) {
8010 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
8011 Z_ADDREF(generator->value);
8012 }
8013 }
8014 } else {
8015 zval *value_ptr = zend_get_bad_ptr();
8016
8017 /* If a function call result is yielded and the function did
8018 * not return by reference we throw a notice. */
8019 do {
8020 if (IS_CONST == IS_VAR) {
8021 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
8022 if (opline->extended_value == ZEND_RETURNS_FUNCTION
8023 && !Z_ISREF_P(value_ptr)) {
8024 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
8025 ZVAL_COPY(&generator->value, value_ptr);
8026 break;
8027 }
8028 }
8029 if (Z_ISREF_P(value_ptr)) {
8030 Z_ADDREF_P(value_ptr);
8031 } else {
8032 ZVAL_MAKE_REF_EX(value_ptr, 2);
8033 }
8034 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
8035 } while (0);
8036
8037 }
8038 } else {
8039 zval *value = RT_CONSTANT(opline, opline->op1);
8040
8041 /* Consts, temporary variables and references need copying */
8042 if (IS_CONST == IS_CONST) {
8043 ZVAL_COPY_VALUE(&generator->value, value);
8044 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
8045 Z_ADDREF(generator->value);
8046 }
8047 } else if (IS_CONST == IS_TMP_VAR) {
8048 ZVAL_COPY_VALUE(&generator->value, value);
8049 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
8050 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
8051
8052 } else {
8053 ZVAL_COPY_VALUE(&generator->value, value);
8054 if (IS_CONST == IS_CV) {
8055 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
8056 }
8057 }
8058 }
8059 } else {
8060 /* If no value was specified yield null */
8061 ZVAL_NULL(&generator->value);
8062 }
8063
8064 /* Set the new yielded key */
8065 if (IS_CONST != IS_UNUSED) {
8066 zval *key = RT_CONSTANT(opline, opline->op2);
8067 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
8068 key = Z_REFVAL_P(key);
8069 }
8070 ZVAL_COPY(&generator->key, key);
8071
8072 if (Z_TYPE(generator->key) == IS_LONG
8073 && Z_LVAL(generator->key) > generator->largest_used_integer_key
8074 ) {
8075 generator->largest_used_integer_key = Z_LVAL(generator->key);
8076 }
8077 } else {
8078 /* If no key was specified we use auto-increment keys */
8079 generator->largest_used_integer_key++;
8080 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
8081 }
8082
8083 if (RETURN_VALUE_USED(opline)) {
8084 /* If the return value of yield is used set the send
8085 * target and initialize it to NULL */
8086 generator->send_target = EX_VAR(opline->result.var);
8087 ZVAL_NULL(generator->send_target);
8088 } else {
8089 generator->send_target = NULL;
8090 }
8091
8092 /* The GOTO VM uses a local opline variable. We need to set the opline
8093 * variable in execute_data so we don't resume at an old position. */
8094 SAVE_OPLINE();
8095
8096 ZEND_VM_RETURN();
8097 }
8098
ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8099 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8100 {
8101 USE_OPLINE
8102 zval *op, *jump_zv;
8103 HashTable *jumptable;
8104
8105 op = RT_CONSTANT(opline, opline->op1);
8106
8107 if (Z_TYPE_P(op) != IS_LONG) {
8108 ZVAL_DEREF(op);
8109 if (Z_TYPE_P(op) != IS_LONG) {
8110 /* Wrong type, fall back to ZEND_CASE chain */
8111 ZEND_VM_NEXT_OPCODE();
8112 }
8113 }
8114
8115 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8116 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
8117 if (jump_zv != NULL) {
8118 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8119 ZEND_VM_CONTINUE();
8120 } else {
8121 /* default */
8122 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8123 ZEND_VM_CONTINUE();
8124 }
8125 }
8126
ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8127 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8128 {
8129 USE_OPLINE
8130 zval *op, *jump_zv;
8131 HashTable *jumptable;
8132
8133 op = RT_CONSTANT(opline, opline->op1);
8134
8135 if (Z_TYPE_P(op) != IS_STRING) {
8136 if (IS_CONST == IS_CONST) {
8137 /* Wrong type, fall back to ZEND_CASE chain */
8138 ZEND_VM_NEXT_OPCODE();
8139 } else {
8140 ZVAL_DEREF(op);
8141 if (Z_TYPE_P(op) != IS_STRING) {
8142 /* Wrong type, fall back to ZEND_CASE chain */
8143 ZEND_VM_NEXT_OPCODE();
8144 }
8145 }
8146 }
8147
8148 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8149 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
8150 if (jump_zv != NULL) {
8151 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8152 ZEND_VM_CONTINUE();
8153 } else {
8154 /* default */
8155 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8156 ZEND_VM_CONTINUE();
8157 }
8158 }
8159
ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8160 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8161 {
8162 USE_OPLINE
8163 zval *op, *jump_zv;
8164 HashTable *jumptable;
8165
8166 op = RT_CONSTANT(opline, opline->op1);
8167 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8168
8169 match_try_again:
8170 if (Z_TYPE_P(op) == IS_LONG) {
8171 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
8172 } else if (Z_TYPE_P(op) == IS_STRING) {
8173 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
8174 } else if (Z_TYPE_P(op) == IS_REFERENCE) {
8175 op = Z_REFVAL_P(op);
8176 goto match_try_again;
8177 } else {
8178 if (UNEXPECTED((IS_CONST & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
8179 SAVE_OPLINE();
8180 op = ZVAL_UNDEFINED_OP1();
8181 if (UNEXPECTED(EG(exception))) {
8182 HANDLE_EXCEPTION();
8183 }
8184 goto match_try_again;
8185 }
8186
8187 goto default_branch;
8188 }
8189
8190 if (jump_zv != NULL) {
8191 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
8192 ZEND_VM_CONTINUE();
8193 } else {
8194 default_branch:
8195 /* default */
8196 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
8197 ZEND_VM_CONTINUE();
8198 }
8199 }
8200
ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8201 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8202 {
8203 USE_OPLINE
8204 zval *op1;
8205 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
8206 zval *result;
8207
8208 op1 = RT_CONSTANT(opline, opline->op1);
8209 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8210 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CONST == IS_CONST);
8211 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
8212 zval_ptr_dtor_str(op1);
8213 }
8214 ZEND_VM_SMART_BRANCH(result, 0);
8215 }
8216
8217 if (opline->extended_value) {
8218 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
8219 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
8220 ZEND_VM_SMART_BRANCH(result, 0);
8221 }
8222 SAVE_OPLINE();
8223 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
8224 op1 = Z_REFVAL_P(op1);
8225 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8226 result = zend_hash_find(ht, Z_STR_P(op1));
8227
8228 ZEND_VM_SMART_BRANCH(result, 0);
8229 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
8230 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
8231
8232 ZEND_VM_SMART_BRANCH(result, 0);
8233 }
8234 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8235 ZVAL_UNDEFINED_OP1();
8236 }
8237 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
8238 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8239 SAVE_OPLINE();
8240 ZVAL_UNDEFINED_OP1();
8241 if (UNEXPECTED(EG(exception) != NULL)) {
8242 HANDLE_EXCEPTION();
8243 }
8244 }
8245 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
8246 ZEND_VM_SMART_BRANCH(result, 0);
8247 } else {
8248 zend_string *key;
8249 zval key_tmp;
8250
8251 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
8252 op1 = Z_REFVAL_P(op1);
8253 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8254 result = zend_hash_find(ht, Z_STR_P(op1));
8255
8256 ZEND_VM_SMART_BRANCH(result, 0);
8257 }
8258 }
8259
8260 SAVE_OPLINE();
8261 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
8262 ZVAL_STR(&key_tmp, key);
8263 if (zend_compare(op1, &key_tmp) == 0) {
8264
8265 ZEND_VM_SMART_BRANCH(1, 1);
8266 }
8267 } ZEND_HASH_FOREACH_END();
8268 }
8269
8270 ZEND_VM_SMART_BRANCH(0, 1);
8271 }
8272
ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8273 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8274 {
8275 USE_OPLINE
8276 zval *op1, *op2, *result;
8277 double d1, d2;
8278
8279 op1 = RT_CONSTANT(opline, opline->op1);
8280 op2 = EX_VAR(opline->op2.var);
8281 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8282 /* pass */
8283 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8284 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8285 result = EX_VAR(opline->result.var);
8286 fast_long_add_function(result, op1, op2);
8287 ZEND_VM_NEXT_OPCODE();
8288 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8289 d1 = (double)Z_LVAL_P(op1);
8290 d2 = Z_DVAL_P(op2);
8291 goto add_double;
8292 }
8293 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8294 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8295 d1 = Z_DVAL_P(op1);
8296 d2 = Z_DVAL_P(op2);
8297 add_double:
8298 result = EX_VAR(opline->result.var);
8299 ZVAL_DOUBLE(result, d1 + d2);
8300 ZEND_VM_NEXT_OPCODE();
8301 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8302 d1 = Z_DVAL_P(op1);
8303 d2 = (double)Z_LVAL_P(op2);
8304 goto add_double;
8305 }
8306 }
8307
8308 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8309 }
8310
ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8311 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8312 {
8313 USE_OPLINE
8314 zval *op1, *op2, *result;
8315 double d1, d2;
8316
8317 op1 = RT_CONSTANT(opline, opline->op1);
8318 op2 = EX_VAR(opline->op2.var);
8319 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8320 /* pass */
8321 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8322 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8323 result = EX_VAR(opline->result.var);
8324 fast_long_sub_function(result, op1, op2);
8325 ZEND_VM_NEXT_OPCODE();
8326 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8327 d1 = (double)Z_LVAL_P(op1);
8328 d2 = Z_DVAL_P(op2);
8329 goto sub_double;
8330 }
8331 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8332 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8333 d1 = Z_DVAL_P(op1);
8334 d2 = Z_DVAL_P(op2);
8335 sub_double:
8336 result = EX_VAR(opline->result.var);
8337 ZVAL_DOUBLE(result, d1 - d2);
8338 ZEND_VM_NEXT_OPCODE();
8339 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8340 d1 = Z_DVAL_P(op1);
8341 d2 = (double)Z_LVAL_P(op2);
8342 goto sub_double;
8343 }
8344 }
8345
8346 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8347 }
8348
ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8349 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8350 {
8351 USE_OPLINE
8352 zval *op1, *op2, *result;
8353
8354 op1 = RT_CONSTANT(opline, opline->op1);
8355 op2 = EX_VAR(opline->op2.var);
8356 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8357 /* pass */
8358 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8359 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8360 result = EX_VAR(opline->result.var);
8361 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
8362 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
8363 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
8364 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
8365 ZVAL_LONG(result, 0);
8366 } else {
8367 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
8368 }
8369 ZEND_VM_NEXT_OPCODE();
8370 }
8371 }
8372
8373 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8374 }
8375
ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8376 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8377 {
8378 USE_OPLINE
8379 zval *op1, *op2;
8380
8381 op1 = RT_CONSTANT(opline, opline->op1);
8382 op2 = EX_VAR(opline->op2.var);
8383 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8384 /* pass */
8385 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8386 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8387 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8388 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
8389 ZVAL_LONG(EX_VAR(opline->result.var),
8390 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
8391 ZEND_VM_NEXT_OPCODE();
8392 }
8393
8394 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8395 }
8396
ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8397 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8398 {
8399 USE_OPLINE
8400 zval *op1, *op2;
8401
8402 op1 = RT_CONSTANT(opline, opline->op1);
8403 op2 = EX_VAR(opline->op2.var);
8404 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8405 /* pass */
8406 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8407 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8408 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8409 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
8410 ZEND_VM_NEXT_OPCODE();
8411 }
8412
8413 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8414 }
8415
ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8416 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8417 {
8418 USE_OPLINE
8419 zval *op1, *op2;
8420 double d1, d2;
8421
8422 op1 = RT_CONSTANT(opline, opline->op1);
8423 op2 = EX_VAR(opline->op2.var);
8424 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8425 /* pass */
8426 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8427 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8428 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8429 is_smaller_true:
8430 ZEND_VM_SMART_BRANCH_TRUE_NONE();
8431 } else {
8432 is_smaller_false:
8433 ZEND_VM_SMART_BRANCH_FALSE_NONE();
8434 }
8435 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8436 d1 = (double)Z_LVAL_P(op1);
8437 d2 = Z_DVAL_P(op2);
8438 goto is_smaller_double;
8439 }
8440 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8441 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8442 d1 = Z_DVAL_P(op1);
8443 d2 = Z_DVAL_P(op2);
8444 is_smaller_double:
8445 if (d1 < d2) {
8446 goto is_smaller_true;
8447 } else {
8448 goto is_smaller_false;
8449 }
8450 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8451 d1 = Z_DVAL_P(op1);
8452 d2 = (double)Z_LVAL_P(op2);
8453 goto is_smaller_double;
8454 }
8455 }
8456 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8457 }
8458
ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8459 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8460 {
8461 USE_OPLINE
8462 zval *op1, *op2;
8463 double d1, d2;
8464
8465 op1 = RT_CONSTANT(opline, opline->op1);
8466 op2 = EX_VAR(opline->op2.var);
8467 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8468 /* pass */
8469 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8470 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8471 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8472 is_smaller_true:
8473 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8474 } else {
8475 is_smaller_false:
8476 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8477 }
8478 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8479 d1 = (double)Z_LVAL_P(op1);
8480 d2 = Z_DVAL_P(op2);
8481 goto is_smaller_double;
8482 }
8483 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8484 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8485 d1 = Z_DVAL_P(op1);
8486 d2 = Z_DVAL_P(op2);
8487 is_smaller_double:
8488 if (d1 < d2) {
8489 goto is_smaller_true;
8490 } else {
8491 goto is_smaller_false;
8492 }
8493 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8494 d1 = Z_DVAL_P(op1);
8495 d2 = (double)Z_LVAL_P(op2);
8496 goto is_smaller_double;
8497 }
8498 }
8499 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8500 }
8501
ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8502 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8503 {
8504 USE_OPLINE
8505 zval *op1, *op2;
8506 double d1, d2;
8507
8508 op1 = RT_CONSTANT(opline, opline->op1);
8509 op2 = EX_VAR(opline->op2.var);
8510 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8511 /* pass */
8512 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8513 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8514 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8515 is_smaller_true:
8516 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8517 } else {
8518 is_smaller_false:
8519 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8520 }
8521 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8522 d1 = (double)Z_LVAL_P(op1);
8523 d2 = Z_DVAL_P(op2);
8524 goto is_smaller_double;
8525 }
8526 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8527 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8528 d1 = Z_DVAL_P(op1);
8529 d2 = Z_DVAL_P(op2);
8530 is_smaller_double:
8531 if (d1 < d2) {
8532 goto is_smaller_true;
8533 } else {
8534 goto is_smaller_false;
8535 }
8536 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8537 d1 = Z_DVAL_P(op1);
8538 d2 = (double)Z_LVAL_P(op2);
8539 goto is_smaller_double;
8540 }
8541 }
8542 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8543 }
8544
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8545 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8546 {
8547 USE_OPLINE
8548 zval *op1, *op2;
8549 double d1, d2;
8550
8551 op1 = RT_CONSTANT(opline, opline->op1);
8552 op2 = EX_VAR(opline->op2.var);
8553 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8554 /* pass */
8555 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8556 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8557 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8558 is_smaller_or_equal_true:
8559 ZEND_VM_SMART_BRANCH_TRUE_NONE();
8560 ZVAL_TRUE(EX_VAR(opline->result.var));
8561 ZEND_VM_NEXT_OPCODE();
8562 } else {
8563 is_smaller_or_equal_false:
8564 ZEND_VM_SMART_BRANCH_FALSE_NONE();
8565 ZVAL_FALSE(EX_VAR(opline->result.var));
8566 ZEND_VM_NEXT_OPCODE();
8567 }
8568 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8569 d1 = (double)Z_LVAL_P(op1);
8570 d2 = Z_DVAL_P(op2);
8571 goto is_smaller_or_equal_double;
8572 }
8573 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8574 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8575 d1 = Z_DVAL_P(op1);
8576 d2 = Z_DVAL_P(op2);
8577 is_smaller_or_equal_double:
8578 if (d1 <= d2) {
8579 goto is_smaller_or_equal_true;
8580 } else {
8581 goto is_smaller_or_equal_false;
8582 }
8583 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8584 d1 = Z_DVAL_P(op1);
8585 d2 = (double)Z_LVAL_P(op2);
8586 goto is_smaller_or_equal_double;
8587 }
8588 }
8589 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8590 }
8591
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8592 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8593 {
8594 USE_OPLINE
8595 zval *op1, *op2;
8596 double d1, d2;
8597
8598 op1 = RT_CONSTANT(opline, opline->op1);
8599 op2 = EX_VAR(opline->op2.var);
8600 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8601 /* pass */
8602 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8603 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8604 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8605 is_smaller_or_equal_true:
8606 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8607 ZVAL_TRUE(EX_VAR(opline->result.var));
8608 ZEND_VM_NEXT_OPCODE();
8609 } else {
8610 is_smaller_or_equal_false:
8611 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8612 ZVAL_FALSE(EX_VAR(opline->result.var));
8613 ZEND_VM_NEXT_OPCODE();
8614 }
8615 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8616 d1 = (double)Z_LVAL_P(op1);
8617 d2 = Z_DVAL_P(op2);
8618 goto is_smaller_or_equal_double;
8619 }
8620 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8621 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8622 d1 = Z_DVAL_P(op1);
8623 d2 = Z_DVAL_P(op2);
8624 is_smaller_or_equal_double:
8625 if (d1 <= d2) {
8626 goto is_smaller_or_equal_true;
8627 } else {
8628 goto is_smaller_or_equal_false;
8629 }
8630 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8631 d1 = Z_DVAL_P(op1);
8632 d2 = (double)Z_LVAL_P(op2);
8633 goto is_smaller_or_equal_double;
8634 }
8635 }
8636 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8637 }
8638
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8639 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8640 {
8641 USE_OPLINE
8642 zval *op1, *op2;
8643 double d1, d2;
8644
8645 op1 = RT_CONSTANT(opline, opline->op1);
8646 op2 = EX_VAR(opline->op2.var);
8647 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8648 /* pass */
8649 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8650 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8651 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8652 is_smaller_or_equal_true:
8653 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8654 ZVAL_TRUE(EX_VAR(opline->result.var));
8655 ZEND_VM_NEXT_OPCODE();
8656 } else {
8657 is_smaller_or_equal_false:
8658 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8659 ZVAL_FALSE(EX_VAR(opline->result.var));
8660 ZEND_VM_NEXT_OPCODE();
8661 }
8662 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8663 d1 = (double)Z_LVAL_P(op1);
8664 d2 = Z_DVAL_P(op2);
8665 goto is_smaller_or_equal_double;
8666 }
8667 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8668 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8669 d1 = Z_DVAL_P(op1);
8670 d2 = Z_DVAL_P(op2);
8671 is_smaller_or_equal_double:
8672 if (d1 <= d2) {
8673 goto is_smaller_or_equal_true;
8674 } else {
8675 goto is_smaller_or_equal_false;
8676 }
8677 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8678 d1 = Z_DVAL_P(op1);
8679 d2 = (double)Z_LVAL_P(op2);
8680 goto is_smaller_or_equal_double;
8681 }
8682 }
8683 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8684 }
8685
ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8686 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8687 {
8688 zend_class_entry *ce, *scope;
8689 zend_class_constant *c;
8690 zval *value, *zv, *constant_zv;
8691 zend_string *constant_name;
8692 USE_OPLINE
8693
8694 SAVE_OPLINE();
8695
8696 do {
8697 if (IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8698 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
8699 value = CACHED_PTR(opline->extended_value + sizeof(void*));
8700 break;
8701 }
8702 }
8703 if (IS_CONST == IS_CONST) {
8704 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
8705 ce = CACHED_PTR(opline->extended_value);
8706 } else {
8707 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);
8708 if (UNEXPECTED(ce == NULL)) {
8709 ZVAL_UNDEF(EX_VAR(opline->result.var));
8710 FREE_OP(opline->op2_type, opline->op2.var);
8711 HANDLE_EXCEPTION();
8712 }
8713 CACHE_PTR(opline->extended_value, ce);
8714 }
8715 } else if (IS_CONST == IS_UNUSED) {
8716 ce = zend_fetch_class(NULL, opline->op1.num);
8717 if (UNEXPECTED(ce == NULL)) {
8718 ZVAL_UNDEF(EX_VAR(opline->result.var));
8719 FREE_OP(opline->op2_type, opline->op2.var);
8720 HANDLE_EXCEPTION();
8721 }
8722 } else {
8723 ce = Z_CE_P(EX_VAR(opline->op1.var));
8724 }
8725 if (IS_CONST != IS_CONST
8726 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8727 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
8728 value = CACHED_PTR(opline->extended_value + sizeof(void*));
8729 break;
8730 }
8731
8732 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
8733 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
8734 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
8735 ZVAL_UNDEF(EX_VAR(opline->result.var));
8736 FREE_OP(opline->op2_type, opline->op2.var);
8737 HANDLE_EXCEPTION();
8738 }
8739 constant_name = Z_STR_P(constant_zv);
8740 /* Magic 'class' for constant OP2 is caught at compile-time */
8741 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
8742 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
8743 FREE_OP(opline->op2_type, opline->op2.var);
8744 ZEND_VM_NEXT_OPCODE();
8745 }
8746 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8747 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
8748 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
8749
8750 if (EXPECTED(zv != NULL)) {
8751 c = Z_PTR_P(zv);
8752 scope = EX(func)->op_array.scope;
8753 if (!zend_verify_const_access(c, scope)) {
8754 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));
8755 ZVAL_UNDEF(EX_VAR(opline->result.var));
8756 FREE_OP(opline->op2_type, opline->op2.var);
8757 HANDLE_EXCEPTION();
8758 }
8759
8760 if (ce->ce_flags & ZEND_ACC_TRAIT) {
8761 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8762 ZVAL_UNDEF(EX_VAR(opline->result.var));
8763 FREE_OP(opline->op2_type, opline->op2.var);
8764 HANDLE_EXCEPTION();
8765 }
8766
8767 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
8768 if (UNEXPECTED(is_constant_deprecated)) {
8769 zend_deprecated_class_constant(c, constant_name);
8770
8771 if (EG(exception)) {
8772 ZVAL_UNDEF(EX_VAR(opline->result.var));
8773 FREE_OP(opline->op2_type, opline->op2.var);
8774 HANDLE_EXCEPTION();
8775 }
8776 }
8777
8778 value = &c->value;
8779 // Enums require loading of all class constants to build the backed enum table
8780 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)) {
8781 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
8782 ZVAL_UNDEF(EX_VAR(opline->result.var));
8783 FREE_OP(opline->op2_type, opline->op2.var);
8784 HANDLE_EXCEPTION();
8785 }
8786 }
8787 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
8788 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
8789 ZVAL_UNDEF(EX_VAR(opline->result.var));
8790 FREE_OP(opline->op2_type, opline->op2.var);
8791 HANDLE_EXCEPTION();
8792 }
8793 }
8794 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
8795 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
8796 }
8797 } else {
8798 zend_throw_error(NULL, "Undefined constant %s::%s",
8799 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8800 ZVAL_UNDEF(EX_VAR(opline->result.var));
8801 FREE_OP(opline->op2_type, opline->op2.var);
8802 HANDLE_EXCEPTION();
8803 }
8804 } while (0);
8805
8806 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
8807
8808 FREE_OP(opline->op2_type, opline->op2.var);
8809 ZEND_VM_NEXT_OPCODE();
8810 }
8811
ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8812 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8813 {
8814 USE_OPLINE
8815 zval *op1, *op2, *result;
8816
8817 op1 = RT_CONSTANT(opline, opline->op1);
8818 op2 = EX_VAR(opline->op2.var);
8819 result = EX_VAR(opline->result.var);
8820 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
8821 ZEND_VM_NEXT_OPCODE();
8822 }
8823
ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8824 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8825 {
8826 USE_OPLINE
8827 zval *op1, *op2, *result;
8828
8829 op1 = RT_CONSTANT(opline, opline->op1);
8830 op2 = EX_VAR(opline->op2.var);
8831 result = EX_VAR(opline->result.var);
8832 fast_long_sub_function(result, op1, op2);
8833 ZEND_VM_NEXT_OPCODE();
8834 }
8835
ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8836 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8837 {
8838 USE_OPLINE
8839 zval *op1, *op2, *result;
8840
8841 op1 = RT_CONSTANT(opline, opline->op1);
8842 op2 = EX_VAR(opline->op2.var);
8843 result = EX_VAR(opline->result.var);
8844 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
8845 ZEND_VM_NEXT_OPCODE();
8846 }
8847
ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8848 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8849 {
8850 USE_OPLINE
8851 zval *op1, *op2;
8852 bool result;
8853
8854 op1 = RT_CONSTANT(opline, opline->op1);
8855 op2 = EX_VAR(opline->op2.var);
8856 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8857 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8858 }
8859
ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8860 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8861 {
8862 USE_OPLINE
8863 zval *op1, *op2;
8864 bool result;
8865
8866 op1 = RT_CONSTANT(opline, opline->op1);
8867 op2 = EX_VAR(opline->op2.var);
8868 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8869 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8870 }
8871
ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8872 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8873 {
8874 USE_OPLINE
8875 zval *op1, *op2;
8876 bool result;
8877
8878 op1 = RT_CONSTANT(opline, opline->op1);
8879 op2 = EX_VAR(opline->op2.var);
8880 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8881 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8882 }
8883
ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8884 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8885 {
8886 USE_OPLINE
8887 zval *op1, *op2;
8888 bool result;
8889
8890 op1 = RT_CONSTANT(opline, opline->op1);
8891 op2 = EX_VAR(opline->op2.var);
8892 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8893 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8894 }
8895
ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8896 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8897 {
8898 USE_OPLINE
8899 zval *op1, *op2;
8900 bool result;
8901
8902 op1 = RT_CONSTANT(opline, opline->op1);
8903 op2 = EX_VAR(opline->op2.var);
8904 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8905 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8906 }
8907
ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8908 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8909 {
8910 USE_OPLINE
8911 zval *op1, *op2;
8912 bool result;
8913
8914 op1 = RT_CONSTANT(opline, opline->op1);
8915 op2 = EX_VAR(opline->op2.var);
8916 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8917 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8918 }
8919
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8920 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8921 {
8922 USE_OPLINE
8923 zval *op1, *op2;
8924 bool result;
8925
8926 op1 = RT_CONSTANT(opline, opline->op1);
8927 op2 = EX_VAR(opline->op2.var);
8928 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8929 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8930 }
8931
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8932 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8933 {
8934 USE_OPLINE
8935 zval *op1, *op2;
8936 bool result;
8937
8938 op1 = RT_CONSTANT(opline, opline->op1);
8939 op2 = EX_VAR(opline->op2.var);
8940 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8941 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8942 }
8943
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8944 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8945 {
8946 USE_OPLINE
8947 zval *op1, *op2;
8948 bool result;
8949
8950 op1 = RT_CONSTANT(opline, opline->op1);
8951 op2 = EX_VAR(opline->op2.var);
8952 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8953 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8954 }
8955
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8956 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8957 {
8958 USE_OPLINE
8959 zval *op1, *op2;
8960 bool result;
8961
8962 op1 = RT_CONSTANT(opline, opline->op1);
8963 op2 = EX_VAR(opline->op2.var);
8964 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
8965 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8966 }
8967
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8968 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8969 {
8970 USE_OPLINE
8971 zval *op1, *op2;
8972 bool result;
8973
8974 op1 = RT_CONSTANT(opline, opline->op1);
8975 op2 = EX_VAR(opline->op2.var);
8976 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
8977 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8978 }
8979
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8980 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8981 {
8982 USE_OPLINE
8983 zval *op1, *op2;
8984 bool result;
8985
8986 op1 = RT_CONSTANT(opline, opline->op1);
8987 op2 = EX_VAR(opline->op2.var);
8988 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
8989 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8990 }
8991
ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8992 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8993 {
8994 USE_OPLINE
8995 zval *container, *dim, *value;
8996 zend_long offset;
8997 HashTable *ht;
8998
8999 container = RT_CONSTANT(opline, opline->op1);
9000 dim = EX_VAR(opline->op2.var);
9001 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9002 fetch_dim_r_index_array:
9003 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
9004 offset = Z_LVAL_P(dim);
9005 } else {
9006 SAVE_OPLINE();
9007 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
9008
9009 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9010 }
9011 ht = Z_ARRVAL_P(container);
9012 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
9013 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
9014 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9015 SAVE_OPLINE();
9016
9017 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9018 } else {
9019 ZEND_VM_NEXT_OPCODE();
9020 }
9021 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
9022 container = Z_REFVAL_P(container);
9023 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9024 goto fetch_dim_r_index_array;
9025 } else {
9026 goto fetch_dim_r_index_slow;
9027 }
9028 } else {
9029 fetch_dim_r_index_slow:
9030 SAVE_OPLINE();
9031 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
9032 dim++;
9033 }
9034 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
9035
9036 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9037 }
9038
9039 fetch_dim_r_index_undef:
9040 ZVAL_NULL(EX_VAR(opline->result.var));
9041 SAVE_OPLINE();
9042 zend_undefined_offset(offset);
9043
9044 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9045 }
9046
ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9047 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9048 {
9049 USE_OPLINE
9050 zval *op1, *op2;
9051
9052 SAVE_OPLINE();
9053 op1 = RT_CONSTANT(opline, opline->op1);
9054 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9055 div_function(EX_VAR(opline->result.var), op1, op2);
9056
9057 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9058 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9059 }
9060
ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9061 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9062 {
9063 USE_OPLINE
9064 zval *op1, *op2;
9065
9066 SAVE_OPLINE();
9067 op1 = RT_CONSTANT(opline, opline->op1);
9068 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9069 pow_function(EX_VAR(opline->result.var), op1, op2);
9070
9071 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9072 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9073 }
9074
ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9075 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9076 {
9077 USE_OPLINE
9078 zval *op1, *op2;
9079
9080 op1 = RT_CONSTANT(opline, opline->op1);
9081 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9082
9083 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
9084 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
9085 zend_string *op1_str = Z_STR_P(op1);
9086 zend_string *op2_str = Z_STR_P(op2);
9087 zend_string *str;
9088 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
9089
9090 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9091 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
9092 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
9093 } else {
9094 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9095 }
9096 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9097 zend_string_release_ex(op1_str, 0);
9098 }
9099 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9100 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
9101 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
9102 } else {
9103 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9104 }
9105 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9106 zend_string_release_ex(op2_str, 0);
9107 }
9108 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
9109 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
9110 size_t len = ZSTR_LEN(op1_str);
9111
9112 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
9113 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
9114 }
9115 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
9116 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9117 GC_ADD_FLAGS(str, flags);
9118 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9119 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9120 zend_string_release_ex(op2_str, 0);
9121 }
9122 } else {
9123 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9124 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9125 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9126 GC_ADD_FLAGS(str, flags);
9127 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9128 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9129 zend_string_release_ex(op1_str, 0);
9130 }
9131 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9132 zend_string_release_ex(op2_str, 0);
9133 }
9134 }
9135 ZEND_VM_NEXT_OPCODE();
9136 } else {
9137 SAVE_OPLINE();
9138
9139 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
9140 op1 = ZVAL_UNDEFINED_OP1();
9141 }
9142 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
9143 op2 = ZVAL_UNDEFINED_OP2();
9144 }
9145 concat_function(EX_VAR(opline->result.var), op1, op2);
9146
9147 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9148 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9149 }
9150 }
9151
ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9152 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9153 {
9154 USE_OPLINE
9155 zval *op1, *op2;
9156
9157 SAVE_OPLINE();
9158 op1 = RT_CONSTANT(opline, opline->op1);
9159 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9160 compare_function(EX_VAR(opline->result.var), op1, op2);
9161
9162 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9163 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9164 }
9165
ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9166 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9167 {
9168 USE_OPLINE
9169 zval *container, *dim, *value;
9170
9171 SAVE_OPLINE();
9172 container = RT_CONSTANT(opline, opline->op1);
9173 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9174 if (IS_CONST != IS_CONST) {
9175 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9176 fetch_dim_r_array:
9177 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
9178 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
9179 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
9180 container = Z_REFVAL_P(container);
9181 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9182 goto fetch_dim_r_array;
9183 } else {
9184 goto fetch_dim_r_slow;
9185 }
9186 } else {
9187 fetch_dim_r_slow:
9188 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
9189 dim++;
9190 }
9191 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
9192 }
9193 } else {
9194 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
9195 }
9196 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9197
9198 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9199 }
9200
ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9201 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9202 {
9203 USE_OPLINE
9204 zval *container;
9205
9206 SAVE_OPLINE();
9207 container = RT_CONSTANT(opline, opline->op1);
9208 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);
9209 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9210
9211 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9212 }
9213
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9214 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9215 {
9216 #if 0
9217 USE_OPLINE
9218 #endif
9219
9220 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
9221 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
9222 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9223 }
9224 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9225 } else {
9226 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
9227 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9228 }
9229 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9230 }
9231 }
9232
ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9233 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9234 {
9235 USE_OPLINE
9236 zval *container;
9237 void **cache_slot = NULL;
9238
9239 SAVE_OPLINE();
9240 container = RT_CONSTANT(opline, opline->op1);
9241
9242 if (IS_CONST == IS_CONST ||
9243 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9244 do {
9245 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9246 container = Z_REFVAL_P(container);
9247 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9248 break;
9249 }
9250 }
9251 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
9252 ZVAL_UNDEFINED_OP1();
9253 }
9254 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9255 ZVAL_NULL(EX_VAR(opline->result.var));
9256 goto fetch_obj_r_finish;
9257 } while (0);
9258 }
9259
9260 /* here we are sure we are dealing with an object */
9261 do {
9262 zend_object *zobj = Z_OBJ_P(container);
9263 zend_string *name, *tmp_name;
9264 zval *retval;
9265
9266 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9267 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
9268
9269 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9270 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9271
9272 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9273 fetch_obj_r_simple:
9274 retval = OBJ_PROP(zobj, prop_offset);
9275 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
9276 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9277 goto fetch_obj_r_copy;
9278 } else {
9279 fetch_obj_r_fast_copy:
9280 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9281 ZEND_VM_NEXT_OPCODE();
9282 }
9283 }
9284 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
9285 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
9286 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
9287 prop_offset = prop_info->offset;
9288 goto fetch_obj_r_simple;
9289 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
9290 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
9291 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
9292 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
9293
9294 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9295 if (IS_CONST & IS_CV) {
9296 GC_ADDREF(zobj);
9297 }
9298 if (IS_CONST & (IS_CV|IS_VAR|IS_TMP_VAR)) {
9299 call_info |= ZEND_CALL_RELEASE_THIS;
9300 }
9301 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
9302 call->prev_execute_data = execute_data;
9303 call->call = NULL;
9304 call->return_value = EX_VAR(opline->result.var);
9305 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
9306
9307 execute_data = call;
9308 EG(current_execute_data) = execute_data;
9309 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
9310
9311 #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
9312 opline = hook->op_array.opcodes;
9313 #else
9314 EX(opline) = hook->op_array.opcodes;
9315 #endif
9316 LOAD_OPLINE_EX();
9317
9318
9319 ZEND_VM_ENTER_EX();
9320 }
9321 /* Fall through to read_property for hooks. */
9322 } else if (EXPECTED(zobj->properties != NULL)) {
9323 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
9324 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9325 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9326 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9327
9328 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9329 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9330
9331 if (EXPECTED(p->key == name) ||
9332 (EXPECTED(p->h == ZSTR_H(name)) &&
9333 EXPECTED(p->key != NULL) &&
9334 EXPECTED(zend_string_equal_content(p->key, name)))) {
9335 retval = &p->val;
9336 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9337 goto fetch_obj_r_copy;
9338 } else {
9339 goto fetch_obj_r_fast_copy;
9340 }
9341 }
9342 }
9343 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9344 }
9345 retval = zend_hash_find_known_hash(zobj->properties, name);
9346 if (EXPECTED(retval)) {
9347 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9348 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9349 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9350 goto fetch_obj_r_copy;
9351 } else {
9352 goto fetch_obj_r_fast_copy;
9353 }
9354 }
9355 }
9356 }
9357 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9358 } else {
9359 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9360 if (UNEXPECTED(!name)) {
9361 ZVAL_UNDEF(EX_VAR(opline->result.var));
9362 break;
9363 }
9364 }
9365
9366 #if ZEND_DEBUG
9367 /* For non-standard object handlers, verify a declared property type in debug builds.
9368 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
9369 zend_property_info *prop_info = NULL;
9370 if (zobj->handlers->read_property != zend_std_read_property) {
9371 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
9372 }
9373 #endif
9374 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
9375 #if ZEND_DEBUG
9376 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
9377 && ZEND_TYPE_IS_SET(prop_info->type)) {
9378 ZVAL_OPT_DEREF(retval);
9379 zend_verify_property_type(prop_info, retval, /* strict */ true);
9380 }
9381 #endif
9382
9383 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9384 zend_tmp_string_release(tmp_name);
9385 }
9386
9387 if (retval != EX_VAR(opline->result.var)) {
9388 fetch_obj_r_copy:
9389 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9390 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9391 zend_unwrap_reference(retval);
9392 }
9393 } while (0);
9394
9395 fetch_obj_r_finish:
9396 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9397
9398 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9399 }
9400
ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9401 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9402 {
9403 USE_OPLINE
9404 zval *container;
9405 void **cache_slot = NULL;
9406
9407 SAVE_OPLINE();
9408 container = RT_CONSTANT(opline, opline->op1);
9409
9410 if (IS_CONST == IS_CONST ||
9411 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9412 do {
9413 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9414 container = Z_REFVAL_P(container);
9415 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9416 break;
9417 }
9418 }
9419 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
9420 ZVAL_UNDEFINED_OP2();
9421 }
9422 ZVAL_NULL(EX_VAR(opline->result.var));
9423 goto fetch_obj_is_finish;
9424 } while (0);
9425 }
9426
9427 /* here we are sure we are dealing with an object */
9428 do {
9429 zend_object *zobj = Z_OBJ_P(container);
9430 zend_string *name, *tmp_name;
9431 zval *retval;
9432
9433 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9434 cache_slot = CACHE_ADDR(opline->extended_value);
9435
9436 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9437 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9438
9439 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9440 fetch_obj_is_simple:
9441 retval = OBJ_PROP(zobj, prop_offset);
9442 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
9443 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9444 goto fetch_obj_is_copy;
9445 } else {
9446 fetch_obj_is_fast_copy:
9447 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9448 ZEND_VM_NEXT_OPCODE();
9449 }
9450 }
9451 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
9452 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
9453 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
9454 prop_offset = prop_info->offset;
9455 goto fetch_obj_is_simple;
9456 }
9457 /* Fall through to read_property for hooks. */
9458 } else if (EXPECTED(zobj->properties != NULL)) {
9459 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
9460 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9461 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9462 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9463
9464 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9465 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9466
9467 if (EXPECTED(p->key == name) ||
9468 (EXPECTED(p->h == ZSTR_H(name)) &&
9469 EXPECTED(p->key != NULL) &&
9470 EXPECTED(zend_string_equal_content(p->key, name)))) {
9471 retval = &p->val;
9472 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9473 goto fetch_obj_is_copy;
9474 } else {
9475 goto fetch_obj_is_fast_copy;
9476 }
9477 }
9478 }
9479 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9480 }
9481 retval = zend_hash_find_known_hash(zobj->properties, name);
9482 if (EXPECTED(retval)) {
9483 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9484 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9485 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9486 goto fetch_obj_is_copy;
9487 } else {
9488 goto fetch_obj_is_fast_copy;
9489 }
9490 }
9491 }
9492 }
9493 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9494 } else {
9495 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9496 if (UNEXPECTED(!name)) {
9497 ZVAL_UNDEF(EX_VAR(opline->result.var));
9498 break;
9499 }
9500 }
9501
9502 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
9503
9504 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9505 zend_tmp_string_release(tmp_name);
9506 }
9507
9508 if (retval != EX_VAR(opline->result.var)) {
9509 fetch_obj_is_copy:
9510 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9511 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9512 zend_unwrap_reference(retval);
9513 }
9514 } while (0);
9515
9516 fetch_obj_is_finish:
9517 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9518
9519 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9520 }
9521
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9522 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9523 {
9524 #if 0
9525 USE_OPLINE
9526 #endif
9527
9528 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
9529 /* Behave like FETCH_OBJ_W */
9530 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
9531 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9532 }
9533 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9534 } else {
9535 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9536 }
9537 }
9538
ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9539 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9540 {
9541 USE_OPLINE
9542 zval *container;
9543
9544 SAVE_OPLINE();
9545 container = RT_CONSTANT(opline, opline->op1);
9546 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);
9547 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9548 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9549 }
9550
ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9551 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9552 {
9553 USE_OPLINE
9554 zval *op1, *op2;
9555 zend_string *op1_str, *op2_str, *str;
9556
9557
9558 op1 = RT_CONSTANT(opline, opline->op1);
9559 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9560 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
9561 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
9562 zend_string *op1_str = Z_STR_P(op1);
9563 zend_string *op2_str = Z_STR_P(op2);
9564 zend_string *str;
9565 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
9566
9567 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9568 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
9569 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
9570 } else {
9571 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9572 }
9573 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9574 zend_string_release_ex(op1_str, 0);
9575 }
9576 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9577 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
9578 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
9579 } else {
9580 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9581 }
9582 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9583 zend_string_release_ex(op2_str, 0);
9584 }
9585 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
9586 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
9587 size_t len = ZSTR_LEN(op1_str);
9588
9589 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
9590 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9591 GC_ADD_FLAGS(str, flags);
9592 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9593 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9594 zend_string_release_ex(op2_str, 0);
9595 }
9596 } else {
9597 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9598 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9599 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9600 GC_ADD_FLAGS(str, flags);
9601 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9602 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9603 zend_string_release_ex(op1_str, 0);
9604 }
9605 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9606 zend_string_release_ex(op2_str, 0);
9607 }
9608 }
9609 ZEND_VM_NEXT_OPCODE();
9610 }
9611
9612 SAVE_OPLINE();
9613 if (IS_CONST == IS_CONST) {
9614 op1_str = Z_STR_P(op1);
9615 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
9616 op1_str = zend_string_copy(Z_STR_P(op1));
9617 } else {
9618 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
9619 ZVAL_UNDEFINED_OP1();
9620 }
9621 op1_str = zval_get_string_func(op1);
9622 }
9623 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9624 op2_str = Z_STR_P(op2);
9625 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
9626 op2_str = zend_string_copy(Z_STR_P(op2));
9627 } else {
9628 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
9629 ZVAL_UNDEFINED_OP2();
9630 }
9631 op2_str = zval_get_string_func(op2);
9632 }
9633 do {
9634 if (IS_CONST != IS_CONST) {
9635 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9636 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9637 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
9638 GC_ADDREF(op2_str);
9639 }
9640 }
9641 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9642 zend_string_release_ex(op1_str, 0);
9643 break;
9644 }
9645 }
9646 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9647 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9648 if (IS_CONST == IS_CONST) {
9649 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
9650 GC_ADDREF(op1_str);
9651 }
9652 }
9653 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9654 zend_string_release_ex(op2_str, 0);
9655 break;
9656 }
9657 }
9658 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9659 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9660 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9661
9662 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
9663 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9664 if (IS_CONST != IS_CONST) {
9665 zend_string_release_ex(op1_str, 0);
9666 }
9667 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9668 zend_string_release_ex(op2_str, 0);
9669 }
9670 } while (0);
9671
9672 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9673 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9674 }
9675
ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9676 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9677 {
9678 USE_OPLINE
9679 zval *function_name;
9680 zval *object;
9681 zend_function *fbc;
9682 zend_class_entry *called_scope;
9683 zend_object *obj;
9684 zend_execute_data *call;
9685 uint32_t call_info;
9686
9687 SAVE_OPLINE();
9688
9689 object = RT_CONSTANT(opline, opline->op1);
9690
9691 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9692 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9693 }
9694
9695 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
9696 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9697 do {
9698 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
9699 function_name = Z_REFVAL_P(function_name);
9700 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
9701 break;
9702 }
9703 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
9704 ZVAL_UNDEFINED_OP2();
9705 if (UNEXPECTED(EG(exception) != NULL)) {
9706
9707 HANDLE_EXCEPTION();
9708 }
9709 }
9710 zend_throw_error(NULL, "Method name must be a string");
9711 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9712
9713 HANDLE_EXCEPTION();
9714 } while (0);
9715 }
9716
9717 if (IS_CONST == IS_UNUSED) {
9718 obj = Z_OBJ_P(object);
9719 } else {
9720 do {
9721 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9722 obj = Z_OBJ_P(object);
9723 } else {
9724 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
9725 zend_reference *ref = Z_REF_P(object);
9726
9727 object = &ref->val;
9728 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9729 obj = Z_OBJ_P(object);
9730 if (IS_CONST & IS_VAR) {
9731 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
9732 efree_size(ref, sizeof(zend_reference));
9733 } else {
9734 Z_ADDREF_P(object);
9735 }
9736 }
9737 break;
9738 }
9739 }
9740 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
9741 object = ZVAL_UNDEFINED_OP1();
9742 if (UNEXPECTED(EG(exception) != NULL)) {
9743 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9744 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9745 }
9746 HANDLE_EXCEPTION();
9747 }
9748 }
9749 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9750 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9751 }
9752 zend_invalid_method_call(object, function_name);
9753 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9754
9755 HANDLE_EXCEPTION();
9756 }
9757 } while (0);
9758 }
9759
9760 called_scope = obj->ce;
9761
9762 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9763 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
9764 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9765 } else {
9766 zend_object *orig_obj = obj;
9767
9768 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9769 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9770 }
9771
9772 /* First, locate the function. */
9773 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));
9774 if (UNEXPECTED(fbc == NULL)) {
9775 if (EXPECTED(!EG(exception))) {
9776 zend_undefined_method(obj->ce, Z_STR_P(function_name));
9777 }
9778 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9779 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
9780 zend_objects_store_del(orig_obj);
9781 }
9782 HANDLE_EXCEPTION();
9783 }
9784 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9785 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
9786 EXPECTED(obj == orig_obj)) {
9787 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
9788 }
9789 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
9790 GC_ADDREF(obj); /* For $this pointer */
9791 if (GC_DELREF(orig_obj) == 0) {
9792 zend_objects_store_del(orig_obj);
9793 }
9794 }
9795 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9796 init_func_run_time_cache(&fbc->op_array);
9797 }
9798 }
9799
9800 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9801 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9802 }
9803
9804 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9805 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
9806 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
9807 zend_objects_store_del(obj);
9808 if (UNEXPECTED(EG(exception))) {
9809 HANDLE_EXCEPTION();
9810 }
9811 }
9812 /* call static method */
9813 obj = (zend_object*)called_scope;
9814 call_info = ZEND_CALL_NESTED_FUNCTION;
9815 } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
9816 if (IS_CONST == IS_CV) {
9817 GC_ADDREF(obj); /* For $this pointer */
9818 }
9819 /* CV may be changed indirectly (e.g. when it's a reference) */
9820 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
9821 }
9822
9823 call = zend_vm_stack_push_call_frame(call_info,
9824 fbc, opline->extended_value, obj);
9825 call->prev_execute_data = EX(call);
9826 EX(call) = call;
9827
9828 ZEND_VM_NEXT_OPCODE();
9829 }
9830
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9831 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9832 {
9833 USE_OPLINE
9834 zval *function_name;
9835 zend_class_entry *ce;
9836 uint32_t call_info;
9837 zend_function *fbc;
9838 zend_execute_data *call;
9839
9840 SAVE_OPLINE();
9841
9842 if (IS_CONST == IS_CONST) {
9843 /* no function found. try a static method in class */
9844 ce = CACHED_PTR(opline->result.num);
9845 if (UNEXPECTED(ce == NULL)) {
9846 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);
9847 if (UNEXPECTED(ce == NULL)) {
9848 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9849 HANDLE_EXCEPTION();
9850 }
9851 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9852 CACHE_PTR(opline->result.num, ce);
9853 }
9854 }
9855 } else if (IS_CONST == IS_UNUSED) {
9856 ce = zend_fetch_class(NULL, opline->op1.num);
9857 if (UNEXPECTED(ce == NULL)) {
9858 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9859 HANDLE_EXCEPTION();
9860 }
9861 } else {
9862 ce = Z_CE_P(EX_VAR(opline->op1.var));
9863 }
9864
9865 if (IS_CONST == IS_CONST &&
9866 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9867 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
9868 /* nothing to do */
9869 } else if (IS_CONST != IS_CONST &&
9870 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9871 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
9872 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9873 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
9874 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9875 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9876 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9877 do {
9878 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
9879 function_name = Z_REFVAL_P(function_name);
9880 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
9881 break;
9882 }
9883 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
9884 ZVAL_UNDEFINED_OP2();
9885 if (UNEXPECTED(EG(exception) != NULL)) {
9886 HANDLE_EXCEPTION();
9887 }
9888 }
9889 zend_throw_error(NULL, "Method name must be a string");
9890 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9891 HANDLE_EXCEPTION();
9892 } while (0);
9893 }
9894 }
9895
9896 if (ce->get_static_method) {
9897 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
9898 } else {
9899 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));
9900 }
9901 if (UNEXPECTED(fbc == NULL)) {
9902 if (EXPECTED(!EG(exception))) {
9903 zend_undefined_method(ce, Z_STR_P(function_name));
9904 }
9905 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9906 HANDLE_EXCEPTION();
9907 }
9908 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9909 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
9910 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
9911 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
9912 }
9913 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9914 init_func_run_time_cache(&fbc->op_array);
9915 }
9916 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9917 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9918 }
9919 } else {
9920 if (UNEXPECTED(ce->constructor == NULL)) {
9921 zend_throw_error(NULL, "Cannot call constructor");
9922 HANDLE_EXCEPTION();
9923 }
9924 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
9925 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
9926 HANDLE_EXCEPTION();
9927 }
9928 fbc = ce->constructor;
9929 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9930 init_func_run_time_cache(&fbc->op_array);
9931 }
9932 }
9933
9934 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
9935 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
9936 ce = (zend_class_entry*)Z_OBJ(EX(This));
9937 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9938 } else {
9939 zend_non_static_method_call(fbc);
9940 HANDLE_EXCEPTION();
9941 }
9942 } else {
9943 /* previous opcode is ZEND_FETCH_CLASS */
9944 if (IS_CONST == IS_UNUSED
9945 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
9946 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
9947 if (Z_TYPE(EX(This)) == IS_OBJECT) {
9948 ce = Z_OBJCE(EX(This));
9949 } else {
9950 ce = Z_CE(EX(This));
9951 }
9952 }
9953 call_info = ZEND_CALL_NESTED_FUNCTION;
9954 }
9955
9956 call = zend_vm_stack_push_call_frame(call_info,
9957 fbc, opline->extended_value, ce);
9958 call->prev_execute_data = EX(call);
9959 EX(call) = call;
9960
9961 ZEND_VM_NEXT_OPCODE();
9962 }
9963
ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9964 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9965 {
9966 USE_OPLINE
9967 zval *function_name;
9968 zend_fcall_info_cache fcc;
9969 char *error = NULL;
9970 zend_function *func;
9971 void *object_or_called_scope;
9972 zend_execute_data *call;
9973 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
9974
9975 SAVE_OPLINE();
9976 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9977 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
9978 ZEND_ASSERT(!error);
9979 func = fcc.function_handler;
9980 object_or_called_scope = fcc.called_scope;
9981 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
9982 /* Delay closure destruction until its invocation */
9983 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
9984 call_info |= ZEND_CALL_CLOSURE;
9985 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
9986 call_info |= ZEND_CALL_FAKE_CLOSURE;
9987 }
9988 if (fcc.object) {
9989 object_or_called_scope = fcc.object;
9990 call_info |= ZEND_CALL_HAS_THIS;
9991 }
9992 } else if (fcc.object) {
9993 GC_ADDREF(fcc.object); /* For $this pointer */
9994 object_or_called_scope = fcc.object;
9995 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
9996 }
9997
9998 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9999 if (((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
10000 if (call_info & ZEND_CALL_CLOSURE) {
10001 zend_object_release(ZEND_CLOSURE_OBJECT(func));
10002 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
10003 zend_object_release(fcc.object);
10004 }
10005 HANDLE_EXCEPTION();
10006 }
10007
10008 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
10009 init_func_run_time_cache(&func->op_array);
10010 }
10011 } else {
10012 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
10013 efree(error);
10014 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10015 HANDLE_EXCEPTION();
10016 }
10017
10018 call = zend_vm_stack_push_call_frame(call_info,
10019 func, opline->extended_value, object_or_called_scope);
10020 call->prev_execute_data = EX(call);
10021 EX(call) = call;
10022
10023 ZEND_VM_NEXT_OPCODE();
10024 }
10025
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10026 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10027 {
10028 USE_OPLINE
10029 zval *expr_ptr, new_expr;
10030
10031 SAVE_OPLINE();
10032 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
10033 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
10034 expr_ptr = zend_get_bad_ptr();
10035 if (Z_ISREF_P(expr_ptr)) {
10036 Z_ADDREF_P(expr_ptr);
10037 } else {
10038 ZVAL_MAKE_REF_EX(expr_ptr, 2);
10039 }
10040
10041 } else {
10042 expr_ptr = RT_CONSTANT(opline, opline->op1);
10043 if (IS_CONST == IS_TMP_VAR) {
10044 /* pass */
10045 } else if (IS_CONST == IS_CONST) {
10046 Z_TRY_ADDREF_P(expr_ptr);
10047 } else if (IS_CONST == IS_CV) {
10048 ZVAL_DEREF(expr_ptr);
10049 Z_TRY_ADDREF_P(expr_ptr);
10050 } else /* if (IS_CONST == IS_VAR) */ {
10051 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
10052 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
10053
10054 expr_ptr = Z_REFVAL_P(expr_ptr);
10055 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
10056 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
10057 expr_ptr = &new_expr;
10058 efree_size(ref, sizeof(zend_reference));
10059 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
10060 Z_ADDREF_P(expr_ptr);
10061 }
10062 }
10063 }
10064 }
10065
10066 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
10067 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10068 zend_string *str;
10069 zend_ulong hval;
10070
10071 add_again:
10072 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
10073 str = Z_STR_P(offset);
10074 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10075 if (ZEND_HANDLE_NUMERIC(str, hval)) {
10076 goto num_index;
10077 }
10078 }
10079 str_index:
10080 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
10081 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
10082 hval = Z_LVAL_P(offset);
10083 num_index:
10084 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
10085 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
10086 offset = Z_REFVAL_P(offset);
10087 goto add_again;
10088 } else if (Z_TYPE_P(offset) == IS_NULL) {
10089 str = ZSTR_EMPTY_ALLOC();
10090 goto str_index;
10091 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
10092 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
10093 goto num_index;
10094 } else if (Z_TYPE_P(offset) == IS_FALSE) {
10095 hval = 0;
10096 goto num_index;
10097 } else if (Z_TYPE_P(offset) == IS_TRUE) {
10098 hval = 1;
10099 goto num_index;
10100 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
10101 zend_use_resource_as_offset(offset);
10102 hval = Z_RES_HANDLE_P(offset);
10103 goto num_index;
10104 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
10105 ZVAL_UNDEFINED_OP2();
10106 str = ZSTR_EMPTY_ALLOC();
10107 goto str_index;
10108 } else {
10109 zend_illegal_array_offset_access(offset);
10110 zval_ptr_dtor_nogc(expr_ptr);
10111 }
10112 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10113 } else {
10114 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
10115 zend_cannot_add_element();
10116 zval_ptr_dtor_nogc(expr_ptr);
10117 }
10118 }
10119 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10120 }
10121
ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10122 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10123 {
10124 zval *array;
10125 uint32_t size;
10126 USE_OPLINE
10127
10128 array = EX_VAR(opline->result.var);
10129 if (IS_CONST != IS_UNUSED) {
10130 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
10131 ZVAL_ARR(array, zend_new_array(size));
10132 /* Explicitly initialize array as not-packed if flag is set */
10133 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
10134 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
10135 }
10136 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10137 } else {
10138 ZVAL_ARR(array, zend_new_array(0));
10139 ZEND_VM_NEXT_OPCODE();
10140 }
10141 }
10142
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10143 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10144 {
10145 USE_OPLINE
10146 zval *container;
10147 bool result;
10148 zend_ulong hval;
10149 zval *offset;
10150
10151 SAVE_OPLINE();
10152 container = RT_CONSTANT(opline, opline->op1);
10153 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10154
10155 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
10156 HashTable *ht;
10157 zval *value;
10158 zend_string *str;
10159
10160 isset_dim_obj_array:
10161 ht = Z_ARRVAL_P(container);
10162 isset_again:
10163 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
10164 str = Z_STR_P(offset);
10165 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10166 if (ZEND_HANDLE_NUMERIC(str, hval)) {
10167 goto num_index_prop;
10168 }
10169 }
10170 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
10171 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
10172 hval = Z_LVAL_P(offset);
10173 num_index_prop:
10174 value = zend_hash_index_find(ht, hval);
10175 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
10176 offset = Z_REFVAL_P(offset);
10177 goto isset_again;
10178 } else {
10179 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
10180 if (UNEXPECTED(EG(exception))) {
10181 result = 0;
10182 goto isset_dim_obj_exit;
10183 }
10184 }
10185
10186 if (!(opline->extended_value & ZEND_ISEMPTY)) {
10187 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
10188 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
10189 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
10190
10191 if (IS_CONST & (IS_CONST|IS_CV)) {
10192 /* avoid exception check */
10193 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10194 ZEND_VM_SMART_BRANCH(result, 0);
10195 }
10196 } else {
10197 result = (value == NULL || !i_zend_is_true(value));
10198 }
10199 goto isset_dim_obj_exit;
10200 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
10201 container = Z_REFVAL_P(container);
10202 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
10203 goto isset_dim_obj_array;
10204 }
10205 }
10206
10207 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
10208 offset++;
10209 }
10210 if (!(opline->extended_value & ZEND_ISEMPTY)) {
10211 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
10212 } else {
10213 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
10214 }
10215
10216 isset_dim_obj_exit:
10217 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10218
10219 ZEND_VM_SMART_BRANCH(result, 1);
10220 }
10221
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10222 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10223 {
10224 USE_OPLINE
10225 zval *container;
10226 int result;
10227 zval *offset;
10228 zend_string *name, *tmp_name;
10229
10230 SAVE_OPLINE();
10231 container = RT_CONSTANT(opline, opline->op1);
10232 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10233
10234 if (IS_CONST == IS_CONST ||
10235 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
10236 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
10237 container = Z_REFVAL_P(container);
10238 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
10239 result = (opline->extended_value & ZEND_ISEMPTY);
10240 goto isset_object_finish;
10241 }
10242 } else {
10243 result = (opline->extended_value & ZEND_ISEMPTY);
10244 goto isset_object_finish;
10245 }
10246 }
10247
10248 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
10249 name = Z_STR_P(offset);
10250 } else {
10251 name = zval_try_get_tmp_string(offset, &tmp_name);
10252 if (UNEXPECTED(!name)) {
10253 result = 0;
10254 goto isset_object_finish;
10255 }
10256 }
10257
10258 result =
10259 (opline->extended_value & ZEND_ISEMPTY) ^
10260 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));
10261
10262 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
10263 zend_tmp_string_release(tmp_name);
10264 }
10265
10266 isset_object_finish:
10267 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10268
10269 ZEND_VM_SMART_BRANCH(result, 1);
10270 }
10271
ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10272 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10273 {
10274 USE_OPLINE
10275
10276 zval *key, *subject;
10277 HashTable *ht;
10278 bool result;
10279
10280 SAVE_OPLINE();
10281
10282 key = RT_CONSTANT(opline, opline->op1);
10283 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10284
10285 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10286 array_key_exists_array:
10287 ht = Z_ARRVAL_P(subject);
10288 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
10289 } else {
10290 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
10291 subject = Z_REFVAL_P(subject);
10292 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10293 goto array_key_exists_array;
10294 }
10295 }
10296 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
10297 result = 0;
10298 }
10299
10300 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10301
10302 ZEND_VM_SMART_BRANCH(result, 1);
10303 }
10304
ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10305 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10306 {
10307 USE_OPLINE
10308
10309 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
10310
10311 SAVE_OPLINE();
10312 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
10313 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10314 }
10315
10316 /* Destroy the previously yielded value */
10317 zval_ptr_dtor(&generator->value);
10318
10319 /* Destroy the previously yielded key */
10320 zval_ptr_dtor(&generator->key);
10321
10322 /* Set the new yielded value */
10323 if (IS_CONST != IS_UNUSED) {
10324 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10325 /* Constants and temporary variables aren't yieldable by reference,
10326 * but we still allow them with a notice. */
10327 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
10328 zval *value;
10329
10330 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10331
10332 value = RT_CONSTANT(opline, opline->op1);
10333 ZVAL_COPY_VALUE(&generator->value, value);
10334 if (IS_CONST == IS_CONST) {
10335 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10336 Z_ADDREF(generator->value);
10337 }
10338 }
10339 } else {
10340 zval *value_ptr = zend_get_bad_ptr();
10341
10342 /* If a function call result is yielded and the function did
10343 * not return by reference we throw a notice. */
10344 do {
10345 if (IS_CONST == IS_VAR) {
10346 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
10347 if (opline->extended_value == ZEND_RETURNS_FUNCTION
10348 && !Z_ISREF_P(value_ptr)) {
10349 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10350 ZVAL_COPY(&generator->value, value_ptr);
10351 break;
10352 }
10353 }
10354 if (Z_ISREF_P(value_ptr)) {
10355 Z_ADDREF_P(value_ptr);
10356 } else {
10357 ZVAL_MAKE_REF_EX(value_ptr, 2);
10358 }
10359 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
10360 } while (0);
10361
10362 }
10363 } else {
10364 zval *value = RT_CONSTANT(opline, opline->op1);
10365
10366 /* Consts, temporary variables and references need copying */
10367 if (IS_CONST == IS_CONST) {
10368 ZVAL_COPY_VALUE(&generator->value, value);
10369 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10370 Z_ADDREF(generator->value);
10371 }
10372 } else if (IS_CONST == IS_TMP_VAR) {
10373 ZVAL_COPY_VALUE(&generator->value, value);
10374 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
10375 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
10376
10377 } else {
10378 ZVAL_COPY_VALUE(&generator->value, value);
10379 if (IS_CONST == IS_CV) {
10380 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
10381 }
10382 }
10383 }
10384 } else {
10385 /* If no value was specified yield null */
10386 ZVAL_NULL(&generator->value);
10387 }
10388
10389 /* Set the new yielded key */
10390 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
10391 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10392 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
10393 key = Z_REFVAL_P(key);
10394 }
10395 ZVAL_COPY(&generator->key, key);
10396 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10397
10398 if (Z_TYPE(generator->key) == IS_LONG
10399 && Z_LVAL(generator->key) > generator->largest_used_integer_key
10400 ) {
10401 generator->largest_used_integer_key = Z_LVAL(generator->key);
10402 }
10403 } else {
10404 /* If no key was specified we use auto-increment keys */
10405 generator->largest_used_integer_key++;
10406 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
10407 }
10408
10409 if (RETURN_VALUE_USED(opline)) {
10410 /* If the return value of yield is used set the send
10411 * target and initialize it to NULL */
10412 generator->send_target = EX_VAR(opline->result.var);
10413 ZVAL_NULL(generator->send_target);
10414 } else {
10415 generator->send_target = NULL;
10416 }
10417
10418 /* The GOTO VM uses a local opline variable. We need to set the opline
10419 * variable in execute_data so we don't resume at an old position. */
10420 SAVE_OPLINE();
10421
10422 ZEND_VM_RETURN();
10423 }
10424
zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)10425 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
10426 {
10427 USE_OPLINE
10428 zval *varname;
10429 zval *retval;
10430 zend_string *name, *tmp_name;
10431 HashTable *target_symbol_table;
10432
10433 SAVE_OPLINE();
10434 varname = RT_CONSTANT(opline, opline->op1);
10435
10436 if (IS_CONST == IS_CONST) {
10437 name = Z_STR_P(varname);
10438 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
10439 name = Z_STR_P(varname);
10440 tmp_name = NULL;
10441 } else {
10442 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
10443 ZVAL_UNDEFINED_OP1();
10444 }
10445 name = zval_try_get_tmp_string(varname, &tmp_name);
10446 if (UNEXPECTED(!name)) {
10447 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10448
10449 }
10450 ZVAL_UNDEF(EX_VAR(opline->result.var));
10451 HANDLE_EXCEPTION();
10452 }
10453 }
10454
10455 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
10456 retval = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
10457 if (retval == NULL) {
10458 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10459 fetch_this:
10460 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
10461 if (IS_CONST != IS_CONST) {
10462 zend_tmp_string_release(tmp_name);
10463 }
10464 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10465 }
10466 if (type == BP_VAR_W) {
10467 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
10468 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10469 retval = &EG(uninitialized_zval);
10470 } else {
10471 if (IS_CONST == IS_CV) {
10472 /* Keep name alive in case an error handler tries to free it. */
10473 zend_string_addref(name);
10474 }
10475 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10476 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10477 if (type == BP_VAR_RW && !EG(exception)) {
10478 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
10479 } else {
10480 retval = &EG(uninitialized_zval);
10481 }
10482 if (IS_CONST == IS_CV) {
10483 zend_string_release(name);
10484 }
10485 }
10486 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
10487 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
10488 retval = Z_INDIRECT_P(retval);
10489 if (Z_TYPE_P(retval) == IS_UNDEF) {
10490 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10491 goto fetch_this;
10492 }
10493 if (type == BP_VAR_W) {
10494 ZVAL_NULL(retval);
10495 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10496 retval = &EG(uninitialized_zval);
10497 } else {
10498 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10499 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10500 if (type == BP_VAR_RW && !EG(exception)) {
10501 ZVAL_NULL(retval);
10502 } else {
10503 retval = &EG(uninitialized_zval);
10504 }
10505 }
10506 }
10507 }
10508
10509 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10510
10511 }
10512
10513 if (IS_CONST != IS_CONST) {
10514 zend_tmp_string_release(tmp_name);
10515 }
10516
10517 ZEND_ASSERT(retval != NULL);
10518 if (type == BP_VAR_R || type == BP_VAR_IS) {
10519 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
10520 } else {
10521 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
10522 }
10523 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10524 }
10525
ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10526 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10527 {
10528 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10529 }
10530
ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10531 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10532 {
10533 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10534 }
10535
ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10536 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10537 {
10538 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10539 }
10540
ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10541 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10542 {
10543 int fetch_type =
10544 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
10545 BP_VAR_W : BP_VAR_R;
10546 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10547 }
10548
ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10549 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10550 {
10551 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10552 }
10553
ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10554 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10555 {
10556 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10557 }
10558
10559 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10560 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10561 {
10562 #if 0
10563 USE_OPLINE
10564 #endif
10565
10566 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
10567 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
10568 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10569 }
10570 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10571 } else {
10572 if (IS_UNUSED == IS_UNUSED) {
10573 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10574 }
10575 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10576 }
10577 }
10578
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10579 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10580 {
10581 USE_OPLINE
10582 zval *function_name;
10583 zend_class_entry *ce;
10584 uint32_t call_info;
10585 zend_function *fbc;
10586 zend_execute_data *call;
10587
10588 SAVE_OPLINE();
10589
10590 if (IS_CONST == IS_CONST) {
10591 /* no function found. try a static method in class */
10592 ce = CACHED_PTR(opline->result.num);
10593 if (UNEXPECTED(ce == NULL)) {
10594 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);
10595 if (UNEXPECTED(ce == NULL)) {
10596
10597 HANDLE_EXCEPTION();
10598 }
10599 if (IS_UNUSED != IS_CONST) {
10600 CACHE_PTR(opline->result.num, ce);
10601 }
10602 }
10603 } else if (IS_CONST == IS_UNUSED) {
10604 ce = zend_fetch_class(NULL, opline->op1.num);
10605 if (UNEXPECTED(ce == NULL)) {
10606
10607 HANDLE_EXCEPTION();
10608 }
10609 } else {
10610 ce = Z_CE_P(EX_VAR(opline->op1.var));
10611 }
10612
10613 if (IS_CONST == IS_CONST &&
10614 IS_UNUSED == IS_CONST &&
10615 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
10616 /* nothing to do */
10617 } else if (IS_CONST != IS_CONST &&
10618 IS_UNUSED == IS_CONST &&
10619 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
10620 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
10621 } else if (IS_UNUSED != IS_UNUSED) {
10622 function_name = NULL;
10623 if (IS_UNUSED != IS_CONST) {
10624 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
10625 do {
10626 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
10627 function_name = Z_REFVAL_P(function_name);
10628 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
10629 break;
10630 }
10631 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
10632 ZVAL_UNDEFINED_OP2();
10633 if (UNEXPECTED(EG(exception) != NULL)) {
10634 HANDLE_EXCEPTION();
10635 }
10636 }
10637 zend_throw_error(NULL, "Method name must be a string");
10638
10639 HANDLE_EXCEPTION();
10640 } while (0);
10641 }
10642 }
10643
10644 if (ce->get_static_method) {
10645 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
10646 } else {
10647 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
10648 }
10649 if (UNEXPECTED(fbc == NULL)) {
10650 if (EXPECTED(!EG(exception))) {
10651 zend_undefined_method(ce, Z_STR_P(function_name));
10652 }
10653
10654 HANDLE_EXCEPTION();
10655 }
10656 if (IS_UNUSED == IS_CONST &&
10657 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
10658 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
10659 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
10660 }
10661 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10662 init_func_run_time_cache(&fbc->op_array);
10663 }
10664 if (IS_UNUSED != IS_CONST) {
10665
10666 }
10667 } else {
10668 if (UNEXPECTED(ce->constructor == NULL)) {
10669 zend_throw_error(NULL, "Cannot call constructor");
10670 HANDLE_EXCEPTION();
10671 }
10672 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
10673 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
10674 HANDLE_EXCEPTION();
10675 }
10676 fbc = ce->constructor;
10677 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10678 init_func_run_time_cache(&fbc->op_array);
10679 }
10680 }
10681
10682 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
10683 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
10684 ce = (zend_class_entry*)Z_OBJ(EX(This));
10685 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
10686 } else {
10687 zend_non_static_method_call(fbc);
10688 HANDLE_EXCEPTION();
10689 }
10690 } else {
10691 /* previous opcode is ZEND_FETCH_CLASS */
10692 if (IS_CONST == IS_UNUSED
10693 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
10694 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
10695 if (Z_TYPE(EX(This)) == IS_OBJECT) {
10696 ce = Z_OBJCE(EX(This));
10697 } else {
10698 ce = Z_CE(EX(This));
10699 }
10700 }
10701 call_info = ZEND_CALL_NESTED_FUNCTION;
10702 }
10703
10704 call = zend_vm_stack_push_call_frame(call_info,
10705 fbc, opline->extended_value, ce);
10706 call->prev_execute_data = EX(call);
10707 EX(call) = call;
10708
10709 ZEND_VM_NEXT_OPCODE();
10710 }
10711
ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10712 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10713 {
10714 if (IS_CONST == IS_UNUSED) {
10715 SAVE_OPLINE();
10716 zend_verify_missing_return_type(EX(func));
10717 HANDLE_EXCEPTION();
10718 } else {
10719 /* prevents "undefined variable opline" errors */
10720 #if 0 || (IS_CONST != IS_UNUSED)
10721 USE_OPLINE
10722 zval *retval_ref, *retval_ptr;
10723 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
10724 retval_ref = retval_ptr = RT_CONSTANT(opline, opline->op1);
10725
10726 if (IS_CONST == IS_CONST) {
10727 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
10728 retval_ref = retval_ptr = EX_VAR(opline->result.var);
10729 } else if (IS_CONST == IS_VAR) {
10730 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
10731 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
10732 }
10733 ZVAL_DEREF(retval_ptr);
10734 } else if (IS_CONST == IS_CV) {
10735 ZVAL_DEREF(retval_ptr);
10736 }
10737
10738 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
10739 ZEND_VM_NEXT_OPCODE();
10740 }
10741
10742 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
10743 SAVE_OPLINE();
10744 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
10745 if (UNEXPECTED(EG(exception))) {
10746 HANDLE_EXCEPTION();
10747 }
10748 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
10749 ZEND_VM_NEXT_OPCODE();
10750 }
10751 }
10752
10753 zend_reference *ref = NULL;
10754 void *cache_slot = CACHE_ADDR(opline->op2.num);
10755 if (UNEXPECTED(retval_ref != retval_ptr)) {
10756 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10757 ref = Z_REF_P(retval_ref);
10758 } else {
10759 /* A cast might happen - unwrap the reference if this is a by-value return */
10760 if (Z_REFCOUNT_P(retval_ref) == 1) {
10761 ZVAL_UNREF(retval_ref);
10762 } else {
10763 Z_DELREF_P(retval_ref);
10764 ZVAL_COPY(retval_ref, retval_ptr);
10765 }
10766 retval_ptr = retval_ref;
10767 }
10768 }
10769
10770 SAVE_OPLINE();
10771 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
10772 zend_verify_return_error(EX(func), retval_ptr);
10773 HANDLE_EXCEPTION();
10774 }
10775 ZEND_VM_NEXT_OPCODE();
10776 #endif
10777 }
10778 }
10779
ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10780 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10781 {
10782 USE_OPLINE
10783 zval *value, *arg;
10784
10785 if (IS_UNUSED == IS_CONST) {
10786 SAVE_OPLINE();
10787 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10788 uint32_t arg_num;
10789 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10790 if (UNEXPECTED(!arg)) {
10791
10792 HANDLE_EXCEPTION();
10793 }
10794 } else {
10795 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10796 }
10797
10798 value = RT_CONSTANT(opline, opline->op1);
10799 ZVAL_COPY_VALUE(arg, value);
10800 if (IS_CONST == IS_CONST) {
10801 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10802 Z_ADDREF_P(arg);
10803 }
10804 }
10805 ZEND_VM_NEXT_OPCODE();
10806 }
10807
ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10808 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10809 {
10810 USE_OPLINE
10811 zval *value, *arg;
10812 uint32_t arg_num;
10813
10814 if (IS_UNUSED == IS_CONST) {
10815 SAVE_OPLINE();
10816 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10817 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10818 if (UNEXPECTED(!arg)) {
10819
10820 HANDLE_EXCEPTION();
10821 }
10822 } else {
10823 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10824 arg_num = opline->op2.num;
10825 }
10826
10827 if (EXPECTED(0)) {
10828 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10829 goto send_val_by_ref;
10830 }
10831 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10832 send_val_by_ref:
10833 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10834 }
10835 value = RT_CONSTANT(opline, opline->op1);
10836 ZVAL_COPY_VALUE(arg, value);
10837 if (IS_CONST == IS_CONST) {
10838 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10839 Z_ADDREF_P(arg);
10840 }
10841 }
10842 ZEND_VM_NEXT_OPCODE();
10843 }
10844
ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10845 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10846 {
10847 USE_OPLINE
10848 zval *value, *arg;
10849 uint32_t arg_num;
10850
10851 if (IS_UNUSED == IS_CONST) {
10852 SAVE_OPLINE();
10853 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10854 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10855 if (UNEXPECTED(!arg)) {
10856
10857 HANDLE_EXCEPTION();
10858 }
10859 } else {
10860 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10861 arg_num = opline->op2.num;
10862 }
10863
10864 if (EXPECTED(1)) {
10865 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10866 goto send_val_by_ref;
10867 }
10868 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10869 send_val_by_ref:
10870 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10871 }
10872 value = RT_CONSTANT(opline, opline->op1);
10873 ZVAL_COPY_VALUE(arg, value);
10874 if (IS_CONST == IS_CONST) {
10875 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10876 Z_ADDREF_P(arg);
10877 }
10878 }
10879 ZEND_VM_NEXT_OPCODE();
10880 }
10881
ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10882 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10883 {
10884 USE_OPLINE
10885 zval *result;
10886 zend_function *constructor;
10887 zend_class_entry *ce;
10888 zend_execute_data *call;
10889
10890 SAVE_OPLINE();
10891 if (IS_CONST == IS_CONST) {
10892 ce = CACHED_PTR(opline->op2.num);
10893 if (UNEXPECTED(ce == NULL)) {
10894 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);
10895 if (UNEXPECTED(ce == NULL)) {
10896 ZVAL_UNDEF(EX_VAR(opline->result.var));
10897 HANDLE_EXCEPTION();
10898 }
10899 CACHE_PTR(opline->op2.num, ce);
10900 }
10901 } else if (IS_CONST == IS_UNUSED) {
10902 ce = zend_fetch_class(NULL, opline->op1.num);
10903 if (UNEXPECTED(ce == NULL)) {
10904 ZVAL_UNDEF(EX_VAR(opline->result.var));
10905 HANDLE_EXCEPTION();
10906 }
10907 } else {
10908 ce = Z_CE_P(EX_VAR(opline->op1.var));
10909 }
10910
10911 result = EX_VAR(opline->result.var);
10912 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
10913 ZVAL_UNDEF(result);
10914 HANDLE_EXCEPTION();
10915 }
10916
10917 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
10918 if (constructor == NULL) {
10919 if (UNEXPECTED(EG(exception))) {
10920 HANDLE_EXCEPTION();
10921 }
10922
10923 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
10924 * opcode is DO_FCALL in case EXT instructions are used. */
10925 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
10926 ZEND_VM_NEXT_OPCODE_EX(1, 2);
10927 }
10928
10929 /* Perform a dummy function call */
10930 call = zend_vm_stack_push_call_frame(
10931 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
10932 opline->extended_value, NULL);
10933 } else {
10934 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
10935 init_func_run_time_cache(&constructor->op_array);
10936 }
10937 /* We are not handling overloaded classes right now */
10938 call = zend_vm_stack_push_call_frame(
10939 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
10940 constructor,
10941 opline->extended_value,
10942 Z_OBJ_P(result));
10943 Z_ADDREF_P(result);
10944 }
10945
10946 call->prev_execute_data = EX(call);
10947 EX(call) = call;
10948 ZEND_VM_NEXT_OPCODE();
10949 }
10950
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10951 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10952 {
10953 USE_OPLINE
10954 zval *expr_ptr, new_expr;
10955
10956 SAVE_OPLINE();
10957 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
10958 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
10959 expr_ptr = zend_get_bad_ptr();
10960 if (Z_ISREF_P(expr_ptr)) {
10961 Z_ADDREF_P(expr_ptr);
10962 } else {
10963 ZVAL_MAKE_REF_EX(expr_ptr, 2);
10964 }
10965
10966 } else {
10967 expr_ptr = RT_CONSTANT(opline, opline->op1);
10968 if (IS_CONST == IS_TMP_VAR) {
10969 /* pass */
10970 } else if (IS_CONST == IS_CONST) {
10971 Z_TRY_ADDREF_P(expr_ptr);
10972 } else if (IS_CONST == IS_CV) {
10973 ZVAL_DEREF(expr_ptr);
10974 Z_TRY_ADDREF_P(expr_ptr);
10975 } else /* if (IS_CONST == IS_VAR) */ {
10976 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
10977 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
10978
10979 expr_ptr = Z_REFVAL_P(expr_ptr);
10980 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
10981 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
10982 expr_ptr = &new_expr;
10983 efree_size(ref, sizeof(zend_reference));
10984 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
10985 Z_ADDREF_P(expr_ptr);
10986 }
10987 }
10988 }
10989 }
10990
10991 if (IS_UNUSED != IS_UNUSED) {
10992 zval *offset = NULL;
10993 zend_string *str;
10994 zend_ulong hval;
10995
10996 add_again:
10997 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
10998 str = Z_STR_P(offset);
10999 if (IS_UNUSED != IS_CONST) {
11000 if (ZEND_HANDLE_NUMERIC(str, hval)) {
11001 goto num_index;
11002 }
11003 }
11004 str_index:
11005 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
11006 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
11007 hval = Z_LVAL_P(offset);
11008 num_index:
11009 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
11010 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
11011 offset = Z_REFVAL_P(offset);
11012 goto add_again;
11013 } else if (Z_TYPE_P(offset) == IS_NULL) {
11014 str = ZSTR_EMPTY_ALLOC();
11015 goto str_index;
11016 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
11017 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
11018 goto num_index;
11019 } else if (Z_TYPE_P(offset) == IS_FALSE) {
11020 hval = 0;
11021 goto num_index;
11022 } else if (Z_TYPE_P(offset) == IS_TRUE) {
11023 hval = 1;
11024 goto num_index;
11025 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
11026 zend_use_resource_as_offset(offset);
11027 hval = Z_RES_HANDLE_P(offset);
11028 goto num_index;
11029 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
11030 ZVAL_UNDEFINED_OP2();
11031 str = ZSTR_EMPTY_ALLOC();
11032 goto str_index;
11033 } else {
11034 zend_illegal_array_offset_access(offset);
11035 zval_ptr_dtor_nogc(expr_ptr);
11036 }
11037
11038 } else {
11039 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
11040 zend_cannot_add_element();
11041 zval_ptr_dtor_nogc(expr_ptr);
11042 }
11043 }
11044 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11045 }
11046
ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11047 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11048 {
11049 zval *array;
11050 uint32_t size;
11051 USE_OPLINE
11052
11053 array = EX_VAR(opline->result.var);
11054 if (IS_CONST != IS_UNUSED) {
11055 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
11056 ZVAL_ARR(array, zend_new_array(size));
11057 /* Explicitly initialize array as not-packed if flag is set */
11058 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
11059 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
11060 }
11061 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11062 } else {
11063 ZVAL_ARR(array, zend_new_array(0));
11064 ZEND_VM_NEXT_OPCODE();
11065 }
11066 }
11067
ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11068 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11069 {
11070 USE_OPLINE
11071 zval *varname;
11072 zend_string *name, *tmp_name;
11073 HashTable *target_symbol_table;
11074
11075 SAVE_OPLINE();
11076
11077 varname = RT_CONSTANT(opline, opline->op1);
11078
11079 if (IS_CONST == IS_CONST) {
11080 name = Z_STR_P(varname);
11081 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
11082 name = Z_STR_P(varname);
11083 tmp_name = NULL;
11084 } else {
11085 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
11086 varname = ZVAL_UNDEFINED_OP1();
11087 }
11088 name = zval_try_get_tmp_string(varname, &tmp_name);
11089 if (UNEXPECTED(!name)) {
11090
11091 HANDLE_EXCEPTION();
11092 }
11093 }
11094
11095 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
11096 zend_hash_del_ind(target_symbol_table, name);
11097
11098 if (IS_CONST != IS_CONST) {
11099 zend_tmp_string_release(tmp_name);
11100 }
11101
11102 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11103 }
11104
11105 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11106 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11107 {
11108 USE_OPLINE
11109 zval *value;
11110 bool result;
11111 zval *varname;
11112 zend_string *name, *tmp_name;
11113 HashTable *target_symbol_table;
11114
11115 SAVE_OPLINE();
11116 varname = RT_CONSTANT(opline, opline->op1);
11117 if (IS_CONST == IS_CONST) {
11118 name = Z_STR_P(varname);
11119 } else {
11120 name = zval_get_tmp_string(varname, &tmp_name);
11121 }
11122
11123 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
11124 value = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
11125
11126 if (IS_CONST != IS_CONST) {
11127 zend_tmp_string_release(tmp_name);
11128 }
11129
11130 if (!value) {
11131 result = (opline->extended_value & ZEND_ISEMPTY);
11132 } else {
11133 if (Z_TYPE_P(value) == IS_INDIRECT) {
11134 value = Z_INDIRECT_P(value);
11135 }
11136 if (!(opline->extended_value & ZEND_ISEMPTY)) {
11137 if (Z_ISREF_P(value)) {
11138 value = Z_REFVAL_P(value);
11139 }
11140 result = Z_TYPE_P(value) > IS_NULL;
11141 } else {
11142 result = !i_zend_is_true(value);
11143 }
11144 }
11145
11146 ZEND_VM_SMART_BRANCH(result, true);
11147 }
11148
11149 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11150 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11151 {
11152 USE_OPLINE
11153
11154 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
11155
11156 SAVE_OPLINE();
11157 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
11158 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11159 }
11160
11161 /* Destroy the previously yielded value */
11162 zval_ptr_dtor(&generator->value);
11163
11164 /* Destroy the previously yielded key */
11165 zval_ptr_dtor(&generator->key);
11166
11167 /* Set the new yielded value */
11168 if (IS_CONST != IS_UNUSED) {
11169 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
11170 /* Constants and temporary variables aren't yieldable by reference,
11171 * but we still allow them with a notice. */
11172 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
11173 zval *value;
11174
11175 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11176
11177 value = RT_CONSTANT(opline, opline->op1);
11178 ZVAL_COPY_VALUE(&generator->value, value);
11179 if (IS_CONST == IS_CONST) {
11180 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
11181 Z_ADDREF(generator->value);
11182 }
11183 }
11184 } else {
11185 zval *value_ptr = zend_get_bad_ptr();
11186
11187 /* If a function call result is yielded and the function did
11188 * not return by reference we throw a notice. */
11189 do {
11190 if (IS_CONST == IS_VAR) {
11191 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
11192 if (opline->extended_value == ZEND_RETURNS_FUNCTION
11193 && !Z_ISREF_P(value_ptr)) {
11194 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
11195 ZVAL_COPY(&generator->value, value_ptr);
11196 break;
11197 }
11198 }
11199 if (Z_ISREF_P(value_ptr)) {
11200 Z_ADDREF_P(value_ptr);
11201 } else {
11202 ZVAL_MAKE_REF_EX(value_ptr, 2);
11203 }
11204 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
11205 } while (0);
11206
11207 }
11208 } else {
11209 zval *value = RT_CONSTANT(opline, opline->op1);
11210
11211 /* Consts, temporary variables and references need copying */
11212 if (IS_CONST == IS_CONST) {
11213 ZVAL_COPY_VALUE(&generator->value, value);
11214 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
11215 Z_ADDREF(generator->value);
11216 }
11217 } else if (IS_CONST == IS_TMP_VAR) {
11218 ZVAL_COPY_VALUE(&generator->value, value);
11219 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
11220 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
11221
11222 } else {
11223 ZVAL_COPY_VALUE(&generator->value, value);
11224 if (IS_CONST == IS_CV) {
11225 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
11226 }
11227 }
11228 }
11229 } else {
11230 /* If no value was specified yield null */
11231 ZVAL_NULL(&generator->value);
11232 }
11233
11234 /* Set the new yielded key */
11235 if (IS_UNUSED != IS_UNUSED) {
11236 zval *key = NULL;
11237 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
11238 key = Z_REFVAL_P(key);
11239 }
11240 ZVAL_COPY(&generator->key, key);
11241
11242 if (Z_TYPE(generator->key) == IS_LONG
11243 && Z_LVAL(generator->key) > generator->largest_used_integer_key
11244 ) {
11245 generator->largest_used_integer_key = Z_LVAL(generator->key);
11246 }
11247 } else {
11248 /* If no key was specified we use auto-increment keys */
11249 generator->largest_used_integer_key++;
11250 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
11251 }
11252
11253 if (RETURN_VALUE_USED(opline)) {
11254 /* If the return value of yield is used set the send
11255 * target and initialize it to NULL */
11256 generator->send_target = EX_VAR(opline->result.var);
11257 ZVAL_NULL(generator->send_target);
11258 } else {
11259 generator->send_target = NULL;
11260 }
11261
11262 /* The GOTO VM uses a local opline variable. We need to set the opline
11263 * variable in execute_data so we don't resume at an old position. */
11264 SAVE_OPLINE();
11265
11266 ZEND_VM_RETURN();
11267 }
11268
ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11269 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11270 {
11271 USE_OPLINE
11272 zval *op;
11273
11274 SAVE_OPLINE();
11275 op = RT_CONSTANT(opline, opline->op1);
11276 zend_match_unhandled_error(op);
11277 HANDLE_EXCEPTION();
11278 }
11279
ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11280 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11281 {
11282 USE_OPLINE
11283 zval *op1;
11284 zend_long count;
11285
11286 SAVE_OPLINE();
11287 op1 = RT_CONSTANT(opline, opline->op1);
11288
11289 while (1) {
11290 if (Z_TYPE_P(op1) == IS_ARRAY) {
11291 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
11292 break;
11293 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
11294 zend_object *zobj = Z_OBJ_P(op1);
11295
11296 /* first, we check if the handler is defined */
11297 if (zobj->handlers->count_elements) {
11298 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
11299 break;
11300 }
11301 if (UNEXPECTED(EG(exception))) {
11302 count = 0;
11303 break;
11304 }
11305 }
11306
11307 /* if not and the object implements Countable we call its count() method */
11308 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
11309 zval retval;
11310
11311 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
11312 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
11313 count = zval_get_long(&retval);
11314 zval_ptr_dtor(&retval);
11315 break;
11316 }
11317
11318 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
11319 } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11320 op1 = Z_REFVAL_P(op1);
11321 continue;
11322 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11323 ZVAL_UNDEFINED_OP1();
11324 }
11325 count = 0;
11326 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));
11327 break;
11328 }
11329
11330 ZVAL_LONG(EX_VAR(opline->result.var), count);
11331
11332 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11333 }
11334
ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11335 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11336 {
11337 USE_OPLINE
11338
11339 if (IS_CONST == IS_UNUSED) {
11340 SAVE_OPLINE();
11341 if (UNEXPECTED(!EX(func)->common.scope)) {
11342 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
11343 ZVAL_UNDEF(EX_VAR(opline->result.var));
11344 HANDLE_EXCEPTION();
11345 } else {
11346 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
11347 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
11348 if (UNEXPECTED(EG(exception))) {
11349 HANDLE_EXCEPTION();
11350 }
11351 ZEND_VM_NEXT_OPCODE();
11352 }
11353 } else {
11354 zval *op1;
11355
11356 SAVE_OPLINE();
11357 op1 = RT_CONSTANT(opline, opline->op1);
11358 while (1) {
11359 if (Z_TYPE_P(op1) == IS_OBJECT) {
11360 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
11361 } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11362 op1 = Z_REFVAL_P(op1);
11363 continue;
11364 } else {
11365 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11366 ZVAL_UNDEFINED_OP1();
11367 }
11368 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
11369 ZVAL_UNDEF(EX_VAR(opline->result.var));
11370 }
11371 break;
11372 }
11373
11374 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11375 }
11376 }
11377
ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11378 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11379 {
11380 USE_OPLINE
11381 zval *op1;
11382 zend_string *type;
11383
11384 SAVE_OPLINE();
11385 op1 = RT_CONSTANT(opline, opline->op1);
11386 type = zend_zval_get_legacy_type(op1);
11387 if (EXPECTED(type)) {
11388 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
11389 } else {
11390 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
11391 }
11392
11393 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11394 }
11395
ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11396 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11397 {
11398 USE_OPLINE
11399 zend_array *ht;
11400 uint32_t arg_count, result_size, skip;
11401
11402 arg_count = EX_NUM_ARGS();
11403 if (IS_CONST == IS_CONST) {
11404 skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
11405 if (arg_count < skip) {
11406 result_size = 0;
11407 } else {
11408 result_size = arg_count - skip;
11409 }
11410 } else {
11411 skip = 0;
11412 result_size = arg_count;
11413 }
11414
11415 if (result_size) {
11416 SAVE_OPLINE();
11417 uint32_t first_extra_arg = EX(func)->op_array.num_args;
11418
11419 ht = zend_new_array(result_size);
11420 ZVAL_ARR(EX_VAR(opline->result.var), ht);
11421 zend_hash_real_init_packed(ht);
11422 ZEND_HASH_FILL_PACKED(ht) {
11423 zval *p, *q;
11424 uint32_t i = skip;
11425 p = EX_VAR_NUM(i);
11426 if (arg_count > first_extra_arg) {
11427 while (i < first_extra_arg) {
11428 q = p;
11429 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11430 ZVAL_DEREF(q);
11431 if (Z_OPT_REFCOUNTED_P(q)) {
11432 Z_ADDREF_P(q);
11433 }
11434 ZEND_HASH_FILL_SET(q);
11435 } else {
11436 ZEND_HASH_FILL_SET_NULL();
11437 }
11438 ZEND_HASH_FILL_NEXT();
11439 p++;
11440 i++;
11441 }
11442 if (skip < first_extra_arg) {
11443 skip = 0;
11444 } else {
11445 skip -= first_extra_arg;
11446 }
11447 p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
11448 }
11449 while (i < arg_count) {
11450 q = p;
11451 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11452 ZVAL_DEREF(q);
11453 if (Z_OPT_REFCOUNTED_P(q)) {
11454 Z_ADDREF_P(q);
11455 }
11456 ZEND_HASH_FILL_SET(q);
11457 } else {
11458 ZEND_HASH_FILL_SET_NULL();
11459 }
11460 ZEND_HASH_FILL_NEXT();
11461 p++;
11462 i++;
11463 }
11464 } ZEND_HASH_FILL_END();
11465 ht->nNumOfElements = result_size;
11466 } else {
11467 ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
11468 }
11469 ZEND_VM_NEXT_OPCODE();
11470 }
11471
11472 /* Contrary to what its name indicates, ZEND_COPY_TMP may receive and define references. */
ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11473 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11474 {
11475 USE_OPLINE
11476 SAVE_OPLINE();
11477
11478 zend_class_entry *ce = EX(func)->common.scope;
11479 ZEND_ASSERT(ce);
11480
11481 zend_class_entry *parent_ce = ce->parent;
11482 if (!parent_ce) {
11483 zend_throw_error(NULL, "Cannot use \"parent\" when current class scope has no parent");
11484 UNDEF_RESULT();
11485 HANDLE_EXCEPTION();
11486 }
11487
11488 zend_string *property_name = Z_STR_P(RT_CONSTANT(opline, opline->op1));
11489 zend_property_hook_kind hook_kind = opline->op2.num;
11490
11491 zend_property_info *prop_info = zend_hash_find_ptr(&parent_ce->properties_info, property_name);
11492 if (!prop_info) {
11493 zend_throw_error(NULL, "Undefined property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name));
11494 UNDEF_RESULT();
11495 HANDLE_EXCEPTION();
11496 }
11497 if (prop_info->flags & ZEND_ACC_PRIVATE) {
11498 zend_throw_error(NULL, "Cannot access private property %s::$%s", ZSTR_VAL(parent_ce->name), ZSTR_VAL(property_name));
11499 UNDEF_RESULT();
11500 HANDLE_EXCEPTION();
11501 }
11502
11503 zend_function **hooks = prop_info->hooks;
11504 zend_function *hook = hooks ? hooks[hook_kind] : NULL;
11505
11506 zend_execute_data *call;
11507 if (hook) {
11508 call = zend_vm_stack_push_call_frame(
11509 ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS,
11510 hook, opline->extended_value, Z_OBJ_P(ZEND_THIS));
11511 if (EXPECTED(hook->type == ZEND_USER_FUNCTION)) {
11512 if (UNEXPECTED(!RUN_TIME_CACHE(&hook->op_array))) {
11513 init_func_run_time_cache(&hook->op_array);
11514 }
11515 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
11516 }
11517 } else {
11518 zend_function *fbc = zend_get_property_hook_trampoline(prop_info, hook_kind, property_name);
11519 call = zend_vm_stack_push_call_frame(
11520 ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS,
11521 fbc, opline->extended_value, Z_OBJ_P(ZEND_THIS));
11522 }
11523
11524 call->prev_execute_data = EX(call);
11525 EX(call) = call;
11526 ZEND_VM_NEXT_OPCODE();
11527 }
11528
ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11529 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11530 {
11531 USE_OPLINE
11532 zval *op1, *op2;
11533
11534 SAVE_OPLINE();
11535 op1 = RT_CONSTANT(opline, opline->op1);
11536 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11537 div_function(EX_VAR(opline->result.var), op1, op2);
11538
11539
11540 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11541 }
11542
ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11543 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11544 {
11545 USE_OPLINE
11546 zval *op1, *op2;
11547
11548 SAVE_OPLINE();
11549 op1 = RT_CONSTANT(opline, opline->op1);
11550 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11551 pow_function(EX_VAR(opline->result.var), op1, op2);
11552
11553
11554 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11555 }
11556
ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11557 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11558 {
11559 USE_OPLINE
11560 zval *op1, *op2;
11561
11562 op1 = RT_CONSTANT(opline, opline->op1);
11563 op2 = EX_VAR(opline->op2.var);
11564
11565 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
11566 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
11567 zend_string *op1_str = Z_STR_P(op1);
11568 zend_string *op2_str = Z_STR_P(op2);
11569 zend_string *str;
11570 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
11571
11572 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
11573 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
11574 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
11575 } else {
11576 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
11577 }
11578 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11579 zend_string_release_ex(op1_str, 0);
11580 }
11581 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
11582 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
11583 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
11584 } else {
11585 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
11586 }
11587 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11588 zend_string_release_ex(op2_str, 0);
11589 }
11590 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
11591 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
11592 size_t len = ZSTR_LEN(op1_str);
11593
11594 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
11595 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
11596 }
11597 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
11598 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11599 GC_ADD_FLAGS(str, flags);
11600 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11601 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11602 zend_string_release_ex(op2_str, 0);
11603 }
11604 } else {
11605 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
11606 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
11607 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11608 GC_ADD_FLAGS(str, flags);
11609 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11610 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11611 zend_string_release_ex(op1_str, 0);
11612 }
11613 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11614 zend_string_release_ex(op2_str, 0);
11615 }
11616 }
11617 ZEND_VM_NEXT_OPCODE();
11618 } else {
11619 SAVE_OPLINE();
11620
11621 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11622 op1 = ZVAL_UNDEFINED_OP1();
11623 }
11624 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
11625 op2 = ZVAL_UNDEFINED_OP2();
11626 }
11627 concat_function(EX_VAR(opline->result.var), op1, op2);
11628
11629
11630 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11631 }
11632 }
11633
ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11634 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11635 {
11636 USE_OPLINE
11637 zval *op1, *op2;
11638
11639 SAVE_OPLINE();
11640 op1 = RT_CONSTANT(opline, opline->op1);
11641 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11642 compare_function(EX_VAR(opline->result.var), op1, op2);
11643
11644
11645 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11646 }
11647
ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11648 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11649 {
11650 USE_OPLINE
11651 zval *container, *dim, *value;
11652
11653 SAVE_OPLINE();
11654 container = RT_CONSTANT(opline, opline->op1);
11655 dim = EX_VAR(opline->op2.var);
11656 if (IS_CONST != IS_CONST) {
11657 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11658 fetch_dim_r_array:
11659 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
11660 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
11661 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
11662 container = Z_REFVAL_P(container);
11663 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11664 goto fetch_dim_r_array;
11665 } else {
11666 goto fetch_dim_r_slow;
11667 }
11668 } else {
11669 fetch_dim_r_slow:
11670 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
11671 dim++;
11672 }
11673 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
11674 }
11675 } else {
11676 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
11677 }
11678
11679
11680 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11681 }
11682
ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11683 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11684 {
11685 USE_OPLINE
11686 zval *container;
11687
11688 SAVE_OPLINE();
11689 container = RT_CONSTANT(opline, opline->op1);
11690 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
11691
11692
11693 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11694 }
11695
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11696 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11697 {
11698 #if 0
11699 USE_OPLINE
11700 #endif
11701
11702 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
11703 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
11704 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11705 }
11706 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11707 } else {
11708 if (IS_CV == IS_UNUSED) {
11709 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11710 }
11711 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11712 }
11713 }
11714
ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11715 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11716 {
11717 USE_OPLINE
11718 zval *container;
11719 void **cache_slot = NULL;
11720
11721 SAVE_OPLINE();
11722 container = RT_CONSTANT(opline, opline->op1);
11723
11724 if (IS_CONST == IS_CONST ||
11725 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
11726 do {
11727 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
11728 container = Z_REFVAL_P(container);
11729 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
11730 break;
11731 }
11732 }
11733 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
11734 ZVAL_UNDEFINED_OP1();
11735 }
11736 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11737 ZVAL_NULL(EX_VAR(opline->result.var));
11738 goto fetch_obj_r_finish;
11739 } while (0);
11740 }
11741
11742 /* here we are sure we are dealing with an object */
11743 do {
11744 zend_object *zobj = Z_OBJ_P(container);
11745 zend_string *name, *tmp_name;
11746 zval *retval;
11747
11748 if (IS_CV == IS_CONST) {
11749 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
11750
11751 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
11752 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
11753
11754 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
11755 fetch_obj_r_simple:
11756 retval = OBJ_PROP(zobj, prop_offset);
11757 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
11758 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11759 goto fetch_obj_r_copy;
11760 } else {
11761 fetch_obj_r_fast_copy:
11762 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11763 ZEND_VM_NEXT_OPCODE();
11764 }
11765 }
11766 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
11767 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
11768 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
11769 prop_offset = prop_info->offset;
11770 goto fetch_obj_r_simple;
11771 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
11772 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
11773 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
11774 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
11775
11776 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
11777 if (IS_CONST & IS_CV) {
11778 GC_ADDREF(zobj);
11779 }
11780 if (IS_CONST & (IS_CV|IS_VAR|IS_TMP_VAR)) {
11781 call_info |= ZEND_CALL_RELEASE_THIS;
11782 }
11783 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
11784 call->prev_execute_data = execute_data;
11785 call->call = NULL;
11786 call->return_value = EX_VAR(opline->result.var);
11787 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
11788
11789 execute_data = call;
11790 EG(current_execute_data) = execute_data;
11791 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
11792
11793 #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
11794 opline = hook->op_array.opcodes;
11795 #else
11796 EX(opline) = hook->op_array.opcodes;
11797 #endif
11798 LOAD_OPLINE_EX();
11799
11800
11801 ZEND_VM_ENTER_EX();
11802 }
11803 /* Fall through to read_property for hooks. */
11804 } else if (EXPECTED(zobj->properties != NULL)) {
11805 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
11806 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11807 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
11808 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
11809
11810 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
11811 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
11812
11813 if (EXPECTED(p->key == name) ||
11814 (EXPECTED(p->h == ZSTR_H(name)) &&
11815 EXPECTED(p->key != NULL) &&
11816 EXPECTED(zend_string_equal_content(p->key, name)))) {
11817 retval = &p->val;
11818 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11819 goto fetch_obj_r_copy;
11820 } else {
11821 goto fetch_obj_r_fast_copy;
11822 }
11823 }
11824 }
11825 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
11826 }
11827 retval = zend_hash_find_known_hash(zobj->properties, name);
11828 if (EXPECTED(retval)) {
11829 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
11830 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
11831 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11832 goto fetch_obj_r_copy;
11833 } else {
11834 goto fetch_obj_r_fast_copy;
11835 }
11836 }
11837 }
11838 }
11839 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11840 } else {
11841 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
11842 if (UNEXPECTED(!name)) {
11843 ZVAL_UNDEF(EX_VAR(opline->result.var));
11844 break;
11845 }
11846 }
11847
11848 #if ZEND_DEBUG
11849 /* For non-standard object handlers, verify a declared property type in debug builds.
11850 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
11851 zend_property_info *prop_info = NULL;
11852 if (zobj->handlers->read_property != zend_std_read_property) {
11853 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
11854 }
11855 #endif
11856 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
11857 #if ZEND_DEBUG
11858 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
11859 && ZEND_TYPE_IS_SET(prop_info->type)) {
11860 ZVAL_OPT_DEREF(retval);
11861 zend_verify_property_type(prop_info, retval, /* strict */ true);
11862 }
11863 #endif
11864
11865 if (IS_CV != IS_CONST) {
11866 zend_tmp_string_release(tmp_name);
11867 }
11868
11869 if (retval != EX_VAR(opline->result.var)) {
11870 fetch_obj_r_copy:
11871 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11872 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
11873 zend_unwrap_reference(retval);
11874 }
11875 } while (0);
11876
11877 fetch_obj_r_finish:
11878
11879
11880 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11881 }
11882
ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11883 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11884 {
11885 USE_OPLINE
11886 zval *container;
11887 void **cache_slot = NULL;
11888
11889 SAVE_OPLINE();
11890 container = RT_CONSTANT(opline, opline->op1);
11891
11892 if (IS_CONST == IS_CONST ||
11893 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
11894 do {
11895 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
11896 container = Z_REFVAL_P(container);
11897 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
11898 break;
11899 }
11900 }
11901 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
11902 ZVAL_UNDEFINED_OP2();
11903 }
11904 ZVAL_NULL(EX_VAR(opline->result.var));
11905 goto fetch_obj_is_finish;
11906 } while (0);
11907 }
11908
11909 /* here we are sure we are dealing with an object */
11910 do {
11911 zend_object *zobj = Z_OBJ_P(container);
11912 zend_string *name, *tmp_name;
11913 zval *retval;
11914
11915 if (IS_CV == IS_CONST) {
11916 cache_slot = CACHE_ADDR(opline->extended_value);
11917
11918 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
11919 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
11920
11921 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
11922 fetch_obj_is_simple:
11923 retval = OBJ_PROP(zobj, prop_offset);
11924 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
11925 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11926 goto fetch_obj_is_copy;
11927 } else {
11928 fetch_obj_is_fast_copy:
11929 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11930 ZEND_VM_NEXT_OPCODE();
11931 }
11932 }
11933 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
11934 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
11935 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
11936 prop_offset = prop_info->offset;
11937 goto fetch_obj_is_simple;
11938 }
11939 /* Fall through to read_property for hooks. */
11940 } else if (EXPECTED(zobj->properties != NULL)) {
11941 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
11942 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11943 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
11944 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
11945
11946 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
11947 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
11948
11949 if (EXPECTED(p->key == name) ||
11950 (EXPECTED(p->h == ZSTR_H(name)) &&
11951 EXPECTED(p->key != NULL) &&
11952 EXPECTED(zend_string_equal_content(p->key, name)))) {
11953 retval = &p->val;
11954 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11955 goto fetch_obj_is_copy;
11956 } else {
11957 goto fetch_obj_is_fast_copy;
11958 }
11959 }
11960 }
11961 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
11962 }
11963 retval = zend_hash_find_known_hash(zobj->properties, name);
11964 if (EXPECTED(retval)) {
11965 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
11966 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
11967 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11968 goto fetch_obj_is_copy;
11969 } else {
11970 goto fetch_obj_is_fast_copy;
11971 }
11972 }
11973 }
11974 }
11975 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11976 } else {
11977 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
11978 if (UNEXPECTED(!name)) {
11979 ZVAL_UNDEF(EX_VAR(opline->result.var));
11980 break;
11981 }
11982 }
11983
11984 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
11985
11986 if (IS_CV != IS_CONST) {
11987 zend_tmp_string_release(tmp_name);
11988 }
11989
11990 if (retval != EX_VAR(opline->result.var)) {
11991 fetch_obj_is_copy:
11992 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11993 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
11994 zend_unwrap_reference(retval);
11995 }
11996 } while (0);
11997
11998 fetch_obj_is_finish:
11999
12000
12001 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12002 }
12003
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12004 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12005 {
12006 #if 0
12007 USE_OPLINE
12008 #endif
12009
12010 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
12011 /* Behave like FETCH_OBJ_W */
12012 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
12013 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12014 }
12015 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12016 } else {
12017 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12018 }
12019 }
12020
ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12021 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12022 {
12023 USE_OPLINE
12024 zval *container;
12025
12026 SAVE_OPLINE();
12027 container = RT_CONSTANT(opline, opline->op1);
12028 zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
12029
12030 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12031 }
12032
ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12033 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12034 {
12035 USE_OPLINE
12036 zval *op1, *op2;
12037 zend_string *op1_str, *op2_str, *str;
12038
12039
12040 op1 = RT_CONSTANT(opline, opline->op1);
12041 op2 = EX_VAR(opline->op2.var);
12042 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
12043 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
12044 zend_string *op1_str = Z_STR_P(op1);
12045 zend_string *op2_str = Z_STR_P(op2);
12046 zend_string *str;
12047 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
12048
12049 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
12050 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
12051 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
12052 } else {
12053 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
12054 }
12055 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
12056 zend_string_release_ex(op1_str, 0);
12057 }
12058 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
12059 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
12060 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
12061 } else {
12062 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
12063 }
12064 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12065 zend_string_release_ex(op2_str, 0);
12066 }
12067 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
12068 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
12069 size_t len = ZSTR_LEN(op1_str);
12070
12071 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
12072 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12073 GC_ADD_FLAGS(str, flags);
12074 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12075 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12076 zend_string_release_ex(op2_str, 0);
12077 }
12078 } else {
12079 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
12080 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
12081 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12082 GC_ADD_FLAGS(str, flags);
12083 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12084 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
12085 zend_string_release_ex(op1_str, 0);
12086 }
12087 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
12088 zend_string_release_ex(op2_str, 0);
12089 }
12090 }
12091 ZEND_VM_NEXT_OPCODE();
12092 }
12093
12094 SAVE_OPLINE();
12095 if (IS_CONST == IS_CONST) {
12096 op1_str = Z_STR_P(op1);
12097 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
12098 op1_str = zend_string_copy(Z_STR_P(op1));
12099 } else {
12100 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
12101 ZVAL_UNDEFINED_OP1();
12102 }
12103 op1_str = zval_get_string_func(op1);
12104 }
12105 if (IS_CV == IS_CONST) {
12106 op2_str = Z_STR_P(op2);
12107 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
12108 op2_str = zend_string_copy(Z_STR_P(op2));
12109 } else {
12110 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
12111 ZVAL_UNDEFINED_OP2();
12112 }
12113 op2_str = zval_get_string_func(op2);
12114 }
12115 do {
12116 if (IS_CONST != IS_CONST) {
12117 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
12118 if (IS_CV == IS_CONST) {
12119 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
12120 GC_ADDREF(op2_str);
12121 }
12122 }
12123 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
12124 zend_string_release_ex(op1_str, 0);
12125 break;
12126 }
12127 }
12128 if (IS_CV != IS_CONST) {
12129 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
12130 if (IS_CONST == IS_CONST) {
12131 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
12132 GC_ADDREF(op1_str);
12133 }
12134 }
12135 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
12136 zend_string_release_ex(op2_str, 0);
12137 break;
12138 }
12139 }
12140 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
12141 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
12142 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
12143
12144 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
12145 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
12146 if (IS_CONST != IS_CONST) {
12147 zend_string_release_ex(op1_str, 0);
12148 }
12149 if (IS_CV != IS_CONST) {
12150 zend_string_release_ex(op2_str, 0);
12151 }
12152 } while (0);
12153
12154
12155 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12156 }
12157
ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12158 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12159 {
12160 USE_OPLINE
12161 zval *function_name;
12162 zval *object;
12163 zend_function *fbc;
12164 zend_class_entry *called_scope;
12165 zend_object *obj;
12166 zend_execute_data *call;
12167 uint32_t call_info;
12168
12169 SAVE_OPLINE();
12170
12171 object = RT_CONSTANT(opline, opline->op1);
12172
12173 if (IS_CV != IS_CONST) {
12174 function_name = EX_VAR(opline->op2.var);
12175 }
12176
12177 if (IS_CV != IS_CONST &&
12178 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
12179 do {
12180 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
12181 function_name = Z_REFVAL_P(function_name);
12182 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
12183 break;
12184 }
12185 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
12186 ZVAL_UNDEFINED_OP2();
12187 if (UNEXPECTED(EG(exception) != NULL)) {
12188
12189 HANDLE_EXCEPTION();
12190 }
12191 }
12192 zend_throw_error(NULL, "Method name must be a string");
12193
12194
12195 HANDLE_EXCEPTION();
12196 } while (0);
12197 }
12198
12199 if (IS_CONST == IS_UNUSED) {
12200 obj = Z_OBJ_P(object);
12201 } else {
12202 do {
12203 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
12204 obj = Z_OBJ_P(object);
12205 } else {
12206 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
12207 zend_reference *ref = Z_REF_P(object);
12208
12209 object = &ref->val;
12210 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
12211 obj = Z_OBJ_P(object);
12212 if (IS_CONST & IS_VAR) {
12213 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
12214 efree_size(ref, sizeof(zend_reference));
12215 } else {
12216 Z_ADDREF_P(object);
12217 }
12218 }
12219 break;
12220 }
12221 }
12222 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
12223 object = ZVAL_UNDEFINED_OP1();
12224 if (UNEXPECTED(EG(exception) != NULL)) {
12225 if (IS_CV != IS_CONST) {
12226
12227 }
12228 HANDLE_EXCEPTION();
12229 }
12230 }
12231 if (IS_CV == IS_CONST) {
12232 function_name = EX_VAR(opline->op2.var);
12233 }
12234 zend_invalid_method_call(object, function_name);
12235
12236
12237 HANDLE_EXCEPTION();
12238 }
12239 } while (0);
12240 }
12241
12242 called_scope = obj->ce;
12243
12244 if (IS_CV == IS_CONST &&
12245 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
12246 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
12247 } else {
12248 zend_object *orig_obj = obj;
12249
12250 if (IS_CV == IS_CONST) {
12251 function_name = EX_VAR(opline->op2.var);
12252 }
12253
12254 /* First, locate the function. */
12255 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
12256 if (UNEXPECTED(fbc == NULL)) {
12257 if (EXPECTED(!EG(exception))) {
12258 zend_undefined_method(obj->ce, Z_STR_P(function_name));
12259 }
12260
12261 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
12262 zend_objects_store_del(orig_obj);
12263 }
12264 HANDLE_EXCEPTION();
12265 }
12266 if (IS_CV == IS_CONST &&
12267 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
12268 EXPECTED(obj == orig_obj)) {
12269 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
12270 }
12271 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
12272 GC_ADDREF(obj); /* For $this pointer */
12273 if (GC_DELREF(orig_obj) == 0) {
12274 zend_objects_store_del(orig_obj);
12275 }
12276 }
12277 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12278 init_func_run_time_cache(&fbc->op_array);
12279 }
12280 }
12281
12282 if (IS_CV != IS_CONST) {
12283
12284 }
12285
12286 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
12287 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
12288 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
12289 zend_objects_store_del(obj);
12290 if (UNEXPECTED(EG(exception))) {
12291 HANDLE_EXCEPTION();
12292 }
12293 }
12294 /* call static method */
12295 obj = (zend_object*)called_scope;
12296 call_info = ZEND_CALL_NESTED_FUNCTION;
12297 } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
12298 if (IS_CONST == IS_CV) {
12299 GC_ADDREF(obj); /* For $this pointer */
12300 }
12301 /* CV may be changed indirectly (e.g. when it's a reference) */
12302 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
12303 }
12304
12305 call = zend_vm_stack_push_call_frame(call_info,
12306 fbc, opline->extended_value, obj);
12307 call->prev_execute_data = EX(call);
12308 EX(call) = call;
12309
12310 ZEND_VM_NEXT_OPCODE();
12311 }
12312
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12313 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12314 {
12315 USE_OPLINE
12316 zval *function_name;
12317 zend_class_entry *ce;
12318 uint32_t call_info;
12319 zend_function *fbc;
12320 zend_execute_data *call;
12321
12322 SAVE_OPLINE();
12323
12324 if (IS_CONST == IS_CONST) {
12325 /* no function found. try a static method in class */
12326 ce = CACHED_PTR(opline->result.num);
12327 if (UNEXPECTED(ce == NULL)) {
12328 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);
12329 if (UNEXPECTED(ce == NULL)) {
12330
12331 HANDLE_EXCEPTION();
12332 }
12333 if (IS_CV != IS_CONST) {
12334 CACHE_PTR(opline->result.num, ce);
12335 }
12336 }
12337 } else if (IS_CONST == IS_UNUSED) {
12338 ce = zend_fetch_class(NULL, opline->op1.num);
12339 if (UNEXPECTED(ce == NULL)) {
12340
12341 HANDLE_EXCEPTION();
12342 }
12343 } else {
12344 ce = Z_CE_P(EX_VAR(opline->op1.var));
12345 }
12346
12347 if (IS_CONST == IS_CONST &&
12348 IS_CV == IS_CONST &&
12349 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
12350 /* nothing to do */
12351 } else if (IS_CONST != IS_CONST &&
12352 IS_CV == IS_CONST &&
12353 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
12354 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
12355 } else if (IS_CV != IS_UNUSED) {
12356 function_name = EX_VAR(opline->op2.var);
12357 if (IS_CV != IS_CONST) {
12358 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
12359 do {
12360 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
12361 function_name = Z_REFVAL_P(function_name);
12362 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
12363 break;
12364 }
12365 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
12366 ZVAL_UNDEFINED_OP2();
12367 if (UNEXPECTED(EG(exception) != NULL)) {
12368 HANDLE_EXCEPTION();
12369 }
12370 }
12371 zend_throw_error(NULL, "Method name must be a string");
12372
12373 HANDLE_EXCEPTION();
12374 } while (0);
12375 }
12376 }
12377
12378 if (ce->get_static_method) {
12379 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
12380 } else {
12381 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
12382 }
12383 if (UNEXPECTED(fbc == NULL)) {
12384 if (EXPECTED(!EG(exception))) {
12385 zend_undefined_method(ce, Z_STR_P(function_name));
12386 }
12387
12388 HANDLE_EXCEPTION();
12389 }
12390 if (IS_CV == IS_CONST &&
12391 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
12392 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
12393 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
12394 }
12395 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12396 init_func_run_time_cache(&fbc->op_array);
12397 }
12398 if (IS_CV != IS_CONST) {
12399
12400 }
12401 } else {
12402 if (UNEXPECTED(ce->constructor == NULL)) {
12403 zend_throw_error(NULL, "Cannot call constructor");
12404 HANDLE_EXCEPTION();
12405 }
12406 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
12407 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
12408 HANDLE_EXCEPTION();
12409 }
12410 fbc = ce->constructor;
12411 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12412 init_func_run_time_cache(&fbc->op_array);
12413 }
12414 }
12415
12416 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
12417 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
12418 ce = (zend_class_entry*)Z_OBJ(EX(This));
12419 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
12420 } else {
12421 zend_non_static_method_call(fbc);
12422 HANDLE_EXCEPTION();
12423 }
12424 } else {
12425 /* previous opcode is ZEND_FETCH_CLASS */
12426 if (IS_CONST == IS_UNUSED
12427 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
12428 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
12429 if (Z_TYPE(EX(This)) == IS_OBJECT) {
12430 ce = Z_OBJCE(EX(This));
12431 } else {
12432 ce = Z_CE(EX(This));
12433 }
12434 }
12435 call_info = ZEND_CALL_NESTED_FUNCTION;
12436 }
12437
12438 call = zend_vm_stack_push_call_frame(call_info,
12439 fbc, opline->extended_value, ce);
12440 call->prev_execute_data = EX(call);
12441 EX(call) = call;
12442
12443 ZEND_VM_NEXT_OPCODE();
12444 }
12445
ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12446 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12447 {
12448 USE_OPLINE
12449 zval *function_name;
12450 zend_fcall_info_cache fcc;
12451 char *error = NULL;
12452 zend_function *func;
12453 void *object_or_called_scope;
12454 zend_execute_data *call;
12455 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
12456
12457 SAVE_OPLINE();
12458 function_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12459 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
12460 ZEND_ASSERT(!error);
12461 func = fcc.function_handler;
12462 object_or_called_scope = fcc.called_scope;
12463 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
12464 /* Delay closure destruction until its invocation */
12465 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
12466 call_info |= ZEND_CALL_CLOSURE;
12467 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
12468 call_info |= ZEND_CALL_FAKE_CLOSURE;
12469 }
12470 if (fcc.object) {
12471 object_or_called_scope = fcc.object;
12472 call_info |= ZEND_CALL_HAS_THIS;
12473 }
12474 } else if (fcc.object) {
12475 GC_ADDREF(fcc.object); /* For $this pointer */
12476 object_or_called_scope = fcc.object;
12477 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
12478 }
12479
12480 if ((IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
12481 if (call_info & ZEND_CALL_CLOSURE) {
12482 zend_object_release(ZEND_CLOSURE_OBJECT(func));
12483 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
12484 zend_object_release(fcc.object);
12485 }
12486 HANDLE_EXCEPTION();
12487 }
12488
12489 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
12490 init_func_run_time_cache(&func->op_array);
12491 }
12492 } else {
12493 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
12494 efree(error);
12495
12496 HANDLE_EXCEPTION();
12497 }
12498
12499 call = zend_vm_stack_push_call_frame(call_info,
12500 func, opline->extended_value, object_or_called_scope);
12501 call->prev_execute_data = EX(call);
12502 EX(call) = call;
12503
12504 ZEND_VM_NEXT_OPCODE();
12505 }
12506
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12507 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12508 {
12509 USE_OPLINE
12510 zval *expr_ptr, new_expr;
12511
12512 SAVE_OPLINE();
12513 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
12514 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
12515 expr_ptr = zend_get_bad_ptr();
12516 if (Z_ISREF_P(expr_ptr)) {
12517 Z_ADDREF_P(expr_ptr);
12518 } else {
12519 ZVAL_MAKE_REF_EX(expr_ptr, 2);
12520 }
12521
12522 } else {
12523 expr_ptr = RT_CONSTANT(opline, opline->op1);
12524 if (IS_CONST == IS_TMP_VAR) {
12525 /* pass */
12526 } else if (IS_CONST == IS_CONST) {
12527 Z_TRY_ADDREF_P(expr_ptr);
12528 } else if (IS_CONST == IS_CV) {
12529 ZVAL_DEREF(expr_ptr);
12530 Z_TRY_ADDREF_P(expr_ptr);
12531 } else /* if (IS_CONST == IS_VAR) */ {
12532 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
12533 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
12534
12535 expr_ptr = Z_REFVAL_P(expr_ptr);
12536 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
12537 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
12538 expr_ptr = &new_expr;
12539 efree_size(ref, sizeof(zend_reference));
12540 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
12541 Z_ADDREF_P(expr_ptr);
12542 }
12543 }
12544 }
12545 }
12546
12547 if (IS_CV != IS_UNUSED) {
12548 zval *offset = EX_VAR(opline->op2.var);
12549 zend_string *str;
12550 zend_ulong hval;
12551
12552 add_again:
12553 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12554 str = Z_STR_P(offset);
12555 if (IS_CV != IS_CONST) {
12556 if (ZEND_HANDLE_NUMERIC(str, hval)) {
12557 goto num_index;
12558 }
12559 }
12560 str_index:
12561 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
12562 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12563 hval = Z_LVAL_P(offset);
12564 num_index:
12565 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
12566 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
12567 offset = Z_REFVAL_P(offset);
12568 goto add_again;
12569 } else if (Z_TYPE_P(offset) == IS_NULL) {
12570 str = ZSTR_EMPTY_ALLOC();
12571 goto str_index;
12572 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
12573 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
12574 goto num_index;
12575 } else if (Z_TYPE_P(offset) == IS_FALSE) {
12576 hval = 0;
12577 goto num_index;
12578 } else if (Z_TYPE_P(offset) == IS_TRUE) {
12579 hval = 1;
12580 goto num_index;
12581 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
12582 zend_use_resource_as_offset(offset);
12583 hval = Z_RES_HANDLE_P(offset);
12584 goto num_index;
12585 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
12586 ZVAL_UNDEFINED_OP2();
12587 str = ZSTR_EMPTY_ALLOC();
12588 goto str_index;
12589 } else {
12590 zend_illegal_array_offset_access(offset);
12591 zval_ptr_dtor_nogc(expr_ptr);
12592 }
12593
12594 } else {
12595 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
12596 zend_cannot_add_element();
12597 zval_ptr_dtor_nogc(expr_ptr);
12598 }
12599 }
12600 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12601 }
12602
ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12603 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12604 {
12605 zval *array;
12606 uint32_t size;
12607 USE_OPLINE
12608
12609 array = EX_VAR(opline->result.var);
12610 if (IS_CONST != IS_UNUSED) {
12611 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
12612 ZVAL_ARR(array, zend_new_array(size));
12613 /* Explicitly initialize array as not-packed if flag is set */
12614 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
12615 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
12616 }
12617 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12618 } else {
12619 ZVAL_ARR(array, zend_new_array(0));
12620 ZEND_VM_NEXT_OPCODE();
12621 }
12622 }
12623
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12624 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12625 {
12626 USE_OPLINE
12627 zval *container;
12628 bool result;
12629 zend_ulong hval;
12630 zval *offset;
12631
12632 SAVE_OPLINE();
12633 container = RT_CONSTANT(opline, opline->op1);
12634 offset = EX_VAR(opline->op2.var);
12635
12636 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12637 HashTable *ht;
12638 zval *value;
12639 zend_string *str;
12640
12641 isset_dim_obj_array:
12642 ht = Z_ARRVAL_P(container);
12643 isset_again:
12644 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12645 str = Z_STR_P(offset);
12646 if (IS_CV != IS_CONST) {
12647 if (ZEND_HANDLE_NUMERIC(str, hval)) {
12648 goto num_index_prop;
12649 }
12650 }
12651 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
12652 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12653 hval = Z_LVAL_P(offset);
12654 num_index_prop:
12655 value = zend_hash_index_find(ht, hval);
12656 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
12657 offset = Z_REFVAL_P(offset);
12658 goto isset_again;
12659 } else {
12660 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
12661 if (UNEXPECTED(EG(exception))) {
12662 result = 0;
12663 goto isset_dim_obj_exit;
12664 }
12665 }
12666
12667 if (!(opline->extended_value & ZEND_ISEMPTY)) {
12668 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
12669 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
12670 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
12671
12672 if (IS_CONST & (IS_CONST|IS_CV)) {
12673 /* avoid exception check */
12674
12675 ZEND_VM_SMART_BRANCH(result, 0);
12676 }
12677 } else {
12678 result = (value == NULL || !i_zend_is_true(value));
12679 }
12680 goto isset_dim_obj_exit;
12681 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
12682 container = Z_REFVAL_P(container);
12683 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12684 goto isset_dim_obj_array;
12685 }
12686 }
12687
12688 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
12689 offset++;
12690 }
12691 if (!(opline->extended_value & ZEND_ISEMPTY)) {
12692 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
12693 } else {
12694 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
12695 }
12696
12697 isset_dim_obj_exit:
12698
12699
12700 ZEND_VM_SMART_BRANCH(result, 1);
12701 }
12702
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12703 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12704 {
12705 USE_OPLINE
12706 zval *container;
12707 int result;
12708 zval *offset;
12709 zend_string *name, *tmp_name;
12710
12711 SAVE_OPLINE();
12712 container = RT_CONSTANT(opline, opline->op1);
12713 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12714
12715 if (IS_CONST == IS_CONST ||
12716 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
12717 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
12718 container = Z_REFVAL_P(container);
12719 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
12720 result = (opline->extended_value & ZEND_ISEMPTY);
12721 goto isset_object_finish;
12722 }
12723 } else {
12724 result = (opline->extended_value & ZEND_ISEMPTY);
12725 goto isset_object_finish;
12726 }
12727 }
12728
12729 if (IS_CV == IS_CONST) {
12730 name = Z_STR_P(offset);
12731 } else {
12732 name = zval_try_get_tmp_string(offset, &tmp_name);
12733 if (UNEXPECTED(!name)) {
12734 result = 0;
12735 goto isset_object_finish;
12736 }
12737 }
12738
12739 result =
12740 (opline->extended_value & ZEND_ISEMPTY) ^
12741 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));
12742
12743 if (IS_CV != IS_CONST) {
12744 zend_tmp_string_release(tmp_name);
12745 }
12746
12747 isset_object_finish:
12748
12749
12750 ZEND_VM_SMART_BRANCH(result, 1);
12751 }
12752
ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12753 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12754 {
12755 USE_OPLINE
12756
12757 zval *key, *subject;
12758 HashTable *ht;
12759 bool result;
12760
12761 SAVE_OPLINE();
12762
12763 key = RT_CONSTANT(opline, opline->op1);
12764 subject = EX_VAR(opline->op2.var);
12765
12766 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12767 array_key_exists_array:
12768 ht = Z_ARRVAL_P(subject);
12769 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
12770 } else {
12771 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
12772 subject = Z_REFVAL_P(subject);
12773 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12774 goto array_key_exists_array;
12775 }
12776 }
12777 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
12778 result = 0;
12779 }
12780
12781
12782 ZEND_VM_SMART_BRANCH(result, 1);
12783 }
12784
ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12785 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12786 {
12787 USE_OPLINE
12788
12789 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
12790
12791 SAVE_OPLINE();
12792 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
12793 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12794 }
12795
12796 /* Destroy the previously yielded value */
12797 zval_ptr_dtor(&generator->value);
12798
12799 /* Destroy the previously yielded key */
12800 zval_ptr_dtor(&generator->key);
12801
12802 /* Set the new yielded value */
12803 if (IS_CONST != IS_UNUSED) {
12804 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
12805 /* Constants and temporary variables aren't yieldable by reference,
12806 * but we still allow them with a notice. */
12807 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
12808 zval *value;
12809
12810 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12811
12812 value = RT_CONSTANT(opline, opline->op1);
12813 ZVAL_COPY_VALUE(&generator->value, value);
12814 if (IS_CONST == IS_CONST) {
12815 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12816 Z_ADDREF(generator->value);
12817 }
12818 }
12819 } else {
12820 zval *value_ptr = zend_get_bad_ptr();
12821
12822 /* If a function call result is yielded and the function did
12823 * not return by reference we throw a notice. */
12824 do {
12825 if (IS_CONST == IS_VAR) {
12826 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
12827 if (opline->extended_value == ZEND_RETURNS_FUNCTION
12828 && !Z_ISREF_P(value_ptr)) {
12829 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12830 ZVAL_COPY(&generator->value, value_ptr);
12831 break;
12832 }
12833 }
12834 if (Z_ISREF_P(value_ptr)) {
12835 Z_ADDREF_P(value_ptr);
12836 } else {
12837 ZVAL_MAKE_REF_EX(value_ptr, 2);
12838 }
12839 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
12840 } while (0);
12841
12842 }
12843 } else {
12844 zval *value = RT_CONSTANT(opline, opline->op1);
12845
12846 /* Consts, temporary variables and references need copying */
12847 if (IS_CONST == IS_CONST) {
12848 ZVAL_COPY_VALUE(&generator->value, value);
12849 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12850 Z_ADDREF(generator->value);
12851 }
12852 } else if (IS_CONST == IS_TMP_VAR) {
12853 ZVAL_COPY_VALUE(&generator->value, value);
12854 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
12855 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
12856
12857 } else {
12858 ZVAL_COPY_VALUE(&generator->value, value);
12859 if (IS_CONST == IS_CV) {
12860 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
12861 }
12862 }
12863 }
12864 } else {
12865 /* If no value was specified yield null */
12866 ZVAL_NULL(&generator->value);
12867 }
12868
12869 /* Set the new yielded key */
12870 if (IS_CV != IS_UNUSED) {
12871 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12872 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
12873 key = Z_REFVAL_P(key);
12874 }
12875 ZVAL_COPY(&generator->key, key);
12876
12877 if (Z_TYPE(generator->key) == IS_LONG
12878 && Z_LVAL(generator->key) > generator->largest_used_integer_key
12879 ) {
12880 generator->largest_used_integer_key = Z_LVAL(generator->key);
12881 }
12882 } else {
12883 /* If no key was specified we use auto-increment keys */
12884 generator->largest_used_integer_key++;
12885 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
12886 }
12887
12888 if (RETURN_VALUE_USED(opline)) {
12889 /* If the return value of yield is used set the send
12890 * target and initialize it to NULL */
12891 generator->send_target = EX_VAR(opline->result.var);
12892 ZVAL_NULL(generator->send_target);
12893 } else {
12894 generator->send_target = NULL;
12895 }
12896
12897 /* The GOTO VM uses a local opline variable. We need to set the opline
12898 * variable in execute_data so we don't resume at an old position. */
12899 SAVE_OPLINE();
12900
12901 ZEND_VM_RETURN();
12902 }
12903
ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12904 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12905 {
12906 USE_OPLINE
12907 zval *op1;
12908
12909 op1 = EX_VAR(opline->op1.var);
12910 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12911 ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
12912 ZEND_VM_NEXT_OPCODE();
12913 }
12914
12915 ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(op1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12916 }
12917
ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12918 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12919 {
12920 USE_OPLINE
12921 zval *value;
12922
12923 value = EX_VAR(opline->op1.var);
12924 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
12925 ZEND_VM_NEXT_OPCODE();
12926 }
12927
ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12928 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12929 {
12930 USE_OPLINE
12931 zval *value;
12932
12933 value = EX_VAR(opline->op1.var);
12934 ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
12935 ZEND_VM_NEXT_OPCODE();
12936 }
12937
ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12938 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12939 {
12940 USE_OPLINE
12941 zval *value;
12942
12943 value = EX_VAR(opline->op1.var);
12944 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
12945 ZEND_VM_NEXT_OPCODE();
12946 }
12947
ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12948 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12949 {
12950 USE_OPLINE
12951 zval *op1, *op2, *result;
12952 double d1, d2;
12953
12954 op1 = EX_VAR(opline->op1.var);
12955 op2 = RT_CONSTANT(opline, opline->op2);
12956 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12957 /* pass */
12958 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12959 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12960 result = EX_VAR(opline->result.var);
12961 fast_long_add_function(result, op1, op2);
12962 ZEND_VM_NEXT_OPCODE();
12963 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12964 d1 = (double)Z_LVAL_P(op1);
12965 d2 = Z_DVAL_P(op2);
12966 goto add_double;
12967 }
12968 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12969 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12970 d1 = Z_DVAL_P(op1);
12971 d2 = Z_DVAL_P(op2);
12972 add_double:
12973 result = EX_VAR(opline->result.var);
12974 ZVAL_DOUBLE(result, d1 + d2);
12975 ZEND_VM_NEXT_OPCODE();
12976 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12977 d1 = Z_DVAL_P(op1);
12978 d2 = (double)Z_LVAL_P(op2);
12979 goto add_double;
12980 }
12981 }
12982
12983 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12984 }
12985
ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12986 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12987 {
12988 USE_OPLINE
12989 zval *op1, *op2, *result;
12990 double d1, d2;
12991
12992 op1 = EX_VAR(opline->op1.var);
12993 op2 = RT_CONSTANT(opline, opline->op2);
12994 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12995 /* pass */
12996 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12997 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12998 result = EX_VAR(opline->result.var);
12999 fast_long_sub_function(result, op1, op2);
13000 ZEND_VM_NEXT_OPCODE();
13001 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13002 d1 = (double)Z_LVAL_P(op1);
13003 d2 = Z_DVAL_P(op2);
13004 goto sub_double;
13005 }
13006 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13007 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13008 d1 = Z_DVAL_P(op1);
13009 d2 = Z_DVAL_P(op2);
13010 sub_double:
13011 result = EX_VAR(opline->result.var);
13012 ZVAL_DOUBLE(result, d1 - d2);
13013 ZEND_VM_NEXT_OPCODE();
13014 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13015 d1 = Z_DVAL_P(op1);
13016 d2 = (double)Z_LVAL_P(op2);
13017 goto sub_double;
13018 }
13019 }
13020
13021 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13022 }
13023
ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13024 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13025 {
13026 USE_OPLINE
13027 zval *op1, *op2, *result;
13028 double d1, d2;
13029
13030 op1 = EX_VAR(opline->op1.var);
13031 op2 = RT_CONSTANT(opline, opline->op2);
13032 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13033 /* pass */
13034 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13035 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13036 zend_long overflow;
13037
13038 result = EX_VAR(opline->result.var);
13039 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13040 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13041 ZEND_VM_NEXT_OPCODE();
13042 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13043 d1 = (double)Z_LVAL_P(op1);
13044 d2 = Z_DVAL_P(op2);
13045 goto mul_double;
13046 }
13047 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13048 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13049 d1 = Z_DVAL_P(op1);
13050 d2 = Z_DVAL_P(op2);
13051 mul_double:
13052 result = EX_VAR(opline->result.var);
13053 ZVAL_DOUBLE(result, d1 * d2);
13054 ZEND_VM_NEXT_OPCODE();
13055 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13056 d1 = Z_DVAL_P(op1);
13057 d2 = (double)Z_LVAL_P(op2);
13058 goto mul_double;
13059 }
13060 }
13061
13062 ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13063 }
13064
ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13065 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13066 {
13067 USE_OPLINE
13068 zval *op1, *op2, *result;
13069
13070 op1 = EX_VAR(opline->op1.var);
13071 op2 = RT_CONSTANT(opline, opline->op2);
13072 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13073 /* pass */
13074 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13075 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13076 result = EX_VAR(opline->result.var);
13077 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
13078 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
13079 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
13080 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
13081 ZVAL_LONG(result, 0);
13082 } else {
13083 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
13084 }
13085 ZEND_VM_NEXT_OPCODE();
13086 }
13087 }
13088
13089 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13090 }
13091
ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13092 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13093 {
13094 USE_OPLINE
13095 zval *op1, *op2;
13096
13097 op1 = EX_VAR(opline->op1.var);
13098 op2 = RT_CONSTANT(opline, opline->op2);
13099 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13100 /* pass */
13101 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13102 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13103 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13104 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
13105 ZVAL_LONG(EX_VAR(opline->result.var),
13106 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
13107 ZEND_VM_NEXT_OPCODE();
13108 }
13109
13110 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13111 }
13112
ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13113 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13114 {
13115 USE_OPLINE
13116 zval *op1, *op2;
13117
13118 op1 = EX_VAR(opline->op1.var);
13119 op2 = RT_CONSTANT(opline, opline->op2);
13120 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13121 /* pass */
13122 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13123 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13124 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13125 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
13126 ZEND_VM_NEXT_OPCODE();
13127 }
13128
13129 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13130 }
13131
ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13132 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13133 {
13134 USE_OPLINE
13135 zval *op1, *op2;
13136 double d1, d2;
13137
13138 op1 = EX_VAR(opline->op1.var);
13139 op2 = RT_CONSTANT(opline, opline->op2);
13140 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13141 /* pass */
13142 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13143 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13144 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13145 is_smaller_true:
13146 ZEND_VM_SMART_BRANCH_TRUE_NONE();
13147 } else {
13148 is_smaller_false:
13149 ZEND_VM_SMART_BRANCH_FALSE_NONE();
13150 }
13151 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13152 d1 = (double)Z_LVAL_P(op1);
13153 d2 = Z_DVAL_P(op2);
13154 goto is_smaller_double;
13155 }
13156 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13157 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13158 d1 = Z_DVAL_P(op1);
13159 d2 = Z_DVAL_P(op2);
13160 is_smaller_double:
13161 if (d1 < d2) {
13162 goto is_smaller_true;
13163 } else {
13164 goto is_smaller_false;
13165 }
13166 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13167 d1 = Z_DVAL_P(op1);
13168 d2 = (double)Z_LVAL_P(op2);
13169 goto is_smaller_double;
13170 }
13171 }
13172 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13173 }
13174
ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13175 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13176 {
13177 USE_OPLINE
13178 zval *op1, *op2;
13179 double d1, d2;
13180
13181 op1 = EX_VAR(opline->op1.var);
13182 op2 = RT_CONSTANT(opline, opline->op2);
13183 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13184 /* pass */
13185 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13186 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13187 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13188 is_smaller_true:
13189 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13190 } else {
13191 is_smaller_false:
13192 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13193 }
13194 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13195 d1 = (double)Z_LVAL_P(op1);
13196 d2 = Z_DVAL_P(op2);
13197 goto is_smaller_double;
13198 }
13199 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13200 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13201 d1 = Z_DVAL_P(op1);
13202 d2 = Z_DVAL_P(op2);
13203 is_smaller_double:
13204 if (d1 < d2) {
13205 goto is_smaller_true;
13206 } else {
13207 goto is_smaller_false;
13208 }
13209 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13210 d1 = Z_DVAL_P(op1);
13211 d2 = (double)Z_LVAL_P(op2);
13212 goto is_smaller_double;
13213 }
13214 }
13215 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13216 }
13217
ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13218 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13219 {
13220 USE_OPLINE
13221 zval *op1, *op2;
13222 double d1, d2;
13223
13224 op1 = EX_VAR(opline->op1.var);
13225 op2 = RT_CONSTANT(opline, opline->op2);
13226 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13227 /* pass */
13228 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13229 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13230 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13231 is_smaller_true:
13232 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13233 } else {
13234 is_smaller_false:
13235 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13236 }
13237 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13238 d1 = (double)Z_LVAL_P(op1);
13239 d2 = Z_DVAL_P(op2);
13240 goto is_smaller_double;
13241 }
13242 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13243 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13244 d1 = Z_DVAL_P(op1);
13245 d2 = Z_DVAL_P(op2);
13246 is_smaller_double:
13247 if (d1 < d2) {
13248 goto is_smaller_true;
13249 } else {
13250 goto is_smaller_false;
13251 }
13252 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13253 d1 = Z_DVAL_P(op1);
13254 d2 = (double)Z_LVAL_P(op2);
13255 goto is_smaller_double;
13256 }
13257 }
13258 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13259 }
13260
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13261 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13262 {
13263 USE_OPLINE
13264 zval *op1, *op2;
13265 double d1, d2;
13266
13267 op1 = EX_VAR(opline->op1.var);
13268 op2 = RT_CONSTANT(opline, opline->op2);
13269 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13270 /* pass */
13271 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13272 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13273 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13274 is_smaller_or_equal_true:
13275 ZEND_VM_SMART_BRANCH_TRUE_NONE();
13276 ZVAL_TRUE(EX_VAR(opline->result.var));
13277 ZEND_VM_NEXT_OPCODE();
13278 } else {
13279 is_smaller_or_equal_false:
13280 ZEND_VM_SMART_BRANCH_FALSE_NONE();
13281 ZVAL_FALSE(EX_VAR(opline->result.var));
13282 ZEND_VM_NEXT_OPCODE();
13283 }
13284 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13285 d1 = (double)Z_LVAL_P(op1);
13286 d2 = Z_DVAL_P(op2);
13287 goto is_smaller_or_equal_double;
13288 }
13289 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13290 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13291 d1 = Z_DVAL_P(op1);
13292 d2 = Z_DVAL_P(op2);
13293 is_smaller_or_equal_double:
13294 if (d1 <= d2) {
13295 goto is_smaller_or_equal_true;
13296 } else {
13297 goto is_smaller_or_equal_false;
13298 }
13299 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13300 d1 = Z_DVAL_P(op1);
13301 d2 = (double)Z_LVAL_P(op2);
13302 goto is_smaller_or_equal_double;
13303 }
13304 }
13305 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13306 }
13307
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13308 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13309 {
13310 USE_OPLINE
13311 zval *op1, *op2;
13312 double d1, d2;
13313
13314 op1 = EX_VAR(opline->op1.var);
13315 op2 = RT_CONSTANT(opline, opline->op2);
13316 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13317 /* pass */
13318 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13319 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13320 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13321 is_smaller_or_equal_true:
13322 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13323 ZVAL_TRUE(EX_VAR(opline->result.var));
13324 ZEND_VM_NEXT_OPCODE();
13325 } else {
13326 is_smaller_or_equal_false:
13327 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13328 ZVAL_FALSE(EX_VAR(opline->result.var));
13329 ZEND_VM_NEXT_OPCODE();
13330 }
13331 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13332 d1 = (double)Z_LVAL_P(op1);
13333 d2 = Z_DVAL_P(op2);
13334 goto is_smaller_or_equal_double;
13335 }
13336 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13337 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13338 d1 = Z_DVAL_P(op1);
13339 d2 = Z_DVAL_P(op2);
13340 is_smaller_or_equal_double:
13341 if (d1 <= d2) {
13342 goto is_smaller_or_equal_true;
13343 } else {
13344 goto is_smaller_or_equal_false;
13345 }
13346 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13347 d1 = Z_DVAL_P(op1);
13348 d2 = (double)Z_LVAL_P(op2);
13349 goto is_smaller_or_equal_double;
13350 }
13351 }
13352 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13353 }
13354
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13355 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13356 {
13357 USE_OPLINE
13358 zval *op1, *op2;
13359 double d1, d2;
13360
13361 op1 = EX_VAR(opline->op1.var);
13362 op2 = RT_CONSTANT(opline, opline->op2);
13363 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13364 /* pass */
13365 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13366 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13367 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13368 is_smaller_or_equal_true:
13369 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13370 ZVAL_TRUE(EX_VAR(opline->result.var));
13371 ZEND_VM_NEXT_OPCODE();
13372 } else {
13373 is_smaller_or_equal_false:
13374 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13375 ZVAL_FALSE(EX_VAR(opline->result.var));
13376 ZEND_VM_NEXT_OPCODE();
13377 }
13378 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13379 d1 = (double)Z_LVAL_P(op1);
13380 d2 = Z_DVAL_P(op2);
13381 goto is_smaller_or_equal_double;
13382 }
13383 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13384 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13385 d1 = Z_DVAL_P(op1);
13386 d2 = Z_DVAL_P(op2);
13387 is_smaller_or_equal_double:
13388 if (d1 <= d2) {
13389 goto is_smaller_or_equal_true;
13390 } else {
13391 goto is_smaller_or_equal_false;
13392 }
13393 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13394 d1 = Z_DVAL_P(op1);
13395 d2 = (double)Z_LVAL_P(op2);
13396 goto is_smaller_or_equal_double;
13397 }
13398 }
13399 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13400 }
13401
ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13402 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13403 {
13404 USE_OPLINE
13405 zval *op1, *op2;
13406
13407 op1 = EX_VAR(opline->op1.var);
13408 op2 = RT_CONSTANT(opline, opline->op2);
13409 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13410 /* pass */
13411 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13412 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13413 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
13414 ZEND_VM_NEXT_OPCODE();
13415 }
13416
13417 ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13418 }
13419
ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13420 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13421 {
13422 USE_OPLINE
13423 zval *op1, *op2;
13424
13425 op1 = EX_VAR(opline->op1.var);
13426 op2 = RT_CONSTANT(opline, opline->op2);
13427 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13428 /* pass */
13429 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13430 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13431 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
13432 ZEND_VM_NEXT_OPCODE();
13433 }
13434
13435 ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13436 }
13437
ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13438 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13439 {
13440 USE_OPLINE
13441 zval *op1, *op2;
13442
13443 op1 = EX_VAR(opline->op1.var);
13444 op2 = RT_CONSTANT(opline, opline->op2);
13445 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13446 /* pass */
13447 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13448 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13449 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
13450 ZEND_VM_NEXT_OPCODE();
13451 }
13452
13453 ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13454 }
13455
ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13456 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13457 {
13458 USE_OPLINE
13459 zval *container;
13460
13461 SAVE_OPLINE();
13462 container = EX_VAR(opline->op1.var);
13463 zend_fetch_dimension_address_LIST_r(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
13464
13465 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
13466 }
13467
ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13468 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13469 {
13470 USE_OPLINE
13471 zval *op, *jump_zv;
13472 HashTable *jumptable;
13473
13474 op = EX_VAR(opline->op1.var);
13475
13476 if (Z_TYPE_P(op) != IS_LONG) {
13477 ZVAL_DEREF(op);
13478 if (Z_TYPE_P(op) != IS_LONG) {
13479 /* Wrong type, fall back to ZEND_CASE chain */
13480 ZEND_VM_NEXT_OPCODE();
13481 }
13482 }
13483
13484 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13485 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13486 if (jump_zv != NULL) {
13487 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13488 ZEND_VM_CONTINUE();
13489 } else {
13490 /* default */
13491 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13492 ZEND_VM_CONTINUE();
13493 }
13494 }
13495
ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13496 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13497 {
13498 USE_OPLINE
13499 zval *op, *jump_zv;
13500 HashTable *jumptable;
13501
13502 op = EX_VAR(opline->op1.var);
13503
13504 if (Z_TYPE_P(op) != IS_STRING) {
13505 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13506 /* Wrong type, fall back to ZEND_CASE chain */
13507 ZEND_VM_NEXT_OPCODE();
13508 } else {
13509 ZVAL_DEREF(op);
13510 if (Z_TYPE_P(op) != IS_STRING) {
13511 /* Wrong type, fall back to ZEND_CASE chain */
13512 ZEND_VM_NEXT_OPCODE();
13513 }
13514 }
13515 }
13516
13517 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13518 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13519 if (jump_zv != NULL) {
13520 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13521 ZEND_VM_CONTINUE();
13522 } else {
13523 /* default */
13524 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13525 ZEND_VM_CONTINUE();
13526 }
13527 }
13528
ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13529 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13530 {
13531 USE_OPLINE
13532 zval *op, *jump_zv;
13533 HashTable *jumptable;
13534
13535 op = EX_VAR(opline->op1.var);
13536 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13537
13538 match_try_again:
13539 if (Z_TYPE_P(op) == IS_LONG) {
13540 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13541 } else if (Z_TYPE_P(op) == IS_STRING) {
13542 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13543 } else if (Z_TYPE_P(op) == IS_REFERENCE) {
13544 op = Z_REFVAL_P(op);
13545 goto match_try_again;
13546 } else {
13547 if (UNEXPECTED(((IS_TMP_VAR|IS_VAR|IS_CV) & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
13548 SAVE_OPLINE();
13549 op = ZVAL_UNDEFINED_OP1();
13550 if (UNEXPECTED(EG(exception))) {
13551 HANDLE_EXCEPTION();
13552 }
13553 goto match_try_again;
13554 }
13555
13556 goto default_branch;
13557 }
13558
13559 if (jump_zv != NULL) {
13560 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13561 ZEND_VM_CONTINUE();
13562 } else {
13563 default_branch:
13564 /* default */
13565 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13566 ZEND_VM_CONTINUE();
13567 }
13568 }
13569
ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13570 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13571 {
13572 USE_OPLINE
13573 zval *op1, *op2, *result;
13574
13575 op1 = EX_VAR(opline->op1.var);
13576 op2 = RT_CONSTANT(opline, opline->op2);
13577 result = EX_VAR(opline->result.var);
13578 ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
13579 ZEND_VM_NEXT_OPCODE();
13580 }
13581
ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13582 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13583 {
13584 USE_OPLINE
13585 zval *op1, *op2, *result;
13586
13587 op1 = EX_VAR(opline->op1.var);
13588 op2 = RT_CONSTANT(opline, opline->op2);
13589 result = EX_VAR(opline->result.var);
13590 fast_long_add_function(result, op1, op2);
13591 ZEND_VM_NEXT_OPCODE();
13592 }
13593
ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13594 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13595 {
13596 USE_OPLINE
13597 zval *op1, *op2, *result;
13598
13599 op1 = EX_VAR(opline->op1.var);
13600 op2 = RT_CONSTANT(opline, opline->op2);
13601 result = EX_VAR(opline->result.var);
13602 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
13603 ZEND_VM_NEXT_OPCODE();
13604 }
13605
ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13606 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13607 {
13608 USE_OPLINE
13609 zval *op1, *op2, *result;
13610
13611 op1 = EX_VAR(opline->op1.var);
13612 op2 = RT_CONSTANT(opline, opline->op2);
13613 result = EX_VAR(opline->result.var);
13614 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
13615 ZEND_VM_NEXT_OPCODE();
13616 }
13617
ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13618 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13619 {
13620 USE_OPLINE
13621 zval *op1, *op2, *result;
13622
13623 op1 = EX_VAR(opline->op1.var);
13624 op2 = RT_CONSTANT(opline, opline->op2);
13625 result = EX_VAR(opline->result.var);
13626 fast_long_sub_function(result, op1, op2);
13627 ZEND_VM_NEXT_OPCODE();
13628 }
13629
ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13630 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13631 {
13632 USE_OPLINE
13633 zval *op1, *op2, *result;
13634
13635 op1 = EX_VAR(opline->op1.var);
13636 op2 = RT_CONSTANT(opline, opline->op2);
13637 result = EX_VAR(opline->result.var);
13638 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
13639 ZEND_VM_NEXT_OPCODE();
13640 }
13641
ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13642 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13643 {
13644 USE_OPLINE
13645 zval *op1, *op2, *result;
13646
13647 op1 = EX_VAR(opline->op1.var);
13648 op2 = RT_CONSTANT(opline, opline->op2);
13649 result = EX_VAR(opline->result.var);
13650 ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
13651 ZEND_VM_NEXT_OPCODE();
13652 }
13653
ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13654 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13655 {
13656 USE_OPLINE
13657 zval *op1, *op2, *result;
13658 zend_long overflow;
13659
13660 op1 = EX_VAR(opline->op1.var);
13661 op2 = RT_CONSTANT(opline, opline->op2);
13662 result = EX_VAR(opline->result.var);
13663 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13664 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13665 ZEND_VM_NEXT_OPCODE();
13666 }
13667
ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13668 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13669 {
13670 USE_OPLINE
13671 zval *op1, *op2, *result;
13672
13673 op1 = EX_VAR(opline->op1.var);
13674 op2 = RT_CONSTANT(opline, opline->op2);
13675 result = EX_VAR(opline->result.var);
13676 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
13677 ZEND_VM_NEXT_OPCODE();
13678 }
13679
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13680 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13681 {
13682 USE_OPLINE
13683 zval *op1, *op2;
13684 bool result;
13685
13686 op1 = EX_VAR(opline->op1.var);
13687 op2 = RT_CONSTANT(opline, opline->op2);
13688 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13689 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13690 }
13691
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13692 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13693 {
13694 USE_OPLINE
13695 zval *op1, *op2;
13696 bool result;
13697
13698 op1 = EX_VAR(opline->op1.var);
13699 op2 = RT_CONSTANT(opline, opline->op2);
13700 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13701 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13702 }
13703
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13704 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13705 {
13706 USE_OPLINE
13707 zval *op1, *op2;
13708 bool result;
13709
13710 op1 = EX_VAR(opline->op1.var);
13711 op2 = RT_CONSTANT(opline, opline->op2);
13712 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13713 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13714 }
13715
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13716 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13717 {
13718 USE_OPLINE
13719 zval *op1, *op2;
13720 bool result;
13721
13722 op1 = EX_VAR(opline->op1.var);
13723 op2 = RT_CONSTANT(opline, opline->op2);
13724 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13725 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13726 }
13727
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13728 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13729 {
13730 USE_OPLINE
13731 zval *op1, *op2;
13732 bool result;
13733
13734 op1 = EX_VAR(opline->op1.var);
13735 op2 = RT_CONSTANT(opline, opline->op2);
13736 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13737 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13738 }
13739
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13740 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13741 {
13742 USE_OPLINE
13743 zval *op1, *op2;
13744 bool result;
13745
13746 op1 = EX_VAR(opline->op1.var);
13747 op2 = RT_CONSTANT(opline, opline->op2);
13748 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13749 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13750 }
13751
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13752 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13753 {
13754 USE_OPLINE
13755 zval *op1, *op2;
13756 bool result;
13757
13758 op1 = EX_VAR(opline->op1.var);
13759 op2 = RT_CONSTANT(opline, opline->op2);
13760 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13761 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13762 }
13763
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13764 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13765 {
13766 USE_OPLINE
13767 zval *op1, *op2;
13768 bool result;
13769
13770 op1 = EX_VAR(opline->op1.var);
13771 op2 = RT_CONSTANT(opline, opline->op2);
13772 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13773 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13774 }
13775
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13776 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13777 {
13778 USE_OPLINE
13779 zval *op1, *op2;
13780 bool result;
13781
13782 op1 = EX_VAR(opline->op1.var);
13783 op2 = RT_CONSTANT(opline, opline->op2);
13784 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13785 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13786 }
13787
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13788 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13789 {
13790 USE_OPLINE
13791 zval *op1, *op2;
13792 bool result;
13793
13794 op1 = EX_VAR(opline->op1.var);
13795 op2 = RT_CONSTANT(opline, opline->op2);
13796 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13797 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13798 }
13799
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13800 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13801 {
13802 USE_OPLINE
13803 zval *op1, *op2;
13804 bool result;
13805
13806 op1 = EX_VAR(opline->op1.var);
13807 op2 = RT_CONSTANT(opline, opline->op2);
13808 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13809 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13810 }
13811
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13812 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13813 {
13814 USE_OPLINE
13815 zval *op1, *op2;
13816 bool result;
13817
13818 op1 = EX_VAR(opline->op1.var);
13819 op2 = RT_CONSTANT(opline, opline->op2);
13820 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13821 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13822 }
13823
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13824 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13825 {
13826 USE_OPLINE
13827 zval *op1, *op2;
13828 bool result;
13829
13830 op1 = EX_VAR(opline->op1.var);
13831 op2 = RT_CONSTANT(opline, opline->op2);
13832 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13833 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13834 }
13835
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13836 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13837 {
13838 USE_OPLINE
13839 zval *op1, *op2;
13840 bool result;
13841
13842 op1 = EX_VAR(opline->op1.var);
13843 op2 = RT_CONSTANT(opline, opline->op2);
13844 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13845 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13846 }
13847
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13848 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13849 {
13850 USE_OPLINE
13851 zval *op1, *op2;
13852 bool result;
13853
13854 op1 = EX_VAR(opline->op1.var);
13855 op2 = RT_CONSTANT(opline, opline->op2);
13856 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13857 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13858 }
13859
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13860 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13861 {
13862 USE_OPLINE
13863 zval *op1, *op2;
13864 bool result;
13865
13866 op1 = EX_VAR(opline->op1.var);
13867 op2 = RT_CONSTANT(opline, opline->op2);
13868 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13869 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13870 }
13871
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13872 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13873 {
13874 USE_OPLINE
13875 zval *op1, *op2;
13876 bool result;
13877
13878 op1 = EX_VAR(opline->op1.var);
13879 op2 = RT_CONSTANT(opline, opline->op2);
13880 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13881 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13882 }
13883
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13884 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13885 {
13886 USE_OPLINE
13887 zval *op1, *op2;
13888 bool result;
13889
13890 op1 = EX_VAR(opline->op1.var);
13891 op2 = RT_CONSTANT(opline, opline->op2);
13892 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13893 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13894 }
13895
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13896 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13897 {
13898 USE_OPLINE
13899 zval *op1, *op2;
13900 bool result;
13901
13902 op1 = EX_VAR(opline->op1.var);
13903 op2 = RT_CONSTANT(opline, opline->op2);
13904 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13905 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13906 }
13907
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13908 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13909 {
13910 USE_OPLINE
13911 zval *op1, *op2;
13912 bool result;
13913
13914 op1 = EX_VAR(opline->op1.var);
13915 op2 = RT_CONSTANT(opline, opline->op2);
13916 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13917 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13918 }
13919
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13920 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13921 {
13922 USE_OPLINE
13923 zval *op1, *op2;
13924 bool result;
13925
13926 op1 = EX_VAR(opline->op1.var);
13927 op2 = RT_CONSTANT(opline, opline->op2);
13928 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13929 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13930 }
13931
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13932 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13933 {
13934 USE_OPLINE
13935 zval *op1, *op2;
13936 bool result;
13937
13938 op1 = EX_VAR(opline->op1.var);
13939 op2 = RT_CONSTANT(opline, opline->op2);
13940 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13941 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13942 }
13943
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13944 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13945 {
13946 USE_OPLINE
13947 zval *op1, *op2;
13948 bool result;
13949
13950 op1 = EX_VAR(opline->op1.var);
13951 op2 = RT_CONSTANT(opline, opline->op2);
13952 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13953 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13954 }
13955
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13956 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13957 {
13958 USE_OPLINE
13959 zval *op1, *op2;
13960 bool result;
13961
13962 op1 = EX_VAR(opline->op1.var);
13963 op2 = RT_CONSTANT(opline, opline->op2);
13964 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13965 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13966 }
13967
ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13968 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13969 {
13970 USE_OPLINE
13971 zval *op1, *op2, *result;
13972 double d1, d2;
13973
13974 op1 = EX_VAR(opline->op1.var);
13975 op2 = EX_VAR(opline->op2.var);
13976 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13977 /* pass */
13978 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13979 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13980 result = EX_VAR(opline->result.var);
13981 fast_long_add_function(result, op1, op2);
13982 ZEND_VM_NEXT_OPCODE();
13983 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13984 d1 = (double)Z_LVAL_P(op1);
13985 d2 = Z_DVAL_P(op2);
13986 goto add_double;
13987 }
13988 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13989 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13990 d1 = Z_DVAL_P(op1);
13991 d2 = Z_DVAL_P(op2);
13992 add_double:
13993 result = EX_VAR(opline->result.var);
13994 ZVAL_DOUBLE(result, d1 + d2);
13995 ZEND_VM_NEXT_OPCODE();
13996 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13997 d1 = Z_DVAL_P(op1);
13998 d2 = (double)Z_LVAL_P(op2);
13999 goto add_double;
14000 }
14001 }
14002
14003 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14004 }
14005
ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14006 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14007 {
14008 USE_OPLINE
14009 zval *op1, *op2, *result;
14010 double d1, d2;
14011
14012 op1 = EX_VAR(opline->op1.var);
14013 op2 = EX_VAR(opline->op2.var);
14014 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14015 /* pass */
14016 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14017 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14018 result = EX_VAR(opline->result.var);
14019 fast_long_sub_function(result, op1, op2);
14020 ZEND_VM_NEXT_OPCODE();
14021 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14022 d1 = (double)Z_LVAL_P(op1);
14023 d2 = Z_DVAL_P(op2);
14024 goto sub_double;
14025 }
14026 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14027 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14028 d1 = Z_DVAL_P(op1);
14029 d2 = Z_DVAL_P(op2);
14030 sub_double:
14031 result = EX_VAR(opline->result.var);
14032 ZVAL_DOUBLE(result, d1 - d2);
14033 ZEND_VM_NEXT_OPCODE();
14034 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14035 d1 = Z_DVAL_P(op1);
14036 d2 = (double)Z_LVAL_P(op2);
14037 goto sub_double;
14038 }
14039 }
14040
14041 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14042 }
14043
ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14044 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14045 {
14046 USE_OPLINE
14047 zval *op1, *op2, *result;
14048 double d1, d2;
14049
14050 op1 = EX_VAR(opline->op1.var);
14051 op2 = EX_VAR(opline->op2.var);
14052 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14053 /* pass */
14054 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14055 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14056 zend_long overflow;
14057
14058 result = EX_VAR(opline->result.var);
14059 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
14060 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
14061 ZEND_VM_NEXT_OPCODE();
14062 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14063 d1 = (double)Z_LVAL_P(op1);
14064 d2 = Z_DVAL_P(op2);
14065 goto mul_double;
14066 }
14067 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14068 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14069 d1 = Z_DVAL_P(op1);
14070 d2 = Z_DVAL_P(op2);
14071 mul_double:
14072 result = EX_VAR(opline->result.var);
14073 ZVAL_DOUBLE(result, d1 * d2);
14074 ZEND_VM_NEXT_OPCODE();
14075 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14076 d1 = Z_DVAL_P(op1);
14077 d2 = (double)Z_LVAL_P(op2);
14078 goto mul_double;
14079 }
14080 }
14081
14082 ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14083 }
14084
ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14085 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14086 {
14087 USE_OPLINE
14088 zval *op1, *op2, *result;
14089
14090 op1 = EX_VAR(opline->op1.var);
14091 op2 = EX_VAR(opline->op2.var);
14092 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14093 /* pass */
14094 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14095 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14096 result = EX_VAR(opline->result.var);
14097 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
14098 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
14099 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
14100 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
14101 ZVAL_LONG(result, 0);
14102 } else {
14103 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
14104 }
14105 ZEND_VM_NEXT_OPCODE();
14106 }
14107 }
14108
14109 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14110 }
14111
ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14112 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14113 {
14114 USE_OPLINE
14115 zval *op1, *op2;
14116
14117 op1 = EX_VAR(opline->op1.var);
14118 op2 = EX_VAR(opline->op2.var);
14119 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14120 /* pass */
14121 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14122 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
14123 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
14124 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
14125 ZVAL_LONG(EX_VAR(opline->result.var),
14126 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
14127 ZEND_VM_NEXT_OPCODE();
14128 }
14129
14130 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14131 }
14132
ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14133 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14134 {
14135 USE_OPLINE
14136 zval *op1, *op2;
14137
14138 op1 = EX_VAR(opline->op1.var);
14139 op2 = EX_VAR(opline->op2.var);
14140 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14141 /* pass */
14142 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14143 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
14144 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
14145 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
14146 ZEND_VM_NEXT_OPCODE();
14147 }
14148
14149 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14150 }
14151
ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14152 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14153 {
14154 USE_OPLINE
14155 zval *op1, *op2;
14156 double d1, d2;
14157
14158 op1 = EX_VAR(opline->op1.var);
14159 op2 = EX_VAR(opline->op2.var);
14160 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14161 /* pass */
14162 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14163 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14164 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14165 is_smaller_true:
14166 ZEND_VM_SMART_BRANCH_TRUE_NONE();
14167 } else {
14168 is_smaller_false:
14169 ZEND_VM_SMART_BRANCH_FALSE_NONE();
14170 }
14171 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14172 d1 = (double)Z_LVAL_P(op1);
14173 d2 = Z_DVAL_P(op2);
14174 goto is_smaller_double;
14175 }
14176 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14177 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14178 d1 = Z_DVAL_P(op1);
14179 d2 = Z_DVAL_P(op2);
14180 is_smaller_double:
14181 if (d1 < d2) {
14182 goto is_smaller_true;
14183 } else {
14184 goto is_smaller_false;
14185 }
14186 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14187 d1 = Z_DVAL_P(op1);
14188 d2 = (double)Z_LVAL_P(op2);
14189 goto is_smaller_double;
14190 }
14191 }
14192 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14193 }
14194
ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14195 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14196 {
14197 USE_OPLINE
14198 zval *op1, *op2;
14199 double d1, d2;
14200
14201 op1 = EX_VAR(opline->op1.var);
14202 op2 = EX_VAR(opline->op2.var);
14203 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14204 /* pass */
14205 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14206 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14207 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14208 is_smaller_true:
14209 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
14210 } else {
14211 is_smaller_false:
14212 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
14213 }
14214 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14215 d1 = (double)Z_LVAL_P(op1);
14216 d2 = Z_DVAL_P(op2);
14217 goto is_smaller_double;
14218 }
14219 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14220 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14221 d1 = Z_DVAL_P(op1);
14222 d2 = Z_DVAL_P(op2);
14223 is_smaller_double:
14224 if (d1 < d2) {
14225 goto is_smaller_true;
14226 } else {
14227 goto is_smaller_false;
14228 }
14229 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14230 d1 = Z_DVAL_P(op1);
14231 d2 = (double)Z_LVAL_P(op2);
14232 goto is_smaller_double;
14233 }
14234 }
14235 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14236 }
14237
ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14238 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14239 {
14240 USE_OPLINE
14241 zval *op1, *op2;
14242 double d1, d2;
14243
14244 op1 = EX_VAR(opline->op1.var);
14245 op2 = EX_VAR(opline->op2.var);
14246 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14247 /* pass */
14248 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14249 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14250 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
14251 is_smaller_true:
14252 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
14253 } else {
14254 is_smaller_false:
14255 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
14256 }
14257 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14258 d1 = (double)Z_LVAL_P(op1);
14259 d2 = Z_DVAL_P(op2);
14260 goto is_smaller_double;
14261 }
14262 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14263 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14264 d1 = Z_DVAL_P(op1);
14265 d2 = Z_DVAL_P(op2);
14266 is_smaller_double:
14267 if (d1 < d2) {
14268 goto is_smaller_true;
14269 } else {
14270 goto is_smaller_false;
14271 }
14272 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14273 d1 = Z_DVAL_P(op1);
14274 d2 = (double)Z_LVAL_P(op2);
14275 goto is_smaller_double;
14276 }
14277 }
14278 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14279 }
14280
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14281 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14282 {
14283 USE_OPLINE
14284 zval *op1, *op2;
14285 double d1, d2;
14286
14287 op1 = EX_VAR(opline->op1.var);
14288 op2 = EX_VAR(opline->op2.var);
14289 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14290 /* pass */
14291 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14292 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14293 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14294 is_smaller_or_equal_true:
14295 ZEND_VM_SMART_BRANCH_TRUE_NONE();
14296 ZVAL_TRUE(EX_VAR(opline->result.var));
14297 ZEND_VM_NEXT_OPCODE();
14298 } else {
14299 is_smaller_or_equal_false:
14300 ZEND_VM_SMART_BRANCH_FALSE_NONE();
14301 ZVAL_FALSE(EX_VAR(opline->result.var));
14302 ZEND_VM_NEXT_OPCODE();
14303 }
14304 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14305 d1 = (double)Z_LVAL_P(op1);
14306 d2 = Z_DVAL_P(op2);
14307 goto is_smaller_or_equal_double;
14308 }
14309 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14310 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14311 d1 = Z_DVAL_P(op1);
14312 d2 = Z_DVAL_P(op2);
14313 is_smaller_or_equal_double:
14314 if (d1 <= d2) {
14315 goto is_smaller_or_equal_true;
14316 } else {
14317 goto is_smaller_or_equal_false;
14318 }
14319 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14320 d1 = Z_DVAL_P(op1);
14321 d2 = (double)Z_LVAL_P(op2);
14322 goto is_smaller_or_equal_double;
14323 }
14324 }
14325 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14326 }
14327
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14328 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14329 {
14330 USE_OPLINE
14331 zval *op1, *op2;
14332 double d1, d2;
14333
14334 op1 = EX_VAR(opline->op1.var);
14335 op2 = EX_VAR(opline->op2.var);
14336 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14337 /* pass */
14338 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14339 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14340 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14341 is_smaller_or_equal_true:
14342 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
14343 ZVAL_TRUE(EX_VAR(opline->result.var));
14344 ZEND_VM_NEXT_OPCODE();
14345 } else {
14346 is_smaller_or_equal_false:
14347 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
14348 ZVAL_FALSE(EX_VAR(opline->result.var));
14349 ZEND_VM_NEXT_OPCODE();
14350 }
14351 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14352 d1 = (double)Z_LVAL_P(op1);
14353 d2 = Z_DVAL_P(op2);
14354 goto is_smaller_or_equal_double;
14355 }
14356 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14357 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14358 d1 = Z_DVAL_P(op1);
14359 d2 = Z_DVAL_P(op2);
14360 is_smaller_or_equal_double:
14361 if (d1 <= d2) {
14362 goto is_smaller_or_equal_true;
14363 } else {
14364 goto is_smaller_or_equal_false;
14365 }
14366 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14367 d1 = Z_DVAL_P(op1);
14368 d2 = (double)Z_LVAL_P(op2);
14369 goto is_smaller_or_equal_double;
14370 }
14371 }
14372 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14373 }
14374
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14375 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14376 {
14377 USE_OPLINE
14378 zval *op1, *op2;
14379 double d1, d2;
14380
14381 op1 = EX_VAR(opline->op1.var);
14382 op2 = EX_VAR(opline->op2.var);
14383 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14384 /* pass */
14385 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14386 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14387 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14388 is_smaller_or_equal_true:
14389 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
14390 ZVAL_TRUE(EX_VAR(opline->result.var));
14391 ZEND_VM_NEXT_OPCODE();
14392 } else {
14393 is_smaller_or_equal_false:
14394 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
14395 ZVAL_FALSE(EX_VAR(opline->result.var));
14396 ZEND_VM_NEXT_OPCODE();
14397 }
14398 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14399 d1 = (double)Z_LVAL_P(op1);
14400 d2 = Z_DVAL_P(op2);
14401 goto is_smaller_or_equal_double;
14402 }
14403 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14404 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14405 d1 = Z_DVAL_P(op1);
14406 d2 = Z_DVAL_P(op2);
14407 is_smaller_or_equal_double:
14408 if (d1 <= d2) {
14409 goto is_smaller_or_equal_true;
14410 } else {
14411 goto is_smaller_or_equal_false;
14412 }
14413 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14414 d1 = Z_DVAL_P(op1);
14415 d2 = (double)Z_LVAL_P(op2);
14416 goto is_smaller_or_equal_double;
14417 }
14418 }
14419 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14420 }
14421
ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14422 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14423 {
14424 USE_OPLINE
14425 zval *op1, *op2;
14426
14427 op1 = EX_VAR(opline->op1.var);
14428 op2 = EX_VAR(opline->op2.var);
14429 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14430 /* pass */
14431 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14432 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14433 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
14434 ZEND_VM_NEXT_OPCODE();
14435 }
14436
14437 ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14438 }
14439
ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14440 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14441 {
14442 USE_OPLINE
14443 zval *op1, *op2;
14444
14445 op1 = EX_VAR(opline->op1.var);
14446 op2 = EX_VAR(opline->op2.var);
14447 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14448 /* pass */
14449 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14450 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14451 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
14452 ZEND_VM_NEXT_OPCODE();
14453 }
14454
14455 ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14456 }
14457
ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14458 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14459 {
14460 USE_OPLINE
14461 zval *op1, *op2;
14462
14463 op1 = EX_VAR(opline->op1.var);
14464 op2 = EX_VAR(opline->op2.var);
14465 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14466 /* pass */
14467 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14468 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14469 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
14470 ZEND_VM_NEXT_OPCODE();
14471 }
14472
14473 ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14474 }
14475
ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14476 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14477 {
14478 USE_OPLINE
14479 zval *op1, *op2, *result;
14480
14481 op1 = EX_VAR(opline->op1.var);
14482 op2 = EX_VAR(opline->op2.var);
14483 result = EX_VAR(opline->result.var);
14484 ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
14485 ZEND_VM_NEXT_OPCODE();
14486 }
14487
ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14488 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14489 {
14490 USE_OPLINE
14491 zval *op1, *op2, *result;
14492
14493 op1 = EX_VAR(opline->op1.var);
14494 op2 = EX_VAR(opline->op2.var);
14495 result = EX_VAR(opline->result.var);
14496 fast_long_add_function(result, op1, op2);
14497 ZEND_VM_NEXT_OPCODE();
14498 }
14499
ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14500 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14501 {
14502 USE_OPLINE
14503 zval *op1, *op2, *result;
14504
14505 op1 = EX_VAR(opline->op1.var);
14506 op2 = EX_VAR(opline->op2.var);
14507 result = EX_VAR(opline->result.var);
14508 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
14509 ZEND_VM_NEXT_OPCODE();
14510 }
14511
ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14512 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14513 {
14514 USE_OPLINE
14515 zval *op1, *op2, *result;
14516
14517 op1 = EX_VAR(opline->op1.var);
14518 op2 = EX_VAR(opline->op2.var);
14519 result = EX_VAR(opline->result.var);
14520 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
14521 ZEND_VM_NEXT_OPCODE();
14522 }
14523
ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14524 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14525 {
14526 USE_OPLINE
14527 zval *op1, *op2, *result;
14528
14529 op1 = EX_VAR(opline->op1.var);
14530 op2 = EX_VAR(opline->op2.var);
14531 result = EX_VAR(opline->result.var);
14532 fast_long_sub_function(result, op1, op2);
14533 ZEND_VM_NEXT_OPCODE();
14534 }
14535
ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14536 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14537 {
14538 USE_OPLINE
14539 zval *op1, *op2, *result;
14540
14541 op1 = EX_VAR(opline->op1.var);
14542 op2 = EX_VAR(opline->op2.var);
14543 result = EX_VAR(opline->result.var);
14544 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
14545 ZEND_VM_NEXT_OPCODE();
14546 }
14547
ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14548 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14549 {
14550 USE_OPLINE
14551 zval *op1, *op2, *result;
14552
14553 op1 = EX_VAR(opline->op1.var);
14554 op2 = EX_VAR(opline->op2.var);
14555 result = EX_VAR(opline->result.var);
14556 ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
14557 ZEND_VM_NEXT_OPCODE();
14558 }
14559
ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14560 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14561 {
14562 USE_OPLINE
14563 zval *op1, *op2, *result;
14564 zend_long overflow;
14565
14566 op1 = EX_VAR(opline->op1.var);
14567 op2 = EX_VAR(opline->op2.var);
14568 result = EX_VAR(opline->result.var);
14569 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
14570 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
14571 ZEND_VM_NEXT_OPCODE();
14572 }
14573
ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14574 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14575 {
14576 USE_OPLINE
14577 zval *op1, *op2, *result;
14578
14579 op1 = EX_VAR(opline->op1.var);
14580 op2 = EX_VAR(opline->op2.var);
14581 result = EX_VAR(opline->result.var);
14582 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
14583 ZEND_VM_NEXT_OPCODE();
14584 }
14585
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14586 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14587 {
14588 USE_OPLINE
14589 zval *op1, *op2;
14590 bool result;
14591
14592 op1 = EX_VAR(opline->op1.var);
14593 op2 = EX_VAR(opline->op2.var);
14594 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14595 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14596 }
14597
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14598 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14599 {
14600 USE_OPLINE
14601 zval *op1, *op2;
14602 bool result;
14603
14604 op1 = EX_VAR(opline->op1.var);
14605 op2 = EX_VAR(opline->op2.var);
14606 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14607 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14608 }
14609
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14610 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14611 {
14612 USE_OPLINE
14613 zval *op1, *op2;
14614 bool result;
14615
14616 op1 = EX_VAR(opline->op1.var);
14617 op2 = EX_VAR(opline->op2.var);
14618 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14619 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14620 }
14621
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14622 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14623 {
14624 USE_OPLINE
14625 zval *op1, *op2;
14626 bool result;
14627
14628 op1 = EX_VAR(opline->op1.var);
14629 op2 = EX_VAR(opline->op2.var);
14630 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14631 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14632 }
14633
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14634 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14635 {
14636 USE_OPLINE
14637 zval *op1, *op2;
14638 bool result;
14639
14640 op1 = EX_VAR(opline->op1.var);
14641 op2 = EX_VAR(opline->op2.var);
14642 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14643 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14644 }
14645
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14646 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14647 {
14648 USE_OPLINE
14649 zval *op1, *op2;
14650 bool result;
14651
14652 op1 = EX_VAR(opline->op1.var);
14653 op2 = EX_VAR(opline->op2.var);
14654 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14655 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14656 }
14657
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14658 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14659 {
14660 USE_OPLINE
14661 zval *op1, *op2;
14662 bool result;
14663
14664 op1 = EX_VAR(opline->op1.var);
14665 op2 = EX_VAR(opline->op2.var);
14666 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14667 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14668 }
14669
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14670 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14671 {
14672 USE_OPLINE
14673 zval *op1, *op2;
14674 bool result;
14675
14676 op1 = EX_VAR(opline->op1.var);
14677 op2 = EX_VAR(opline->op2.var);
14678 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14679 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14680 }
14681
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14682 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14683 {
14684 USE_OPLINE
14685 zval *op1, *op2;
14686 bool result;
14687
14688 op1 = EX_VAR(opline->op1.var);
14689 op2 = EX_VAR(opline->op2.var);
14690 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14691 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14692 }
14693
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14694 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14695 {
14696 USE_OPLINE
14697 zval *op1, *op2;
14698 bool result;
14699
14700 op1 = EX_VAR(opline->op1.var);
14701 op2 = EX_VAR(opline->op2.var);
14702 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14703 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14704 }
14705
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14706 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14707 {
14708 USE_OPLINE
14709 zval *op1, *op2;
14710 bool result;
14711
14712 op1 = EX_VAR(opline->op1.var);
14713 op2 = EX_VAR(opline->op2.var);
14714 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14715 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14716 }
14717
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14718 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14719 {
14720 USE_OPLINE
14721 zval *op1, *op2;
14722 bool result;
14723
14724 op1 = EX_VAR(opline->op1.var);
14725 op2 = EX_VAR(opline->op2.var);
14726 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14727 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14728 }
14729
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14730 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14731 {
14732 USE_OPLINE
14733 zval *op1, *op2;
14734 bool result;
14735
14736 op1 = EX_VAR(opline->op1.var);
14737 op2 = EX_VAR(opline->op2.var);
14738 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14739 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14740 }
14741
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14742 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14743 {
14744 USE_OPLINE
14745 zval *op1, *op2;
14746 bool result;
14747
14748 op1 = EX_VAR(opline->op1.var);
14749 op2 = EX_VAR(opline->op2.var);
14750 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14751 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14752 }
14753
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14754 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14755 {
14756 USE_OPLINE
14757 zval *op1, *op2;
14758 bool result;
14759
14760 op1 = EX_VAR(opline->op1.var);
14761 op2 = EX_VAR(opline->op2.var);
14762 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14763 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14764 }
14765
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14766 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14767 {
14768 USE_OPLINE
14769 zval *op1, *op2;
14770 bool result;
14771
14772 op1 = EX_VAR(opline->op1.var);
14773 op2 = EX_VAR(opline->op2.var);
14774 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14775 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14776 }
14777
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14778 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14779 {
14780 USE_OPLINE
14781 zval *op1, *op2;
14782 bool result;
14783
14784 op1 = EX_VAR(opline->op1.var);
14785 op2 = EX_VAR(opline->op2.var);
14786 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14787 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14788 }
14789
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14790 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14791 {
14792 USE_OPLINE
14793 zval *op1, *op2;
14794 bool result;
14795
14796 op1 = EX_VAR(opline->op1.var);
14797 op2 = EX_VAR(opline->op2.var);
14798 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14799 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14800 }
14801
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14802 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14803 {
14804 USE_OPLINE
14805 zval *op1, *op2;
14806 bool result;
14807
14808 op1 = EX_VAR(opline->op1.var);
14809 op2 = EX_VAR(opline->op2.var);
14810 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14811 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14812 }
14813
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14814 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14815 {
14816 USE_OPLINE
14817 zval *op1, *op2;
14818 bool result;
14819
14820 op1 = EX_VAR(opline->op1.var);
14821 op2 = EX_VAR(opline->op2.var);
14822 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14823 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14824 }
14825
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14826 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14827 {
14828 USE_OPLINE
14829 zval *op1, *op2;
14830 bool result;
14831
14832 op1 = EX_VAR(opline->op1.var);
14833 op2 = EX_VAR(opline->op2.var);
14834 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14835 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14836 }
14837
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14838 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14839 {
14840 USE_OPLINE
14841 zval *op1, *op2;
14842 bool result;
14843
14844 op1 = EX_VAR(opline->op1.var);
14845 op2 = EX_VAR(opline->op2.var);
14846 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14847 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14848 }
14849
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14850 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14851 {
14852 USE_OPLINE
14853 zval *op1, *op2;
14854 bool result;
14855
14856 op1 = EX_VAR(opline->op1.var);
14857 op2 = EX_VAR(opline->op2.var);
14858 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14859 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14860 }
14861
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14862 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14863 {
14864 USE_OPLINE
14865 zval *op1, *op2;
14866 bool result;
14867
14868 op1 = EX_VAR(opline->op1.var);
14869 op2 = EX_VAR(opline->op2.var);
14870 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14871 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14872 }
14873
ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14874 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14875 {
14876 USE_OPLINE
14877 zval *container;
14878
14879 SAVE_OPLINE();
14880 container = EX_VAR(opline->op1.var);
14881 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);
14882 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
14883 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14884 }
14885
ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14886 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14887 {
14888 USE_OPLINE
14889 zval *op;
14890
14891 SAVE_OPLINE();
14892 op = EX_VAR(opline->op1.var);
14893 zend_match_unhandled_error(op);
14894 HANDLE_EXCEPTION();
14895 }
14896
ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14897 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14898 {
14899 USE_OPLINE
14900 zval *container;
14901
14902 SAVE_OPLINE();
14903 container = EX_VAR(opline->op1.var);
14904 zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
14905
14906 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14907 }
14908
ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14909 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14910 {
14911 USE_OPLINE
14912 zval *val;
14913
14914 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14915 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14916 ZVAL_FALSE(EX_VAR(opline->result.var));
14917 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14918 /* The result and op1 can be the same cv zval */
14919 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
14920 ZVAL_TRUE(EX_VAR(opline->result.var));
14921 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
14922 SAVE_OPLINE();
14923 ZVAL_UNDEFINED_OP1();
14924 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14925 }
14926 } else {
14927 SAVE_OPLINE();
14928 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
14929 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14930 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14931 }
14932 ZEND_VM_NEXT_OPCODE();
14933 }
14934
ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14935 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14936 {
14937 USE_OPLINE
14938 zval *z;
14939
14940 SAVE_OPLINE();
14941 z = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14942
14943 if (Z_TYPE_P(z) == IS_STRING) {
14944 zend_string *str = Z_STR_P(z);
14945
14946 if (ZSTR_LEN(str) != 0) {
14947 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
14948 }
14949 } else {
14950 zend_string *str = zval_get_string_func(z);
14951
14952 if (ZSTR_LEN(str) != 0) {
14953 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
14954 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
14955 ZVAL_UNDEFINED_OP1();
14956 }
14957 zend_string_release_ex(str, 0);
14958 }
14959
14960 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14961 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14962 }
14963
ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14964 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14965 {
14966 USE_OPLINE
14967 zval *val;
14968 uint8_t op1_type;
14969
14970 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14971
14972 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14973 ZEND_VM_NEXT_OPCODE();
14974 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14975 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
14976 SAVE_OPLINE();
14977 ZVAL_UNDEFINED_OP1();
14978 if (UNEXPECTED(EG(exception))) {
14979 HANDLE_EXCEPTION();
14980 }
14981 }
14982 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
14983 }
14984
14985 SAVE_OPLINE();
14986 op1_type = (IS_TMP_VAR|IS_VAR);
14987 if (i_zend_is_true(val)) {
14988 opline++;
14989 } else {
14990 opline = OP_JMP_ADDR(opline, opline->op2);
14991 }
14992 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
14993 zval_ptr_dtor_nogc(val);
14994 }
14995 ZEND_VM_JMP(opline);
14996 }
14997
ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14998 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_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_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
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_NEXT_OPCODE();
15017 }
15018
15019 SAVE_OPLINE();
15020 op1_type = (IS_TMP_VAR|IS_VAR);
15021 if (i_zend_is_true(val)) {
15022 opline = OP_JMP_ADDR(opline, opline->op2);
15023 } else {
15024 opline++;
15025 }
15026 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
15027 zval_ptr_dtor_nogc(val);
15028 }
15029 ZEND_VM_JMP(opline);
15030 }
15031
ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15032 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15033 {
15034 USE_OPLINE
15035 zval *val;
15036 bool ret;
15037
15038 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15039
15040 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15041 ZVAL_TRUE(EX_VAR(opline->result.var));
15042 ZEND_VM_NEXT_OPCODE();
15043 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15044 ZVAL_FALSE(EX_VAR(opline->result.var));
15045 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15046 SAVE_OPLINE();
15047 ZVAL_UNDEFINED_OP1();
15048 if (UNEXPECTED(EG(exception))) {
15049 HANDLE_EXCEPTION();
15050 }
15051 }
15052 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15053 }
15054
15055 SAVE_OPLINE();
15056 ret = i_zend_is_true(val);
15057 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15058 if (ret) {
15059 ZVAL_TRUE(EX_VAR(opline->result.var));
15060 opline++;
15061 } else {
15062 ZVAL_FALSE(EX_VAR(opline->result.var));
15063 opline = OP_JMP_ADDR(opline, opline->op2);
15064 }
15065 ZEND_VM_JMP(opline);
15066 }
15067
ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15068 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15069 {
15070 USE_OPLINE
15071 zval *val;
15072 bool ret;
15073
15074 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15075
15076 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15077 ZVAL_TRUE(EX_VAR(opline->result.var));
15078 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
15079 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15080 ZVAL_FALSE(EX_VAR(opline->result.var));
15081 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
15082 SAVE_OPLINE();
15083 ZVAL_UNDEFINED_OP1();
15084 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15085 } else {
15086 ZEND_VM_NEXT_OPCODE();
15087 }
15088 }
15089
15090 SAVE_OPLINE();
15091 ret = i_zend_is_true(val);
15092 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15093 if (ret) {
15094 ZVAL_TRUE(EX_VAR(opline->result.var));
15095 opline = OP_JMP_ADDR(opline, opline->op2);
15096 } else {
15097 ZVAL_FALSE(EX_VAR(opline->result.var));
15098 opline++;
15099 }
15100 ZEND_VM_JMP(opline);
15101 }
15102
ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15103 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15104 {
15105 USE_OPLINE
15106
15107 SAVE_OPLINE();
15108 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15109 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15110 }
15111
ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15112 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15113 {
15114 zval *var;
15115 USE_OPLINE
15116
15117 var = EX_VAR(opline->op1.var);
15118 if (Z_TYPE_P(var) != IS_ARRAY) {
15119 SAVE_OPLINE();
15120 if (Z_FE_ITER_P(var) != (uint32_t)-1) {
15121 zend_hash_iterator_del(Z_FE_ITER_P(var));
15122 }
15123 zval_ptr_dtor_nogc(var);
15124 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15125 }
15126
15127 /* This is freeing an array. Use an inlined version of zval_ptr_dtor_nogc. */
15128 /* 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) */
15129 if (Z_REFCOUNTED_P(var) && !Z_DELREF_P(var)) {
15130 SAVE_OPLINE();
15131 rc_dtor_func(Z_COUNTED_P(var));
15132 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15133 }
15134 ZEND_VM_NEXT_OPCODE();
15135 }
15136
ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15137 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15138 {
15139 USE_OPLINE
15140 zval *value;
15141
15142 SAVE_OPLINE();
15143 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15144
15145 do {
15146 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
15147 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
15148 value = Z_REFVAL_P(value);
15149 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
15150 break;
15151 }
15152 }
15153 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15154 ZVAL_UNDEFINED_OP1();
15155 if (UNEXPECTED(EG(exception) != NULL)) {
15156 HANDLE_EXCEPTION();
15157 }
15158 }
15159 zend_throw_error(NULL, "Can only throw objects");
15160 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15161 HANDLE_EXCEPTION();
15162 }
15163 } while (0);
15164
15165 zend_exception_save();
15166 Z_TRY_ADDREF_P(value);
15167 zend_throw_exception_object(value);
15168 zend_exception_restore();
15169 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15170 HANDLE_EXCEPTION();
15171 }
15172
ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15173 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15174 {
15175 USE_OPLINE
15176 zval *val;
15177
15178 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15179 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
15180 ZVAL_TRUE(EX_VAR(opline->result.var));
15181 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
15182 /* The result and op1 can be the same cv zval */
15183 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
15184 ZVAL_FALSE(EX_VAR(opline->result.var));
15185 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
15186 SAVE_OPLINE();
15187 ZVAL_UNDEFINED_OP1();
15188 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15189 }
15190 } else {
15191 SAVE_OPLINE();
15192 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
15193 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15194 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15195 }
15196 ZEND_VM_NEXT_OPCODE();
15197 }
15198
ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15199 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15200 {
15201 USE_OPLINE
15202 zval *obj;
15203 zend_object *zobj;
15204 zend_class_entry *ce, *scope;
15205 zend_function *clone;
15206 zend_object_clone_obj_t clone_call;
15207
15208 SAVE_OPLINE();
15209 obj = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15210
15211 do {
15212 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
15213 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
15214 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
15215 obj = Z_REFVAL_P(obj);
15216 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
15217 break;
15218 }
15219 }
15220 ZVAL_UNDEF(EX_VAR(opline->result.var));
15221 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
15222 ZVAL_UNDEFINED_OP1();
15223 if (UNEXPECTED(EG(exception) != NULL)) {
15224 HANDLE_EXCEPTION();
15225 }
15226 }
15227 zend_throw_error(NULL, "__clone method called on non-object");
15228 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15229 HANDLE_EXCEPTION();
15230 }
15231 } while (0);
15232
15233 zobj = Z_OBJ_P(obj);
15234 ce = zobj->ce;
15235 clone = ce->clone;
15236 clone_call = zobj->handlers->clone_obj;
15237 if (UNEXPECTED(clone_call == NULL)) {
15238 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
15239 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15240 ZVAL_UNDEF(EX_VAR(opline->result.var));
15241 HANDLE_EXCEPTION();
15242 }
15243
15244 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
15245 scope = EX(func)->op_array.scope;
15246 if (clone->common.scope != scope) {
15247 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
15248 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
15249 zend_wrong_clone_call(clone, scope);
15250 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15251 ZVAL_UNDEF(EX_VAR(opline->result.var));
15252 HANDLE_EXCEPTION();
15253 }
15254 }
15255 }
15256
15257 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
15258
15259 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15260 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15261 }
15262
ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15263 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15264 {
15265 USE_OPLINE
15266 zend_op_array *new_op_array;
15267 zval *inc_filename;
15268
15269 SAVE_OPLINE();
15270 inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15271 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
15272 if (UNEXPECTED(EG(exception) != NULL)) {
15273 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15274 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
15275 destroy_op_array(new_op_array);
15276 efree_size(new_op_array, sizeof(zend_op_array));
15277 }
15278 UNDEF_RESULT();
15279 HANDLE_EXCEPTION();
15280 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
15281 if (RETURN_VALUE_USED(opline)) {
15282 ZVAL_TRUE(EX_VAR(opline->result.var));
15283 }
15284 } else if (UNEXPECTED(new_op_array == NULL)) {
15285 if (RETURN_VALUE_USED(opline)) {
15286 ZVAL_FALSE(EX_VAR(opline->result.var));
15287 }
15288 } else if (new_op_array->last == 1
15289 && new_op_array->opcodes[0].opcode == ZEND_RETURN
15290 && new_op_array->opcodes[0].op1_type == IS_CONST
15291 && EXPECTED(zend_execute_ex == execute_ex)) {
15292 if (RETURN_VALUE_USED(opline)) {
15293 const zend_op *op = new_op_array->opcodes;
15294
15295 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
15296 }
15297 zend_destroy_static_vars(new_op_array);
15298 destroy_op_array(new_op_array);
15299 efree_size(new_op_array, sizeof(zend_op_array));
15300 } else {
15301 zval *return_value = NULL;
15302 zend_execute_data *call;
15303 if (RETURN_VALUE_USED(opline)) {
15304 return_value = EX_VAR(opline->result.var);
15305 }
15306
15307 new_op_array->scope = EX(func)->op_array.scope;
15308
15309 call = zend_vm_stack_push_call_frame(
15310 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
15311 (zend_function*)new_op_array, 0,
15312 Z_PTR(EX(This)));
15313
15314 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
15315 call->symbol_table = EX(symbol_table);
15316 } else {
15317 call->symbol_table = zend_rebuild_symbol_table();
15318 }
15319
15320 call->prev_execute_data = execute_data;
15321 i_init_code_execute_data(call, new_op_array, return_value);
15322
15323 if (EXPECTED(zend_execute_ex == execute_ex)) {
15324 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15325 ZEND_VM_ENTER();
15326 } else {
15327 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
15328 zend_execute_ex(call);
15329 zend_vm_stack_free_call_frame(call);
15330 }
15331
15332 zend_destroy_static_vars(new_op_array);
15333 destroy_op_array(new_op_array);
15334 efree_size(new_op_array, sizeof(zend_op_array));
15335 if (UNEXPECTED(EG(exception) != NULL)) {
15336 zend_rethrow_exception(execute_data);
15337 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15338 UNDEF_RESULT();
15339 HANDLE_EXCEPTION();
15340 }
15341 }
15342 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15343 ZEND_VM_NEXT_OPCODE();
15344 }
15345
ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15346 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15347 {
15348 USE_OPLINE
15349 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
15350 zval *val;
15351
15352 SAVE_OPLINE();
15353 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15354
15355 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
15356 zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
15357 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15358 UNDEF_RESULT();
15359 HANDLE_EXCEPTION();
15360 }
15361
15362 yield_from_try_again:
15363 if (Z_TYPE_P(val) == IS_ARRAY) {
15364 ZVAL_COPY_VALUE(&generator->values, val);
15365 if (Z_OPT_REFCOUNTED_P(val)) {
15366 Z_ADDREF_P(val);
15367 }
15368 Z_FE_POS(generator->values) = 0;
15369 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15370 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
15371 zend_class_entry *ce = Z_OBJCE_P(val);
15372 if (ce == zend_ce_generator) {
15373 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
15374
15375 Z_ADDREF_P(val);
15376 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15377
15378 if (UNEXPECTED(new_gen->execute_data == NULL)) {
15379 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
15380 zval_ptr_dtor(val);
15381 UNDEF_RESULT();
15382 HANDLE_EXCEPTION();
15383 } else if (Z_ISUNDEF(new_gen->retval)) {
15384 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
15385 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
15386 zval_ptr_dtor(val);
15387 UNDEF_RESULT();
15388 HANDLE_EXCEPTION();
15389 } else {
15390 zend_generator_yield_from(generator, new_gen);
15391 }
15392 } else {
15393 if (RETURN_VALUE_USED(opline)) {
15394 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
15395 }
15396 ZEND_VM_NEXT_OPCODE();
15397 }
15398 } else {
15399 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
15400 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15401
15402 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
15403 if (!EG(exception)) {
15404 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
15405 }
15406 UNDEF_RESULT();
15407 HANDLE_EXCEPTION();
15408 }
15409
15410 iter->index = 0;
15411 if (iter->funcs->rewind) {
15412 iter->funcs->rewind(iter);
15413 if (UNEXPECTED(EG(exception) != NULL)) {
15414 OBJ_RELEASE(&iter->std);
15415 UNDEF_RESULT();
15416 HANDLE_EXCEPTION();
15417 }
15418 }
15419
15420 ZVAL_OBJ(&generator->values, &iter->std);
15421 }
15422 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
15423 val = Z_REFVAL_P(val);
15424 goto yield_from_try_again;
15425 } else {
15426 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
15427 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15428 UNDEF_RESULT();
15429 HANDLE_EXCEPTION();
15430 }
15431
15432 /* This is the default return value
15433 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
15434 if (RETURN_VALUE_USED(opline)) {
15435 ZVAL_NULL(EX_VAR(opline->result.var));
15436 }
15437
15438 /* This generator has no send target (though the generator we delegate to might have one) */
15439 generator->send_target = NULL;
15440
15441 /* The GOTO VM uses a local opline variable. We need to set the opline
15442 * variable in execute_data so we don't resume at an old position. */
15443 SAVE_OPLINE();
15444
15445 ZEND_VM_RETURN();
15446 }
15447
ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15448 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15449 {
15450 USE_OPLINE
15451 zval *value;
15452
15453 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15454 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15455 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15456 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15457 zval_ptr_dtor_str(value);
15458 }
15459 ZEND_VM_NEXT_OPCODE();
15460 } else {
15461 bool strict;
15462
15463 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
15464 value = Z_REFVAL_P(value);
15465 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15466 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15467 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15468 ZEND_VM_NEXT_OPCODE();
15469 }
15470 }
15471
15472 SAVE_OPLINE();
15473 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15474 value = ZVAL_UNDEFINED_OP1();
15475 }
15476 strict = EX_USES_STRICT_TYPES();
15477 do {
15478 if (EXPECTED(!strict)) {
15479 zend_string *str;
15480 zval tmp;
15481
15482 if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
15483 zend_error(E_DEPRECATED,
15484 "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
15485 ZVAL_LONG(EX_VAR(opline->result.var), 0);
15486 if (UNEXPECTED(EG(exception))) {
15487 HANDLE_EXCEPTION();
15488 }
15489 break;
15490 }
15491
15492 ZVAL_COPY(&tmp, value);
15493 if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
15494 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
15495 zval_ptr_dtor(&tmp);
15496 break;
15497 }
15498 zval_ptr_dtor(&tmp);
15499 }
15500 if (!EG(exception)) {
15501 zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
15502 }
15503 ZVAL_UNDEF(EX_VAR(opline->result.var));
15504 } while (0);
15505 }
15506 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15507 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15508 }
15509
ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15510 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15511 {
15512 USE_OPLINE
15513 zval *value;
15514 int result = 0;
15515
15516 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15517 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15518 type_check_resource:
15519 if (opline->extended_value != MAY_BE_RESOURCE
15520 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
15521 result = 1;
15522 }
15523 } else if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
15524 value = Z_REFVAL_P(value);
15525 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15526 goto type_check_resource;
15527 }
15528 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15529 result = ((1 << IS_NULL) & opline->extended_value) != 0;
15530 SAVE_OPLINE();
15531 ZVAL_UNDEFINED_OP1();
15532 if (UNEXPECTED(EG(exception))) {
15533 ZVAL_UNDEF(EX_VAR(opline->result.var));
15534 HANDLE_EXCEPTION();
15535 }
15536 }
15537 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15538 SAVE_OPLINE();
15539 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15540 ZEND_VM_SMART_BRANCH(result, 1);
15541 } else {
15542 ZEND_VM_SMART_BRANCH(result, 0);
15543 }
15544 }
15545
ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15546 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15547 {
15548 uint32_t fetch_type;
15549 zend_class_entry *called_scope, *scope;
15550 USE_OPLINE
15551
15552 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
15553 SAVE_OPLINE();
15554 zval *op = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15555 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
15556 ZVAL_DEREF(op);
15557 if (Z_TYPE_P(op) != IS_OBJECT) {
15558 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
15559 ZVAL_UNDEF(EX_VAR(opline->result.var));
15560 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15561 HANDLE_EXCEPTION();
15562 }
15563 }
15564
15565 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
15566 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15567 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15568 }
15569
15570 fetch_type = opline->op1.num;
15571 scope = EX(func)->op_array.scope;
15572 if (UNEXPECTED(scope == NULL)) {
15573 SAVE_OPLINE();
15574 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
15575 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
15576 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
15577 ZVAL_UNDEF(EX_VAR(opline->result.var));
15578 HANDLE_EXCEPTION();
15579 }
15580
15581 switch (fetch_type) {
15582 case ZEND_FETCH_CLASS_SELF:
15583 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
15584 break;
15585 case ZEND_FETCH_CLASS_PARENT:
15586 if (UNEXPECTED(scope->parent == NULL)) {
15587 SAVE_OPLINE();
15588 zend_throw_error(NULL,
15589 "Cannot use \"parent\" when current class scope has no parent");
15590 ZVAL_UNDEF(EX_VAR(opline->result.var));
15591 HANDLE_EXCEPTION();
15592 }
15593 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
15594 break;
15595 case ZEND_FETCH_CLASS_STATIC:
15596 if (Z_TYPE(EX(This)) == IS_OBJECT) {
15597 called_scope = Z_OBJCE(EX(This));
15598 } else {
15599 called_scope = Z_CE(EX(This));
15600 }
15601 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
15602 break;
15603 EMPTY_SWITCH_DEFAULT_CASE()
15604 }
15605 ZEND_VM_NEXT_OPCODE();
15606 }
15607
ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15608 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15609 {
15610 USE_OPLINE
15611 zval *op1, *op2;
15612
15613 SAVE_OPLINE();
15614 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15615 op2 = RT_CONSTANT(opline, opline->op2);
15616 div_function(EX_VAR(opline->result.var), op1, op2);
15617 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15618
15619 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15620 }
15621
ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15622 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15623 {
15624 USE_OPLINE
15625 zval *op1, *op2;
15626
15627 SAVE_OPLINE();
15628 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15629 op2 = RT_CONSTANT(opline, opline->op2);
15630 pow_function(EX_VAR(opline->result.var), op1, op2);
15631 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15632
15633 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15634 }
15635
ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15636 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15637 {
15638 USE_OPLINE
15639 zval *op1, *op2;
15640
15641 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15642 op2 = RT_CONSTANT(opline, opline->op2);
15643
15644 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
15645 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
15646 zend_string *op1_str = Z_STR_P(op1);
15647 zend_string *op2_str = Z_STR_P(op2);
15648 zend_string *str;
15649 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
15650
15651 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
15652 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
15653 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
15654 } else {
15655 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
15656 }
15657 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15658 zend_string_release_ex(op1_str, 0);
15659 }
15660 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
15661 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
15662 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
15663 } else {
15664 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
15665 }
15666 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15667 zend_string_release_ex(op2_str, 0);
15668 }
15669 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
15670 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
15671 size_t len = ZSTR_LEN(op1_str);
15672
15673 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
15674 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
15675 }
15676 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
15677 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15678 GC_ADD_FLAGS(str, flags);
15679 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15680 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15681 zend_string_release_ex(op2_str, 0);
15682 }
15683 } else {
15684 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
15685 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
15686 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15687 GC_ADD_FLAGS(str, flags);
15688 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15689 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15690 zend_string_release_ex(op1_str, 0);
15691 }
15692 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15693 zend_string_release_ex(op2_str, 0);
15694 }
15695 }
15696 ZEND_VM_NEXT_OPCODE();
15697 } else {
15698 SAVE_OPLINE();
15699
15700 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
15701 op1 = ZVAL_UNDEFINED_OP1();
15702 }
15703 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
15704 op2 = ZVAL_UNDEFINED_OP2();
15705 }
15706 concat_function(EX_VAR(opline->result.var), op1, op2);
15707 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15708
15709 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15710 }
15711 }
15712
ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15713 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15714 {
15715 USE_OPLINE
15716 zval *op1, *op2;
15717 double d1, d2;
15718
15719 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15720 op2 = RT_CONSTANT(opline, opline->op2);
15721 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15722 /* pass */
15723 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15724 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15725 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15726 is_equal_true:
15727 ZEND_VM_SMART_BRANCH_TRUE_NONE();
15728 } else {
15729 is_equal_false:
15730 ZEND_VM_SMART_BRANCH_FALSE_NONE();
15731 }
15732 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15733 d1 = (double)Z_LVAL_P(op1);
15734 d2 = Z_DVAL_P(op2);
15735 goto is_equal_double;
15736 }
15737 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15738 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15739 d1 = Z_DVAL_P(op1);
15740 d2 = Z_DVAL_P(op2);
15741 is_equal_double:
15742 if (d1 == d2) {
15743 goto is_equal_true;
15744 } else {
15745 goto is_equal_false;
15746 }
15747 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15748 d1 = Z_DVAL_P(op1);
15749 d2 = (double)Z_LVAL_P(op2);
15750 goto is_equal_double;
15751 }
15752 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15753 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15754 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15755 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15756 zval_ptr_dtor_str(op1);
15757 }
15758 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15759 zval_ptr_dtor_str(op2);
15760 }
15761 if (result) {
15762 goto is_equal_true;
15763 } else {
15764 goto is_equal_false;
15765 }
15766 }
15767 }
15768 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15769 }
15770
ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15771 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15772 {
15773 USE_OPLINE
15774 zval *op1, *op2;
15775 double d1, d2;
15776
15777 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15778 op2 = RT_CONSTANT(opline, opline->op2);
15779 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15780 /* pass */
15781 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15782 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15783 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15784 is_equal_true:
15785 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
15786 } else {
15787 is_equal_false:
15788 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
15789 }
15790 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15791 d1 = (double)Z_LVAL_P(op1);
15792 d2 = Z_DVAL_P(op2);
15793 goto is_equal_double;
15794 }
15795 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15796 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15797 d1 = Z_DVAL_P(op1);
15798 d2 = Z_DVAL_P(op2);
15799 is_equal_double:
15800 if (d1 == d2) {
15801 goto is_equal_true;
15802 } else {
15803 goto is_equal_false;
15804 }
15805 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15806 d1 = Z_DVAL_P(op1);
15807 d2 = (double)Z_LVAL_P(op2);
15808 goto is_equal_double;
15809 }
15810 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15811 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15812 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15813 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15814 zval_ptr_dtor_str(op1);
15815 }
15816 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15817 zval_ptr_dtor_str(op2);
15818 }
15819 if (result) {
15820 goto is_equal_true;
15821 } else {
15822 goto is_equal_false;
15823 }
15824 }
15825 }
15826 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15827 }
15828
ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15829 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15830 {
15831 USE_OPLINE
15832 zval *op1, *op2;
15833 double d1, d2;
15834
15835 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15836 op2 = RT_CONSTANT(opline, opline->op2);
15837 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15838 /* pass */
15839 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15840 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15841 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15842 is_equal_true:
15843 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
15844 } else {
15845 is_equal_false:
15846 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
15847 }
15848 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15849 d1 = (double)Z_LVAL_P(op1);
15850 d2 = Z_DVAL_P(op2);
15851 goto is_equal_double;
15852 }
15853 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15854 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15855 d1 = Z_DVAL_P(op1);
15856 d2 = Z_DVAL_P(op2);
15857 is_equal_double:
15858 if (d1 == d2) {
15859 goto is_equal_true;
15860 } else {
15861 goto is_equal_false;
15862 }
15863 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15864 d1 = Z_DVAL_P(op1);
15865 d2 = (double)Z_LVAL_P(op2);
15866 goto is_equal_double;
15867 }
15868 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15869 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15870 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15871 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15872 zval_ptr_dtor_str(op1);
15873 }
15874 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15875 zval_ptr_dtor_str(op2);
15876 }
15877 if (result) {
15878 goto is_equal_true;
15879 } else {
15880 goto is_equal_false;
15881 }
15882 }
15883 }
15884 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15885 }
15886
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15887 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15888 {
15889 USE_OPLINE
15890 zval *op1, *op2;
15891 double d1, d2;
15892
15893 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15894 op2 = RT_CONSTANT(opline, opline->op2);
15895 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15896 /* pass */
15897 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15898 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15899 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
15900 is_not_equal_true:
15901 ZEND_VM_SMART_BRANCH_TRUE_NONE();
15902 } else {
15903 is_not_equal_false:
15904 ZEND_VM_SMART_BRANCH_FALSE_NONE();
15905 }
15906 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15907 d1 = (double)Z_LVAL_P(op1);
15908 d2 = Z_DVAL_P(op2);
15909 goto is_not_equal_double;
15910 }
15911 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15912 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15913 d1 = Z_DVAL_P(op1);
15914 d2 = Z_DVAL_P(op2);
15915 is_not_equal_double:
15916 if (d1 != d2) {
15917 goto is_not_equal_true;
15918 } else {
15919 goto is_not_equal_false;
15920 }
15921 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15922 d1 = Z_DVAL_P(op1);
15923 d2 = (double)Z_LVAL_P(op2);
15924 goto is_not_equal_double;
15925 }
15926 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15927 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15928 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15929 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15930 zval_ptr_dtor_str(op1);
15931 }
15932 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15933 zval_ptr_dtor_str(op2);
15934 }
15935 if (!result) {
15936 goto is_not_equal_true;
15937 } else {
15938 goto is_not_equal_false;
15939 }
15940 }
15941 }
15942 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15943 }
15944
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15945 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15946 {
15947 USE_OPLINE
15948 zval *op1, *op2;
15949 double d1, d2;
15950
15951 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15952 op2 = RT_CONSTANT(opline, opline->op2);
15953 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15954 /* pass */
15955 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15956 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15957 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
15958 is_not_equal_true:
15959 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
15960 } else {
15961 is_not_equal_false:
15962 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
15963 }
15964 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15965 d1 = (double)Z_LVAL_P(op1);
15966 d2 = Z_DVAL_P(op2);
15967 goto is_not_equal_double;
15968 }
15969 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15970 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15971 d1 = Z_DVAL_P(op1);
15972 d2 = Z_DVAL_P(op2);
15973 is_not_equal_double:
15974 if (d1 != d2) {
15975 goto is_not_equal_true;
15976 } else {
15977 goto is_not_equal_false;
15978 }
15979 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15980 d1 = Z_DVAL_P(op1);
15981 d2 = (double)Z_LVAL_P(op2);
15982 goto is_not_equal_double;
15983 }
15984 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15985 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15986 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15987 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15988 zval_ptr_dtor_str(op1);
15989 }
15990 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15991 zval_ptr_dtor_str(op2);
15992 }
15993 if (!result) {
15994 goto is_not_equal_true;
15995 } else {
15996 goto is_not_equal_false;
15997 }
15998 }
15999 }
16000 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16001 }
16002
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16003 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16004 {
16005 USE_OPLINE
16006 zval *op1, *op2;
16007 double d1, d2;
16008
16009 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16010 op2 = RT_CONSTANT(opline, opline->op2);
16011 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
16012 /* pass */
16013 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16014 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16015 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
16016 is_not_equal_true:
16017 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
16018 } else {
16019 is_not_equal_false:
16020 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
16021 }
16022 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16023 d1 = (double)Z_LVAL_P(op1);
16024 d2 = Z_DVAL_P(op2);
16025 goto is_not_equal_double;
16026 }
16027 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16028 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16029 d1 = Z_DVAL_P(op1);
16030 d2 = Z_DVAL_P(op2);
16031 is_not_equal_double:
16032 if (d1 != d2) {
16033 goto is_not_equal_true;
16034 } else {
16035 goto is_not_equal_false;
16036 }
16037 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16038 d1 = Z_DVAL_P(op1);
16039 d2 = (double)Z_LVAL_P(op2);
16040 goto is_not_equal_double;
16041 }
16042 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16043 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16044 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16045 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16046 zval_ptr_dtor_str(op1);
16047 }
16048 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16049 zval_ptr_dtor_str(op2);
16050 }
16051 if (!result) {
16052 goto is_not_equal_true;
16053 } else {
16054 goto is_not_equal_false;
16055 }
16056 }
16057 }
16058 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16059 }
16060
ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16061 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16062 {
16063 USE_OPLINE
16064 zval *op1, *op2;
16065
16066 SAVE_OPLINE();
16067 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16068 op2 = RT_CONSTANT(opline, opline->op2);
16069 compare_function(EX_VAR(opline->result.var), op1, op2);
16070 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16071
16072 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16073 }
16074
ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16075 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16076 {
16077 USE_OPLINE
16078 zval *op1, *op2;
16079
16080 SAVE_OPLINE();
16081 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16082 op2 = RT_CONSTANT(opline, opline->op2);
16083 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
16084 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16085
16086 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16087 }
16088
ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16089 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16090 {
16091 USE_OPLINE
16092 zval *container, *dim, *value;
16093
16094 SAVE_OPLINE();
16095 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16096 dim = RT_CONSTANT(opline, opline->op2);
16097 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16098 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16099 fetch_dim_r_array:
16100 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
16101 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
16102 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
16103 container = Z_REFVAL_P(container);
16104 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16105 goto fetch_dim_r_array;
16106 } else {
16107 goto fetch_dim_r_slow;
16108 }
16109 } else {
16110 fetch_dim_r_slow:
16111 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
16112 dim++;
16113 }
16114 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
16115 }
16116 } else {
16117 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
16118 }
16119
16120 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16121 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16122 }
16123
ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16124 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16125 {
16126 USE_OPLINE
16127 zval *container;
16128
16129 SAVE_OPLINE();
16130 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16131 zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
16132
16133 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16134 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16135 }
16136
ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16137 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16138 {
16139 USE_OPLINE
16140 zval *container;
16141 void **cache_slot = NULL;
16142
16143 SAVE_OPLINE();
16144 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16145
16146 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16147 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16148 do {
16149 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16150 container = Z_REFVAL_P(container);
16151 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
16152 break;
16153 }
16154 }
16155 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
16156 ZVAL_UNDEFINED_OP1();
16157 }
16158 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
16159 ZVAL_NULL(EX_VAR(opline->result.var));
16160 goto fetch_obj_r_finish;
16161 } while (0);
16162 }
16163
16164 /* here we are sure we are dealing with an object */
16165 do {
16166 zend_object *zobj = Z_OBJ_P(container);
16167 zend_string *name, *tmp_name;
16168 zval *retval;
16169
16170 if (IS_CONST == IS_CONST) {
16171 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
16172
16173 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
16174 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
16175
16176 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
16177 fetch_obj_r_simple:
16178 retval = OBJ_PROP(zobj, prop_offset);
16179 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
16180 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16181 goto fetch_obj_r_copy;
16182 } else {
16183 fetch_obj_r_fast_copy:
16184 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16185 ZEND_VM_NEXT_OPCODE();
16186 }
16187 }
16188 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
16189 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
16190 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
16191 prop_offset = prop_info->offset;
16192 goto fetch_obj_r_simple;
16193 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
16194 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
16195 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
16196 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
16197
16198 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
16199 if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
16200 GC_ADDREF(zobj);
16201 }
16202 if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
16203 call_info |= ZEND_CALL_RELEASE_THIS;
16204 }
16205 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
16206 call->prev_execute_data = execute_data;
16207 call->call = NULL;
16208 call->return_value = EX_VAR(opline->result.var);
16209 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
16210
16211 execute_data = call;
16212 EG(current_execute_data) = execute_data;
16213 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
16214
16215 #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
16216 opline = hook->op_array.opcodes;
16217 #else
16218 EX(opline) = hook->op_array.opcodes;
16219 #endif
16220 LOAD_OPLINE_EX();
16221
16222
16223 ZEND_VM_ENTER_EX();
16224 }
16225 /* Fall through to read_property for hooks. */
16226 } else if (EXPECTED(zobj->properties != NULL)) {
16227 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
16228 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16229 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
16230 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
16231
16232 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
16233 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
16234
16235 if (EXPECTED(p->key == name) ||
16236 (EXPECTED(p->h == ZSTR_H(name)) &&
16237 EXPECTED(p->key != NULL) &&
16238 EXPECTED(zend_string_equal_content(p->key, name)))) {
16239 retval = &p->val;
16240 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16241 goto fetch_obj_r_copy;
16242 } else {
16243 goto fetch_obj_r_fast_copy;
16244 }
16245 }
16246 }
16247 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
16248 }
16249 retval = zend_hash_find_known_hash(zobj->properties, name);
16250 if (EXPECTED(retval)) {
16251 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
16252 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
16253 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16254 goto fetch_obj_r_copy;
16255 } else {
16256 goto fetch_obj_r_fast_copy;
16257 }
16258 }
16259 }
16260 }
16261 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16262 } else {
16263 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
16264 if (UNEXPECTED(!name)) {
16265 ZVAL_UNDEF(EX_VAR(opline->result.var));
16266 break;
16267 }
16268 }
16269
16270 #if ZEND_DEBUG
16271 /* For non-standard object handlers, verify a declared property type in debug builds.
16272 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
16273 zend_property_info *prop_info = NULL;
16274 if (zobj->handlers->read_property != zend_std_read_property) {
16275 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
16276 }
16277 #endif
16278 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
16279 #if ZEND_DEBUG
16280 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
16281 && ZEND_TYPE_IS_SET(prop_info->type)) {
16282 ZVAL_OPT_DEREF(retval);
16283 zend_verify_property_type(prop_info, retval, /* strict */ true);
16284 }
16285 #endif
16286
16287 if (IS_CONST != IS_CONST) {
16288 zend_tmp_string_release(tmp_name);
16289 }
16290
16291 if (retval != EX_VAR(opline->result.var)) {
16292 fetch_obj_r_copy:
16293 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16294 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
16295 zend_unwrap_reference(retval);
16296 }
16297 } while (0);
16298
16299 fetch_obj_r_finish:
16300
16301 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16302 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16303 }
16304
ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16305 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16306 {
16307 USE_OPLINE
16308 zval *container;
16309 void **cache_slot = NULL;
16310
16311 SAVE_OPLINE();
16312 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16313
16314 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16315 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16316 do {
16317 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16318 container = Z_REFVAL_P(container);
16319 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
16320 break;
16321 }
16322 }
16323 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
16324 ZVAL_UNDEFINED_OP2();
16325 }
16326 ZVAL_NULL(EX_VAR(opline->result.var));
16327 goto fetch_obj_is_finish;
16328 } while (0);
16329 }
16330
16331 /* here we are sure we are dealing with an object */
16332 do {
16333 zend_object *zobj = Z_OBJ_P(container);
16334 zend_string *name, *tmp_name;
16335 zval *retval;
16336
16337 if (IS_CONST == IS_CONST) {
16338 cache_slot = CACHE_ADDR(opline->extended_value);
16339
16340 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
16341 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
16342
16343 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
16344 fetch_obj_is_simple:
16345 retval = OBJ_PROP(zobj, prop_offset);
16346 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
16347 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16348 goto fetch_obj_is_copy;
16349 } else {
16350 fetch_obj_is_fast_copy:
16351 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16352 ZEND_VM_NEXT_OPCODE();
16353 }
16354 }
16355 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
16356 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
16357 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
16358 prop_offset = prop_info->offset;
16359 goto fetch_obj_is_simple;
16360 }
16361 /* Fall through to read_property for hooks. */
16362 } else if (EXPECTED(zobj->properties != NULL)) {
16363 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
16364 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16365 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
16366 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
16367
16368 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
16369 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
16370
16371 if (EXPECTED(p->key == name) ||
16372 (EXPECTED(p->h == ZSTR_H(name)) &&
16373 EXPECTED(p->key != NULL) &&
16374 EXPECTED(zend_string_equal_content(p->key, name)))) {
16375 retval = &p->val;
16376 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16377 goto fetch_obj_is_copy;
16378 } else {
16379 goto fetch_obj_is_fast_copy;
16380 }
16381 }
16382 }
16383 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
16384 }
16385 retval = zend_hash_find_known_hash(zobj->properties, name);
16386 if (EXPECTED(retval)) {
16387 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
16388 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
16389 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
16390 goto fetch_obj_is_copy;
16391 } else {
16392 goto fetch_obj_is_fast_copy;
16393 }
16394 }
16395 }
16396 }
16397 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16398 } else {
16399 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
16400 if (UNEXPECTED(!name)) {
16401 ZVAL_UNDEF(EX_VAR(opline->result.var));
16402 break;
16403 }
16404 }
16405
16406 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
16407
16408 if (IS_CONST != IS_CONST) {
16409 zend_tmp_string_release(tmp_name);
16410 }
16411
16412 if (retval != EX_VAR(opline->result.var)) {
16413 fetch_obj_is_copy:
16414 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16415 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
16416 zend_unwrap_reference(retval);
16417 }
16418 } while (0);
16419
16420 fetch_obj_is_finish:
16421
16422 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16423 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16424 }
16425
ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16426 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16427 {
16428 USE_OPLINE
16429 zval *op1, *op2;
16430 zend_string *op1_str, *op2_str, *str;
16431
16432
16433 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16434 op2 = RT_CONSTANT(opline, opline->op2);
16435 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
16436 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
16437 zend_string *op1_str = Z_STR_P(op1);
16438 zend_string *op2_str = Z_STR_P(op2);
16439 zend_string *str;
16440 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
16441
16442 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16443 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
16444 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
16445 } else {
16446 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16447 }
16448 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16449 zend_string_release_ex(op1_str, 0);
16450 }
16451 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16452 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
16453 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
16454 } else {
16455 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16456 }
16457 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16458 zend_string_release_ex(op2_str, 0);
16459 }
16460 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
16461 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
16462 size_t len = ZSTR_LEN(op1_str);
16463
16464 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
16465 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16466 GC_ADD_FLAGS(str, flags);
16467 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16468 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16469 zend_string_release_ex(op2_str, 0);
16470 }
16471 } else {
16472 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16473 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16474 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16475 GC_ADD_FLAGS(str, flags);
16476 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16477 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16478 zend_string_release_ex(op1_str, 0);
16479 }
16480 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16481 zend_string_release_ex(op2_str, 0);
16482 }
16483 }
16484 ZEND_VM_NEXT_OPCODE();
16485 }
16486
16487 SAVE_OPLINE();
16488 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16489 op1_str = Z_STR_P(op1);
16490 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16491 op1_str = zend_string_copy(Z_STR_P(op1));
16492 } else {
16493 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
16494 ZVAL_UNDEFINED_OP1();
16495 }
16496 op1_str = zval_get_string_func(op1);
16497 }
16498 if (IS_CONST == IS_CONST) {
16499 op2_str = Z_STR_P(op2);
16500 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16501 op2_str = zend_string_copy(Z_STR_P(op2));
16502 } else {
16503 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
16504 ZVAL_UNDEFINED_OP2();
16505 }
16506 op2_str = zval_get_string_func(op2);
16507 }
16508 do {
16509 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16510 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16511 if (IS_CONST == IS_CONST) {
16512 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
16513 GC_ADDREF(op2_str);
16514 }
16515 }
16516 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16517 zend_string_release_ex(op1_str, 0);
16518 break;
16519 }
16520 }
16521 if (IS_CONST != IS_CONST) {
16522 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16523 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16524 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
16525 GC_ADDREF(op1_str);
16526 }
16527 }
16528 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16529 zend_string_release_ex(op2_str, 0);
16530 break;
16531 }
16532 }
16533 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16534 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16535 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16536
16537 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
16538 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16539 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16540 zend_string_release_ex(op1_str, 0);
16541 }
16542 if (IS_CONST != IS_CONST) {
16543 zend_string_release_ex(op2_str, 0);
16544 }
16545 } while (0);
16546 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16547
16548 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16549 }
16550
ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16551 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16552 {
16553 USE_OPLINE
16554 zval *function_name;
16555 zval *object;
16556 zend_function *fbc;
16557 zend_class_entry *called_scope;
16558 zend_object *obj;
16559 zend_execute_data *call;
16560 uint32_t call_info;
16561
16562 SAVE_OPLINE();
16563
16564 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16565
16566 if (IS_CONST != IS_CONST) {
16567 function_name = RT_CONSTANT(opline, opline->op2);
16568 }
16569
16570 if (IS_CONST != IS_CONST &&
16571 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
16572 do {
16573 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
16574 function_name = Z_REFVAL_P(function_name);
16575 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
16576 break;
16577 }
16578 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
16579 ZVAL_UNDEFINED_OP2();
16580 if (UNEXPECTED(EG(exception) != NULL)) {
16581 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16582 HANDLE_EXCEPTION();
16583 }
16584 }
16585 zend_throw_error(NULL, "Method name must be a string");
16586
16587 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16588 HANDLE_EXCEPTION();
16589 } while (0);
16590 }
16591
16592 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
16593 obj = Z_OBJ_P(object);
16594 } else {
16595 do {
16596 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16597 obj = Z_OBJ_P(object);
16598 } else {
16599 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
16600 zend_reference *ref = Z_REF_P(object);
16601
16602 object = &ref->val;
16603 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16604 obj = Z_OBJ_P(object);
16605 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
16606 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
16607 efree_size(ref, sizeof(zend_reference));
16608 } else {
16609 Z_ADDREF_P(object);
16610 }
16611 }
16612 break;
16613 }
16614 }
16615 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
16616 object = ZVAL_UNDEFINED_OP1();
16617 if (UNEXPECTED(EG(exception) != NULL)) {
16618 if (IS_CONST != IS_CONST) {
16619
16620 }
16621 HANDLE_EXCEPTION();
16622 }
16623 }
16624 if (IS_CONST == IS_CONST) {
16625 function_name = RT_CONSTANT(opline, opline->op2);
16626 }
16627 zend_invalid_method_call(object, function_name);
16628
16629 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16630 HANDLE_EXCEPTION();
16631 }
16632 } while (0);
16633 }
16634
16635 called_scope = obj->ce;
16636
16637 if (IS_CONST == IS_CONST &&
16638 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
16639 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
16640 } else {
16641 zend_object *orig_obj = obj;
16642
16643 if (IS_CONST == IS_CONST) {
16644 function_name = RT_CONSTANT(opline, opline->op2);
16645 }
16646
16647 /* First, locate the function. */
16648 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
16649 if (UNEXPECTED(fbc == NULL)) {
16650 if (EXPECTED(!EG(exception))) {
16651 zend_undefined_method(obj->ce, Z_STR_P(function_name));
16652 }
16653
16654 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
16655 zend_objects_store_del(orig_obj);
16656 }
16657 HANDLE_EXCEPTION();
16658 }
16659 if (IS_CONST == IS_CONST &&
16660 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
16661 EXPECTED(obj == orig_obj)) {
16662 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
16663 }
16664 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
16665 GC_ADDREF(obj); /* For $this pointer */
16666 if (GC_DELREF(orig_obj) == 0) {
16667 zend_objects_store_del(orig_obj);
16668 }
16669 }
16670 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
16671 init_func_run_time_cache(&fbc->op_array);
16672 }
16673 }
16674
16675 if (IS_CONST != IS_CONST) {
16676
16677 }
16678
16679 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
16680 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
16681 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
16682 zend_objects_store_del(obj);
16683 if (UNEXPECTED(EG(exception))) {
16684 HANDLE_EXCEPTION();
16685 }
16686 }
16687 /* call static method */
16688 obj = (zend_object*)called_scope;
16689 call_info = ZEND_CALL_NESTED_FUNCTION;
16690 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
16691 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
16692 GC_ADDREF(obj); /* For $this pointer */
16693 }
16694 /* CV may be changed indirectly (e.g. when it's a reference) */
16695 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
16696 }
16697
16698 call = zend_vm_stack_push_call_frame(call_info,
16699 fbc, opline->extended_value, obj);
16700 call->prev_execute_data = EX(call);
16701 EX(call) = call;
16702
16703 ZEND_VM_NEXT_OPCODE();
16704 }
16705
ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16706 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16707 {
16708 USE_OPLINE
16709 zval *value, *arg;
16710
16711 if (IS_CONST == IS_CONST) {
16712 SAVE_OPLINE();
16713 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16714 uint32_t arg_num;
16715 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
16716 if (UNEXPECTED(!arg)) {
16717 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16718 HANDLE_EXCEPTION();
16719 }
16720 } else {
16721 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
16722 }
16723
16724 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16725 ZVAL_COPY_VALUE(arg, value);
16726 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16727 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
16728 Z_ADDREF_P(arg);
16729 }
16730 }
16731 ZEND_VM_NEXT_OPCODE();
16732 }
16733
ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16734 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16735 {
16736 USE_OPLINE
16737 zval *op1, *op2;
16738 double d1, d2;
16739
16740 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16741 op2 = RT_CONSTANT(opline, opline->op2);
16742 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16743 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16744 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16745 case_true:
16746 ZEND_VM_SMART_BRANCH_TRUE();
16747 } else {
16748 case_false:
16749 ZEND_VM_SMART_BRANCH_FALSE();
16750 }
16751 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16752 d1 = (double)Z_LVAL_P(op1);
16753 d2 = Z_DVAL_P(op2);
16754 goto case_double;
16755 }
16756 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16757 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16758 d1 = Z_DVAL_P(op1);
16759 d2 = Z_DVAL_P(op2);
16760 case_double:
16761 if (d1 == d2) {
16762 goto case_true;
16763 } else {
16764 goto case_false;
16765 }
16766 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16767 d1 = Z_DVAL_P(op1);
16768 d2 = (double)Z_LVAL_P(op2);
16769 goto case_double;
16770 }
16771 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16772 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16773 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16774
16775 if (result) {
16776 goto case_true;
16777 } else {
16778 goto case_false;
16779 }
16780 }
16781 }
16782 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16783 }
16784
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16785 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16786 {
16787 USE_OPLINE
16788 zval *container;
16789 bool result;
16790 zend_ulong hval;
16791 zval *offset;
16792
16793 SAVE_OPLINE();
16794 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16795 offset = RT_CONSTANT(opline, opline->op2);
16796
16797 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16798 HashTable *ht;
16799 zval *value;
16800 zend_string *str;
16801
16802 isset_dim_obj_array:
16803 ht = Z_ARRVAL_P(container);
16804 isset_again:
16805 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
16806 str = Z_STR_P(offset);
16807 if (IS_CONST != IS_CONST) {
16808 if (ZEND_HANDLE_NUMERIC(str, hval)) {
16809 goto num_index_prop;
16810 }
16811 }
16812 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
16813 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
16814 hval = Z_LVAL_P(offset);
16815 num_index_prop:
16816 value = zend_hash_index_find(ht, hval);
16817 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
16818 offset = Z_REFVAL_P(offset);
16819 goto isset_again;
16820 } else {
16821 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
16822 if (UNEXPECTED(EG(exception))) {
16823 result = 0;
16824 goto isset_dim_obj_exit;
16825 }
16826 }
16827
16828 if (!(opline->extended_value & ZEND_ISEMPTY)) {
16829 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
16830 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
16831 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
16832
16833 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
16834 /* avoid exception check */
16835
16836 ZEND_VM_SMART_BRANCH(result, 0);
16837 }
16838 } else {
16839 result = (value == NULL || !i_zend_is_true(value));
16840 }
16841 goto isset_dim_obj_exit;
16842 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
16843 container = Z_REFVAL_P(container);
16844 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16845 goto isset_dim_obj_array;
16846 }
16847 }
16848
16849 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
16850 offset++;
16851 }
16852 if (!(opline->extended_value & ZEND_ISEMPTY)) {
16853 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
16854 } else {
16855 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
16856 }
16857
16858 isset_dim_obj_exit:
16859
16860 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16861 ZEND_VM_SMART_BRANCH(result, 1);
16862 }
16863
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16864 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16865 {
16866 USE_OPLINE
16867 zval *container;
16868 int result;
16869 zval *offset;
16870 zend_string *name, *tmp_name;
16871
16872 SAVE_OPLINE();
16873 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16874 offset = RT_CONSTANT(opline, opline->op2);
16875
16876 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16877 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16878 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16879 container = Z_REFVAL_P(container);
16880 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
16881 result = (opline->extended_value & ZEND_ISEMPTY);
16882 goto isset_object_finish;
16883 }
16884 } else {
16885 result = (opline->extended_value & ZEND_ISEMPTY);
16886 goto isset_object_finish;
16887 }
16888 }
16889
16890 if (IS_CONST == IS_CONST) {
16891 name = Z_STR_P(offset);
16892 } else {
16893 name = zval_try_get_tmp_string(offset, &tmp_name);
16894 if (UNEXPECTED(!name)) {
16895 result = 0;
16896 goto isset_object_finish;
16897 }
16898 }
16899
16900 result =
16901 (opline->extended_value & ZEND_ISEMPTY) ^
16902 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));
16903
16904 if (IS_CONST != IS_CONST) {
16905 zend_tmp_string_release(tmp_name);
16906 }
16907
16908 isset_object_finish:
16909
16910 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16911 ZEND_VM_SMART_BRANCH(result, 1);
16912 }
16913
ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16914 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16915 {
16916 USE_OPLINE
16917
16918 zval *key, *subject;
16919 HashTable *ht;
16920 bool result;
16921
16922 SAVE_OPLINE();
16923
16924 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16925 subject = RT_CONSTANT(opline, opline->op2);
16926
16927 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
16928 array_key_exists_array:
16929 ht = Z_ARRVAL_P(subject);
16930 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
16931 } else {
16932 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
16933 subject = Z_REFVAL_P(subject);
16934 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
16935 goto array_key_exists_array;
16936 }
16937 }
16938 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
16939 result = 0;
16940 }
16941
16942 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16943 ZEND_VM_SMART_BRANCH(result, 1);
16944 }
16945
ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16946 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16947 {
16948 USE_OPLINE
16949 zval *expr;
16950 bool result;
16951
16952 SAVE_OPLINE();
16953 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16954
16955 try_instanceof:
16956 if (Z_TYPE_P(expr) == IS_OBJECT) {
16957 zend_class_entry *ce;
16958
16959 if (IS_CONST == IS_CONST) {
16960 ce = CACHED_PTR(opline->extended_value);
16961 if (UNEXPECTED(ce == NULL)) {
16962 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);
16963 if (EXPECTED(ce)) {
16964 CACHE_PTR(opline->extended_value, ce);
16965 }
16966 }
16967 } else if (IS_CONST == IS_UNUSED) {
16968 ce = zend_fetch_class(NULL, opline->op2.num);
16969 if (UNEXPECTED(ce == NULL)) {
16970 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16971 ZVAL_UNDEF(EX_VAR(opline->result.var));
16972 HANDLE_EXCEPTION();
16973 }
16974 } else {
16975 ce = Z_CE_P(EX_VAR(opline->op2.var));
16976 }
16977 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
16978 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
16979 expr = Z_REFVAL_P(expr);
16980 goto try_instanceof;
16981 } else {
16982 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
16983 ZVAL_UNDEFINED_OP1();
16984 }
16985 result = 0;
16986 }
16987 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16988 ZEND_VM_SMART_BRANCH(result, 1);
16989 }
16990
ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16991 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16992 {
16993 USE_OPLINE
16994 zval *container, *dim, *value;
16995 zend_long offset;
16996 HashTable *ht;
16997
16998 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16999 dim = RT_CONSTANT(opline, opline->op2);
17000 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17001 fetch_dim_r_index_array:
17002 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
17003 offset = Z_LVAL_P(dim);
17004 } else {
17005 SAVE_OPLINE();
17006 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
17007 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17008 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17009 }
17010 ht = Z_ARRVAL_P(container);
17011 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
17012 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17013 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17014 SAVE_OPLINE();
17015 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17016 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17017 } else {
17018 ZEND_VM_NEXT_OPCODE();
17019 }
17020 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17021 container = Z_REFVAL_P(container);
17022 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17023 goto fetch_dim_r_index_array;
17024 } else {
17025 goto fetch_dim_r_index_slow;
17026 }
17027 } else {
17028 fetch_dim_r_index_slow:
17029 SAVE_OPLINE();
17030 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17031 dim++;
17032 }
17033 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17034 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17035 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17036 }
17037
17038 fetch_dim_r_index_undef:
17039 ZVAL_NULL(EX_VAR(opline->result.var));
17040 SAVE_OPLINE();
17041 zend_undefined_offset(offset);
17042 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17043 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17044 }
17045
ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17046 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17047 {
17048 USE_OPLINE
17049 zval *container, *dim, *value;
17050 zend_long offset;
17051 HashTable *ht;
17052
17053 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17054 dim = EX_VAR(opline->op2.var);
17055 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17056 fetch_dim_r_index_array:
17057 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
17058 offset = Z_LVAL_P(dim);
17059 } else {
17060 SAVE_OPLINE();
17061 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
17062 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17063 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17064 }
17065 ht = Z_ARRVAL_P(container);
17066 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
17067 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17068 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17069 SAVE_OPLINE();
17070 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17071 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17072 } else {
17073 ZEND_VM_NEXT_OPCODE();
17074 }
17075 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17076 container = Z_REFVAL_P(container);
17077 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17078 goto fetch_dim_r_index_array;
17079 } else {
17080 goto fetch_dim_r_index_slow;
17081 }
17082 } else {
17083 fetch_dim_r_index_slow:
17084 SAVE_OPLINE();
17085 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17086 dim++;
17087 }
17088 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17089 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17090 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17091 }
17092
17093 fetch_dim_r_index_undef:
17094 ZVAL_NULL(EX_VAR(opline->result.var));
17095 SAVE_OPLINE();
17096 zend_undefined_offset(offset);
17097 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17098 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17099 }
17100
ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17101 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17102 {
17103 USE_OPLINE
17104 zval *op1, *op2;
17105
17106 SAVE_OPLINE();
17107 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17108 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17109 div_function(EX_VAR(opline->result.var), op1, op2);
17110 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17111 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17112 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17113 }
17114
ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17115 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17116 {
17117 USE_OPLINE
17118 zval *op1, *op2;
17119
17120 SAVE_OPLINE();
17121 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17122 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17123 pow_function(EX_VAR(opline->result.var), op1, op2);
17124 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17125 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17126 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17127 }
17128
ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17129 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17130 {
17131 USE_OPLINE
17132 zval *op1, *op2;
17133
17134 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17135 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17136
17137 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
17138 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
17139 zend_string *op1_str = Z_STR_P(op1);
17140 zend_string *op2_str = Z_STR_P(op2);
17141 zend_string *str;
17142 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
17143
17144 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
17145 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17146 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
17147 } else {
17148 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
17149 }
17150 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17151 zend_string_release_ex(op1_str, 0);
17152 }
17153 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
17154 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17155 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
17156 } else {
17157 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
17158 }
17159 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17160 zend_string_release_ex(op2_str, 0);
17161 }
17162 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
17163 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
17164 size_t len = ZSTR_LEN(op1_str);
17165
17166 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
17167 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
17168 }
17169 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
17170 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17171 GC_ADD_FLAGS(str, flags);
17172 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17173 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17174 zend_string_release_ex(op2_str, 0);
17175 }
17176 } else {
17177 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
17178 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
17179 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17180 GC_ADD_FLAGS(str, flags);
17181 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17182 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17183 zend_string_release_ex(op1_str, 0);
17184 }
17185 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17186 zend_string_release_ex(op2_str, 0);
17187 }
17188 }
17189 ZEND_VM_NEXT_OPCODE();
17190 } else {
17191 SAVE_OPLINE();
17192
17193 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
17194 op1 = ZVAL_UNDEFINED_OP1();
17195 }
17196 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
17197 op2 = ZVAL_UNDEFINED_OP2();
17198 }
17199 concat_function(EX_VAR(opline->result.var), op1, op2);
17200 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17201 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17202 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17203 }
17204 }
17205
ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17206 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17207 {
17208 USE_OPLINE
17209 zval *op1, *op2;
17210 double d1, d2;
17211
17212 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17213 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17214 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17215 /* pass */
17216 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17217 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17218 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17219 is_equal_true:
17220 ZEND_VM_SMART_BRANCH_TRUE_NONE();
17221 } else {
17222 is_equal_false:
17223 ZEND_VM_SMART_BRANCH_FALSE_NONE();
17224 }
17225 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17226 d1 = (double)Z_LVAL_P(op1);
17227 d2 = Z_DVAL_P(op2);
17228 goto is_equal_double;
17229 }
17230 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17231 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17232 d1 = Z_DVAL_P(op1);
17233 d2 = Z_DVAL_P(op2);
17234 is_equal_double:
17235 if (d1 == d2) {
17236 goto is_equal_true;
17237 } else {
17238 goto is_equal_false;
17239 }
17240 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17241 d1 = Z_DVAL_P(op1);
17242 d2 = (double)Z_LVAL_P(op2);
17243 goto is_equal_double;
17244 }
17245 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17246 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17247 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17248 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17249 zval_ptr_dtor_str(op1);
17250 }
17251 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17252 zval_ptr_dtor_str(op2);
17253 }
17254 if (result) {
17255 goto is_equal_true;
17256 } else {
17257 goto is_equal_false;
17258 }
17259 }
17260 }
17261 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17262 }
17263
ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17264 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17265 {
17266 USE_OPLINE
17267 zval *op1, *op2;
17268 double d1, d2;
17269
17270 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17271 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17272 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17273 /* pass */
17274 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17275 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17276 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17277 is_equal_true:
17278 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
17279 } else {
17280 is_equal_false:
17281 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
17282 }
17283 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17284 d1 = (double)Z_LVAL_P(op1);
17285 d2 = Z_DVAL_P(op2);
17286 goto is_equal_double;
17287 }
17288 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17289 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17290 d1 = Z_DVAL_P(op1);
17291 d2 = Z_DVAL_P(op2);
17292 is_equal_double:
17293 if (d1 == d2) {
17294 goto is_equal_true;
17295 } else {
17296 goto is_equal_false;
17297 }
17298 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17299 d1 = Z_DVAL_P(op1);
17300 d2 = (double)Z_LVAL_P(op2);
17301 goto is_equal_double;
17302 }
17303 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17304 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17305 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17306 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17307 zval_ptr_dtor_str(op1);
17308 }
17309 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17310 zval_ptr_dtor_str(op2);
17311 }
17312 if (result) {
17313 goto is_equal_true;
17314 } else {
17315 goto is_equal_false;
17316 }
17317 }
17318 }
17319 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17320 }
17321
ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17322 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17323 {
17324 USE_OPLINE
17325 zval *op1, *op2;
17326 double d1, d2;
17327
17328 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17329 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17330 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17331 /* pass */
17332 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17333 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17334 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17335 is_equal_true:
17336 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
17337 } else {
17338 is_equal_false:
17339 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
17340 }
17341 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17342 d1 = (double)Z_LVAL_P(op1);
17343 d2 = Z_DVAL_P(op2);
17344 goto is_equal_double;
17345 }
17346 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17347 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17348 d1 = Z_DVAL_P(op1);
17349 d2 = Z_DVAL_P(op2);
17350 is_equal_double:
17351 if (d1 == d2) {
17352 goto is_equal_true;
17353 } else {
17354 goto is_equal_false;
17355 }
17356 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17357 d1 = Z_DVAL_P(op1);
17358 d2 = (double)Z_LVAL_P(op2);
17359 goto is_equal_double;
17360 }
17361 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17362 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17363 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17364 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17365 zval_ptr_dtor_str(op1);
17366 }
17367 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17368 zval_ptr_dtor_str(op2);
17369 }
17370 if (result) {
17371 goto is_equal_true;
17372 } else {
17373 goto is_equal_false;
17374 }
17375 }
17376 }
17377 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17378 }
17379
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17380 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17381 {
17382 USE_OPLINE
17383 zval *op1, *op2;
17384 double d1, d2;
17385
17386 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17387 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17388 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17389 /* pass */
17390 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17391 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17392 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17393 is_not_equal_true:
17394 ZEND_VM_SMART_BRANCH_TRUE_NONE();
17395 } else {
17396 is_not_equal_false:
17397 ZEND_VM_SMART_BRANCH_FALSE_NONE();
17398 }
17399 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17400 d1 = (double)Z_LVAL_P(op1);
17401 d2 = Z_DVAL_P(op2);
17402 goto is_not_equal_double;
17403 }
17404 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17405 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17406 d1 = Z_DVAL_P(op1);
17407 d2 = Z_DVAL_P(op2);
17408 is_not_equal_double:
17409 if (d1 != d2) {
17410 goto is_not_equal_true;
17411 } else {
17412 goto is_not_equal_false;
17413 }
17414 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17415 d1 = Z_DVAL_P(op1);
17416 d2 = (double)Z_LVAL_P(op2);
17417 goto is_not_equal_double;
17418 }
17419 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17420 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17421 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17422 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17423 zval_ptr_dtor_str(op1);
17424 }
17425 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17426 zval_ptr_dtor_str(op2);
17427 }
17428 if (!result) {
17429 goto is_not_equal_true;
17430 } else {
17431 goto is_not_equal_false;
17432 }
17433 }
17434 }
17435 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17436 }
17437
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17438 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17439 {
17440 USE_OPLINE
17441 zval *op1, *op2;
17442 double d1, d2;
17443
17444 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17445 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17446 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17447 /* pass */
17448 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17449 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17450 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17451 is_not_equal_true:
17452 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
17453 } else {
17454 is_not_equal_false:
17455 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
17456 }
17457 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17458 d1 = (double)Z_LVAL_P(op1);
17459 d2 = Z_DVAL_P(op2);
17460 goto is_not_equal_double;
17461 }
17462 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17463 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17464 d1 = Z_DVAL_P(op1);
17465 d2 = Z_DVAL_P(op2);
17466 is_not_equal_double:
17467 if (d1 != d2) {
17468 goto is_not_equal_true;
17469 } else {
17470 goto is_not_equal_false;
17471 }
17472 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17473 d1 = Z_DVAL_P(op1);
17474 d2 = (double)Z_LVAL_P(op2);
17475 goto is_not_equal_double;
17476 }
17477 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17478 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17479 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17480 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17481 zval_ptr_dtor_str(op1);
17482 }
17483 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17484 zval_ptr_dtor_str(op2);
17485 }
17486 if (!result) {
17487 goto is_not_equal_true;
17488 } else {
17489 goto is_not_equal_false;
17490 }
17491 }
17492 }
17493 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17494 }
17495
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17496 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17497 {
17498 USE_OPLINE
17499 zval *op1, *op2;
17500 double d1, d2;
17501
17502 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17503 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17504 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17505 /* pass */
17506 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17507 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17508 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17509 is_not_equal_true:
17510 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
17511 } else {
17512 is_not_equal_false:
17513 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
17514 }
17515 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17516 d1 = (double)Z_LVAL_P(op1);
17517 d2 = Z_DVAL_P(op2);
17518 goto is_not_equal_double;
17519 }
17520 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17521 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17522 d1 = Z_DVAL_P(op1);
17523 d2 = Z_DVAL_P(op2);
17524 is_not_equal_double:
17525 if (d1 != d2) {
17526 goto is_not_equal_true;
17527 } else {
17528 goto is_not_equal_false;
17529 }
17530 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17531 d1 = Z_DVAL_P(op1);
17532 d2 = (double)Z_LVAL_P(op2);
17533 goto is_not_equal_double;
17534 }
17535 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17536 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17537 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17538 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17539 zval_ptr_dtor_str(op1);
17540 }
17541 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17542 zval_ptr_dtor_str(op2);
17543 }
17544 if (!result) {
17545 goto is_not_equal_true;
17546 } else {
17547 goto is_not_equal_false;
17548 }
17549 }
17550 }
17551 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17552 }
17553
ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17554 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17555 {
17556 USE_OPLINE
17557 zval *op1, *op2;
17558
17559 SAVE_OPLINE();
17560 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17561 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17562 compare_function(EX_VAR(opline->result.var), op1, op2);
17563 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17564 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17565 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17566 }
17567
ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17568 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17569 {
17570 USE_OPLINE
17571 zval *op1, *op2;
17572
17573 SAVE_OPLINE();
17574 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17575 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17576 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
17577 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17578 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17579 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17580 }
17581
ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17582 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17583 {
17584 USE_OPLINE
17585 zval *container, *dim, *value;
17586
17587 SAVE_OPLINE();
17588 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17589 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17590 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17591 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17592 fetch_dim_r_array:
17593 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
17594 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17595 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17596 container = Z_REFVAL_P(container);
17597 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17598 goto fetch_dim_r_array;
17599 } else {
17600 goto fetch_dim_r_slow;
17601 }
17602 } else {
17603 fetch_dim_r_slow:
17604 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17605 dim++;
17606 }
17607 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17608 }
17609 } else {
17610 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
17611 }
17612 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17613 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17614 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17615 }
17616
ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17617 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17618 {
17619 USE_OPLINE
17620 zval *container;
17621
17622 SAVE_OPLINE();
17623 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17624 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);
17625 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17626 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17627 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17628 }
17629
ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17630 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17631 {
17632 USE_OPLINE
17633 zval *container;
17634 void **cache_slot = NULL;
17635
17636 SAVE_OPLINE();
17637 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17638
17639 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17640 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17641 do {
17642 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17643 container = Z_REFVAL_P(container);
17644 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
17645 break;
17646 }
17647 }
17648 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
17649 ZVAL_UNDEFINED_OP1();
17650 }
17651 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17652 ZVAL_NULL(EX_VAR(opline->result.var));
17653 goto fetch_obj_r_finish;
17654 } while (0);
17655 }
17656
17657 /* here we are sure we are dealing with an object */
17658 do {
17659 zend_object *zobj = Z_OBJ_P(container);
17660 zend_string *name, *tmp_name;
17661 zval *retval;
17662
17663 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17664 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
17665
17666 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
17667 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
17668
17669 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
17670 fetch_obj_r_simple:
17671 retval = OBJ_PROP(zobj, prop_offset);
17672 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
17673 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17674 goto fetch_obj_r_copy;
17675 } else {
17676 fetch_obj_r_fast_copy:
17677 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17678 ZEND_VM_NEXT_OPCODE();
17679 }
17680 }
17681 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
17682 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
17683 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
17684 prop_offset = prop_info->offset;
17685 goto fetch_obj_r_simple;
17686 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
17687 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
17688 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
17689 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
17690
17691 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
17692 if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
17693 GC_ADDREF(zobj);
17694 }
17695 if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
17696 call_info |= ZEND_CALL_RELEASE_THIS;
17697 }
17698 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
17699 call->prev_execute_data = execute_data;
17700 call->call = NULL;
17701 call->return_value = EX_VAR(opline->result.var);
17702 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
17703
17704 execute_data = call;
17705 EG(current_execute_data) = execute_data;
17706 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
17707
17708 #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
17709 opline = hook->op_array.opcodes;
17710 #else
17711 EX(opline) = hook->op_array.opcodes;
17712 #endif
17713 LOAD_OPLINE_EX();
17714
17715
17716 ZEND_VM_ENTER_EX();
17717 }
17718 /* Fall through to read_property for hooks. */
17719 } else if (EXPECTED(zobj->properties != NULL)) {
17720 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
17721 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17722 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
17723 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
17724
17725 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
17726 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
17727
17728 if (EXPECTED(p->key == name) ||
17729 (EXPECTED(p->h == ZSTR_H(name)) &&
17730 EXPECTED(p->key != NULL) &&
17731 EXPECTED(zend_string_equal_content(p->key, name)))) {
17732 retval = &p->val;
17733 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17734 goto fetch_obj_r_copy;
17735 } else {
17736 goto fetch_obj_r_fast_copy;
17737 }
17738 }
17739 }
17740 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
17741 }
17742 retval = zend_hash_find_known_hash(zobj->properties, name);
17743 if (EXPECTED(retval)) {
17744 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
17745 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
17746 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17747 goto fetch_obj_r_copy;
17748 } else {
17749 goto fetch_obj_r_fast_copy;
17750 }
17751 }
17752 }
17753 }
17754 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17755 } else {
17756 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
17757 if (UNEXPECTED(!name)) {
17758 ZVAL_UNDEF(EX_VAR(opline->result.var));
17759 break;
17760 }
17761 }
17762
17763 #if ZEND_DEBUG
17764 /* For non-standard object handlers, verify a declared property type in debug builds.
17765 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
17766 zend_property_info *prop_info = NULL;
17767 if (zobj->handlers->read_property != zend_std_read_property) {
17768 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
17769 }
17770 #endif
17771 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
17772 #if ZEND_DEBUG
17773 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
17774 && ZEND_TYPE_IS_SET(prop_info->type)) {
17775 ZVAL_OPT_DEREF(retval);
17776 zend_verify_property_type(prop_info, retval, /* strict */ true);
17777 }
17778 #endif
17779
17780 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17781 zend_tmp_string_release(tmp_name);
17782 }
17783
17784 if (retval != EX_VAR(opline->result.var)) {
17785 fetch_obj_r_copy:
17786 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17787 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
17788 zend_unwrap_reference(retval);
17789 }
17790 } while (0);
17791
17792 fetch_obj_r_finish:
17793 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17794 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17795 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17796 }
17797
ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17798 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17799 {
17800 USE_OPLINE
17801 zval *container;
17802 void **cache_slot = NULL;
17803
17804 SAVE_OPLINE();
17805 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17806
17807 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17808 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17809 do {
17810 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17811 container = Z_REFVAL_P(container);
17812 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
17813 break;
17814 }
17815 }
17816 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
17817 ZVAL_UNDEFINED_OP2();
17818 }
17819 ZVAL_NULL(EX_VAR(opline->result.var));
17820 goto fetch_obj_is_finish;
17821 } while (0);
17822 }
17823
17824 /* here we are sure we are dealing with an object */
17825 do {
17826 zend_object *zobj = Z_OBJ_P(container);
17827 zend_string *name, *tmp_name;
17828 zval *retval;
17829
17830 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17831 cache_slot = CACHE_ADDR(opline->extended_value);
17832
17833 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
17834 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
17835
17836 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
17837 fetch_obj_is_simple:
17838 retval = OBJ_PROP(zobj, prop_offset);
17839 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
17840 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17841 goto fetch_obj_is_copy;
17842 } else {
17843 fetch_obj_is_fast_copy:
17844 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17845 ZEND_VM_NEXT_OPCODE();
17846 }
17847 }
17848 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
17849 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
17850 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
17851 prop_offset = prop_info->offset;
17852 goto fetch_obj_is_simple;
17853 }
17854 /* Fall through to read_property for hooks. */
17855 } else if (EXPECTED(zobj->properties != NULL)) {
17856 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
17857 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17858 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
17859 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
17860
17861 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
17862 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
17863
17864 if (EXPECTED(p->key == name) ||
17865 (EXPECTED(p->h == ZSTR_H(name)) &&
17866 EXPECTED(p->key != NULL) &&
17867 EXPECTED(zend_string_equal_content(p->key, name)))) {
17868 retval = &p->val;
17869 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17870 goto fetch_obj_is_copy;
17871 } else {
17872 goto fetch_obj_is_fast_copy;
17873 }
17874 }
17875 }
17876 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
17877 }
17878 retval = zend_hash_find_known_hash(zobj->properties, name);
17879 if (EXPECTED(retval)) {
17880 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
17881 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
17882 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17883 goto fetch_obj_is_copy;
17884 } else {
17885 goto fetch_obj_is_fast_copy;
17886 }
17887 }
17888 }
17889 }
17890 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17891 } else {
17892 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
17893 if (UNEXPECTED(!name)) {
17894 ZVAL_UNDEF(EX_VAR(opline->result.var));
17895 break;
17896 }
17897 }
17898
17899 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
17900
17901 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17902 zend_tmp_string_release(tmp_name);
17903 }
17904
17905 if (retval != EX_VAR(opline->result.var)) {
17906 fetch_obj_is_copy:
17907 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17908 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
17909 zend_unwrap_reference(retval);
17910 }
17911 } while (0);
17912
17913 fetch_obj_is_finish:
17914 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17915 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17916 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17917 }
17918
ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17919 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17920 {
17921 USE_OPLINE
17922 zval *op1, *op2;
17923 zend_string *op1_str, *op2_str, *str;
17924
17925
17926 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17927 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17928 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
17929 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
17930 zend_string *op1_str = Z_STR_P(op1);
17931 zend_string *op2_str = Z_STR_P(op2);
17932 zend_string *str;
17933 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
17934
17935 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
17936 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17937 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
17938 } else {
17939 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
17940 }
17941 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17942 zend_string_release_ex(op1_str, 0);
17943 }
17944 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
17945 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17946 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
17947 } else {
17948 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
17949 }
17950 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17951 zend_string_release_ex(op2_str, 0);
17952 }
17953 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
17954 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
17955 size_t len = ZSTR_LEN(op1_str);
17956
17957 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
17958 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17959 GC_ADD_FLAGS(str, flags);
17960 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17961 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17962 zend_string_release_ex(op2_str, 0);
17963 }
17964 } else {
17965 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
17966 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
17967 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17968 GC_ADD_FLAGS(str, flags);
17969 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17970 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17971 zend_string_release_ex(op1_str, 0);
17972 }
17973 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17974 zend_string_release_ex(op2_str, 0);
17975 }
17976 }
17977 ZEND_VM_NEXT_OPCODE();
17978 }
17979
17980 SAVE_OPLINE();
17981 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17982 op1_str = Z_STR_P(op1);
17983 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17984 op1_str = zend_string_copy(Z_STR_P(op1));
17985 } else {
17986 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
17987 ZVAL_UNDEFINED_OP1();
17988 }
17989 op1_str = zval_get_string_func(op1);
17990 }
17991 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17992 op2_str = Z_STR_P(op2);
17993 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17994 op2_str = zend_string_copy(Z_STR_P(op2));
17995 } else {
17996 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
17997 ZVAL_UNDEFINED_OP2();
17998 }
17999 op2_str = zval_get_string_func(op2);
18000 }
18001 do {
18002 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18003 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18004 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18005 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
18006 GC_ADDREF(op2_str);
18007 }
18008 }
18009 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18010 zend_string_release_ex(op1_str, 0);
18011 break;
18012 }
18013 }
18014 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18015 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18016 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18017 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
18018 GC_ADDREF(op1_str);
18019 }
18020 }
18021 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18022 zend_string_release_ex(op2_str, 0);
18023 break;
18024 }
18025 }
18026 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18027 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18028 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18029
18030 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
18031 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18032 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18033 zend_string_release_ex(op1_str, 0);
18034 }
18035 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18036 zend_string_release_ex(op2_str, 0);
18037 }
18038 } while (0);
18039 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18040 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18041 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18042 }
18043
ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18044 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18045 {
18046 USE_OPLINE
18047 zval *function_name;
18048 zval *object;
18049 zend_function *fbc;
18050 zend_class_entry *called_scope;
18051 zend_object *obj;
18052 zend_execute_data *call;
18053 uint32_t call_info;
18054
18055 SAVE_OPLINE();
18056
18057 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18058
18059 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18060 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18061 }
18062
18063 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
18064 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
18065 do {
18066 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
18067 function_name = Z_REFVAL_P(function_name);
18068 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
18069 break;
18070 }
18071 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
18072 ZVAL_UNDEFINED_OP2();
18073 if (UNEXPECTED(EG(exception) != NULL)) {
18074 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18075 HANDLE_EXCEPTION();
18076 }
18077 }
18078 zend_throw_error(NULL, "Method name must be a string");
18079 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18080 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18081 HANDLE_EXCEPTION();
18082 } while (0);
18083 }
18084
18085 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
18086 obj = Z_OBJ_P(object);
18087 } else {
18088 do {
18089 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
18090 obj = Z_OBJ_P(object);
18091 } else {
18092 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
18093 zend_reference *ref = Z_REF_P(object);
18094
18095 object = &ref->val;
18096 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
18097 obj = Z_OBJ_P(object);
18098 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
18099 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
18100 efree_size(ref, sizeof(zend_reference));
18101 } else {
18102 Z_ADDREF_P(object);
18103 }
18104 }
18105 break;
18106 }
18107 }
18108 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
18109 object = ZVAL_UNDEFINED_OP1();
18110 if (UNEXPECTED(EG(exception) != NULL)) {
18111 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18112 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18113 }
18114 HANDLE_EXCEPTION();
18115 }
18116 }
18117 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18118 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18119 }
18120 zend_invalid_method_call(object, function_name);
18121 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18122 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18123 HANDLE_EXCEPTION();
18124 }
18125 } while (0);
18126 }
18127
18128 called_scope = obj->ce;
18129
18130 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
18131 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
18132 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
18133 } else {
18134 zend_object *orig_obj = obj;
18135
18136 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18137 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18138 }
18139
18140 /* First, locate the function. */
18141 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));
18142 if (UNEXPECTED(fbc == NULL)) {
18143 if (EXPECTED(!EG(exception))) {
18144 zend_undefined_method(obj->ce, Z_STR_P(function_name));
18145 }
18146 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18147 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
18148 zend_objects_store_del(orig_obj);
18149 }
18150 HANDLE_EXCEPTION();
18151 }
18152 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
18153 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
18154 EXPECTED(obj == orig_obj)) {
18155 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
18156 }
18157 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
18158 GC_ADDREF(obj); /* For $this pointer */
18159 if (GC_DELREF(orig_obj) == 0) {
18160 zend_objects_store_del(orig_obj);
18161 }
18162 }
18163 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
18164 init_func_run_time_cache(&fbc->op_array);
18165 }
18166 }
18167
18168 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18169 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18170 }
18171
18172 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
18173 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
18174 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
18175 zend_objects_store_del(obj);
18176 if (UNEXPECTED(EG(exception))) {
18177 HANDLE_EXCEPTION();
18178 }
18179 }
18180 /* call static method */
18181 obj = (zend_object*)called_scope;
18182 call_info = ZEND_CALL_NESTED_FUNCTION;
18183 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
18184 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18185 GC_ADDREF(obj); /* For $this pointer */
18186 }
18187 /* CV may be changed indirectly (e.g. when it's a reference) */
18188 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
18189 }
18190
18191 call = zend_vm_stack_push_call_frame(call_info,
18192 fbc, opline->extended_value, obj);
18193 call->prev_execute_data = EX(call);
18194 EX(call) = call;
18195
18196 ZEND_VM_NEXT_OPCODE();
18197 }
18198
ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18199 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18200 {
18201 USE_OPLINE
18202 zval *op1, *op2;
18203 double d1, d2;
18204
18205 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18206 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18207 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
18208 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
18209 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
18210 case_true:
18211 ZEND_VM_SMART_BRANCH_TRUE();
18212 } else {
18213 case_false:
18214 ZEND_VM_SMART_BRANCH_FALSE();
18215 }
18216 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
18217 d1 = (double)Z_LVAL_P(op1);
18218 d2 = Z_DVAL_P(op2);
18219 goto case_double;
18220 }
18221 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
18222 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
18223 d1 = Z_DVAL_P(op1);
18224 d2 = Z_DVAL_P(op2);
18225 case_double:
18226 if (d1 == d2) {
18227 goto case_true;
18228 } else {
18229 goto case_false;
18230 }
18231 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
18232 d1 = Z_DVAL_P(op1);
18233 d2 = (double)Z_LVAL_P(op2);
18234 goto case_double;
18235 }
18236 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
18237 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
18238 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
18239 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18240 if (result) {
18241 goto case_true;
18242 } else {
18243 goto case_false;
18244 }
18245 }
18246 }
18247 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18248 }
18249
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18250 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18251 {
18252 USE_OPLINE
18253 zval *container;
18254 bool result;
18255 zend_ulong hval;
18256 zval *offset;
18257
18258 SAVE_OPLINE();
18259 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18260 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18261
18262 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18263 HashTable *ht;
18264 zval *value;
18265 zend_string *str;
18266
18267 isset_dim_obj_array:
18268 ht = Z_ARRVAL_P(container);
18269 isset_again:
18270 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
18271 str = Z_STR_P(offset);
18272 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18273 if (ZEND_HANDLE_NUMERIC(str, hval)) {
18274 goto num_index_prop;
18275 }
18276 }
18277 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18278 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
18279 hval = Z_LVAL_P(offset);
18280 num_index_prop:
18281 value = zend_hash_index_find(ht, hval);
18282 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
18283 offset = Z_REFVAL_P(offset);
18284 goto isset_again;
18285 } else {
18286 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
18287 if (UNEXPECTED(EG(exception))) {
18288 result = 0;
18289 goto isset_dim_obj_exit;
18290 }
18291 }
18292
18293 if (!(opline->extended_value & ZEND_ISEMPTY)) {
18294 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
18295 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
18296 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
18297
18298 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
18299 /* avoid exception check */
18300 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18301 ZEND_VM_SMART_BRANCH(result, 0);
18302 }
18303 } else {
18304 result = (value == NULL || !i_zend_is_true(value));
18305 }
18306 goto isset_dim_obj_exit;
18307 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
18308 container = Z_REFVAL_P(container);
18309 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18310 goto isset_dim_obj_array;
18311 }
18312 }
18313
18314 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
18315 offset++;
18316 }
18317 if (!(opline->extended_value & ZEND_ISEMPTY)) {
18318 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
18319 } else {
18320 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
18321 }
18322
18323 isset_dim_obj_exit:
18324 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18325 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18326 ZEND_VM_SMART_BRANCH(result, 1);
18327 }
18328
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18329 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18330 {
18331 USE_OPLINE
18332 zval *container;
18333 int result;
18334 zval *offset;
18335 zend_string *name, *tmp_name;
18336
18337 SAVE_OPLINE();
18338 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18339 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18340
18341 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
18342 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
18343 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
18344 container = Z_REFVAL_P(container);
18345 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
18346 result = (opline->extended_value & ZEND_ISEMPTY);
18347 goto isset_object_finish;
18348 }
18349 } else {
18350 result = (opline->extended_value & ZEND_ISEMPTY);
18351 goto isset_object_finish;
18352 }
18353 }
18354
18355 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18356 name = Z_STR_P(offset);
18357 } else {
18358 name = zval_try_get_tmp_string(offset, &tmp_name);
18359 if (UNEXPECTED(!name)) {
18360 result = 0;
18361 goto isset_object_finish;
18362 }
18363 }
18364
18365 result =
18366 (opline->extended_value & ZEND_ISEMPTY) ^
18367 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));
18368
18369 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18370 zend_tmp_string_release(tmp_name);
18371 }
18372
18373 isset_object_finish:
18374 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18375 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18376 ZEND_VM_SMART_BRANCH(result, 1);
18377 }
18378
ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18379 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18380 {
18381 USE_OPLINE
18382
18383 zval *key, *subject;
18384 HashTable *ht;
18385 bool result;
18386
18387 SAVE_OPLINE();
18388
18389 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18390 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
18391
18392 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
18393 array_key_exists_array:
18394 ht = Z_ARRVAL_P(subject);
18395 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
18396 } else {
18397 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
18398 subject = Z_REFVAL_P(subject);
18399 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
18400 goto array_key_exists_array;
18401 }
18402 }
18403 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
18404 result = 0;
18405 }
18406
18407 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
18408 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18409 ZEND_VM_SMART_BRANCH(result, 1);
18410 }
18411
ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18412 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18413 {
18414 USE_OPLINE
18415 zval *expr;
18416 bool result;
18417
18418 SAVE_OPLINE();
18419 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18420
18421 try_instanceof:
18422 if (Z_TYPE_P(expr) == IS_OBJECT) {
18423 zend_class_entry *ce;
18424
18425 if (IS_VAR == IS_CONST) {
18426 ce = CACHED_PTR(opline->extended_value);
18427 if (UNEXPECTED(ce == NULL)) {
18428 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);
18429 if (EXPECTED(ce)) {
18430 CACHE_PTR(opline->extended_value, ce);
18431 }
18432 }
18433 } else if (IS_VAR == IS_UNUSED) {
18434 ce = zend_fetch_class(NULL, opline->op2.num);
18435 if (UNEXPECTED(ce == NULL)) {
18436 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18437 ZVAL_UNDEF(EX_VAR(opline->result.var));
18438 HANDLE_EXCEPTION();
18439 }
18440 } else {
18441 ce = Z_CE_P(EX_VAR(opline->op2.var));
18442 }
18443 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
18444 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
18445 expr = Z_REFVAL_P(expr);
18446 goto try_instanceof;
18447 } else {
18448 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
18449 ZVAL_UNDEFINED_OP1();
18450 }
18451 result = 0;
18452 }
18453 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18454 ZEND_VM_SMART_BRANCH(result, 1);
18455 }
18456
zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)18457 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
18458 {
18459 USE_OPLINE
18460 zval *varname;
18461 zval *retval;
18462 zend_string *name, *tmp_name;
18463 HashTable *target_symbol_table;
18464
18465 SAVE_OPLINE();
18466 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18467
18468 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18469 name = Z_STR_P(varname);
18470 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18471 name = Z_STR_P(varname);
18472 tmp_name = NULL;
18473 } else {
18474 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18475 ZVAL_UNDEFINED_OP1();
18476 }
18477 name = zval_try_get_tmp_string(varname, &tmp_name);
18478 if (UNEXPECTED(!name)) {
18479 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18480 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18481 }
18482 ZVAL_UNDEF(EX_VAR(opline->result.var));
18483 HANDLE_EXCEPTION();
18484 }
18485 }
18486
18487 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18488 retval = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18489 if (retval == NULL) {
18490 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18491 fetch_this:
18492 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
18493 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18494 zend_tmp_string_release(tmp_name);
18495 }
18496 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18497 }
18498 if (type == BP_VAR_W) {
18499 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
18500 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18501 retval = &EG(uninitialized_zval);
18502 } else {
18503 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18504 /* Keep name alive in case an error handler tries to free it. */
18505 zend_string_addref(name);
18506 }
18507 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18508 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18509 if (type == BP_VAR_RW && !EG(exception)) {
18510 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
18511 } else {
18512 retval = &EG(uninitialized_zval);
18513 }
18514 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18515 zend_string_release(name);
18516 }
18517 }
18518 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
18519 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
18520 retval = Z_INDIRECT_P(retval);
18521 if (Z_TYPE_P(retval) == IS_UNDEF) {
18522 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18523 goto fetch_this;
18524 }
18525 if (type == BP_VAR_W) {
18526 ZVAL_NULL(retval);
18527 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18528 retval = &EG(uninitialized_zval);
18529 } else {
18530 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18531 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18532 if (type == BP_VAR_RW && !EG(exception)) {
18533 ZVAL_NULL(retval);
18534 } else {
18535 retval = &EG(uninitialized_zval);
18536 }
18537 }
18538 }
18539 }
18540
18541 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18542 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18543 }
18544
18545 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18546 zend_tmp_string_release(tmp_name);
18547 }
18548
18549 ZEND_ASSERT(retval != NULL);
18550 if (type == BP_VAR_R || type == BP_VAR_IS) {
18551 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18552 } else {
18553 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
18554 }
18555 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18556 }
18557
ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18558 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18559 {
18560 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18561 }
18562
ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18563 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18564 {
18565 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18566 }
18567
ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18568 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18569 {
18570 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18571 }
18572
ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18573 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18574 {
18575 int fetch_type =
18576 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
18577 BP_VAR_W : BP_VAR_R;
18578 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18579 }
18580
ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18581 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18582 {
18583 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18584 }
18585
ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18586 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18587 {
18588 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18589 }
18590
18591 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18592 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18593 {
18594 USE_OPLINE
18595 zval *value, *arg;
18596
18597 if (IS_UNUSED == IS_CONST) {
18598 SAVE_OPLINE();
18599 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
18600 uint32_t arg_num;
18601 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
18602 if (UNEXPECTED(!arg)) {
18603 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18604 HANDLE_EXCEPTION();
18605 }
18606 } else {
18607 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
18608 }
18609
18610 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18611 ZVAL_COPY_VALUE(arg, value);
18612 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18613 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
18614 Z_ADDREF_P(arg);
18615 }
18616 }
18617 ZEND_VM_NEXT_OPCODE();
18618 }
18619
ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18620 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18621 {
18622 USE_OPLINE
18623 zval *varname;
18624 zend_string *name, *tmp_name;
18625 HashTable *target_symbol_table;
18626
18627 SAVE_OPLINE();
18628
18629 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18630
18631 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18632 name = Z_STR_P(varname);
18633 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18634 name = Z_STR_P(varname);
18635 tmp_name = NULL;
18636 } else {
18637 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18638 varname = ZVAL_UNDEFINED_OP1();
18639 }
18640 name = zval_try_get_tmp_string(varname, &tmp_name);
18641 if (UNEXPECTED(!name)) {
18642 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18643 HANDLE_EXCEPTION();
18644 }
18645 }
18646
18647 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18648 zend_hash_del_ind(target_symbol_table, name);
18649
18650 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18651 zend_tmp_string_release(tmp_name);
18652 }
18653 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18654 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18655 }
18656
18657 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18658 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18659 {
18660 USE_OPLINE
18661 zval *value;
18662 bool result;
18663 zval *varname;
18664 zend_string *name, *tmp_name;
18665 HashTable *target_symbol_table;
18666
18667 SAVE_OPLINE();
18668 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18669 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18670 name = Z_STR_P(varname);
18671 } else {
18672 name = zval_get_tmp_string(varname, &tmp_name);
18673 }
18674
18675 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18676 value = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18677
18678 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18679 zend_tmp_string_release(tmp_name);
18680 }
18681 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18682
18683 if (!value) {
18684 result = (opline->extended_value & ZEND_ISEMPTY);
18685 } else {
18686 if (Z_TYPE_P(value) == IS_INDIRECT) {
18687 value = Z_INDIRECT_P(value);
18688 }
18689 if (!(opline->extended_value & ZEND_ISEMPTY)) {
18690 if (Z_ISREF_P(value)) {
18691 value = Z_REFVAL_P(value);
18692 }
18693 result = Z_TYPE_P(value) > IS_NULL;
18694 } else {
18695 result = !i_zend_is_true(value);
18696 }
18697 }
18698
18699 ZEND_VM_SMART_BRANCH(result, true);
18700 }
18701
18702 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18703 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18704 {
18705 USE_OPLINE
18706 zval *expr;
18707 bool result;
18708
18709 SAVE_OPLINE();
18710 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18711
18712 try_instanceof:
18713 if (Z_TYPE_P(expr) == IS_OBJECT) {
18714 zend_class_entry *ce;
18715
18716 if (IS_UNUSED == IS_CONST) {
18717 ce = CACHED_PTR(opline->extended_value);
18718 if (UNEXPECTED(ce == NULL)) {
18719 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);
18720 if (EXPECTED(ce)) {
18721 CACHE_PTR(opline->extended_value, ce);
18722 }
18723 }
18724 } else if (IS_UNUSED == IS_UNUSED) {
18725 ce = zend_fetch_class(NULL, opline->op2.num);
18726 if (UNEXPECTED(ce == NULL)) {
18727 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18728 ZVAL_UNDEF(EX_VAR(opline->result.var));
18729 HANDLE_EXCEPTION();
18730 }
18731 } else {
18732 ce = Z_CE_P(EX_VAR(opline->op2.var));
18733 }
18734 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
18735 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
18736 expr = Z_REFVAL_P(expr);
18737 goto try_instanceof;
18738 } else {
18739 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
18740 ZVAL_UNDEFINED_OP1();
18741 }
18742 result = 0;
18743 }
18744 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18745 ZEND_VM_SMART_BRANCH(result, 1);
18746 }
18747
ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18748 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18749 {
18750 USE_OPLINE
18751 zval *op1;
18752 zend_long count;
18753
18754 SAVE_OPLINE();
18755 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18756
18757 while (1) {
18758 if (Z_TYPE_P(op1) == IS_ARRAY) {
18759 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
18760 break;
18761 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
18762 zend_object *zobj = Z_OBJ_P(op1);
18763
18764 /* first, we check if the handler is defined */
18765 if (zobj->handlers->count_elements) {
18766 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
18767 break;
18768 }
18769 if (UNEXPECTED(EG(exception))) {
18770 count = 0;
18771 break;
18772 }
18773 }
18774
18775 /* if not and the object implements Countable we call its count() method */
18776 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
18777 zval retval;
18778
18779 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
18780 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
18781 count = zval_get_long(&retval);
18782 zval_ptr_dtor(&retval);
18783 break;
18784 }
18785
18786 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
18787 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
18788 op1 = Z_REFVAL_P(op1);
18789 continue;
18790 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18791 ZVAL_UNDEFINED_OP1();
18792 }
18793 count = 0;
18794 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));
18795 break;
18796 }
18797
18798 ZVAL_LONG(EX_VAR(opline->result.var), count);
18799 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18800 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18801 }
18802
ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18803 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18804 {
18805 USE_OPLINE
18806 zend_array *ht = Z_ARRVAL_P(_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC));
18807 ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
18808 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
18809 SAVE_OPLINE();
18810 zend_array_destroy(ht);
18811 if (EG(exception)) {
18812 HANDLE_EXCEPTION();
18813 }
18814 }
18815 ZEND_VM_NEXT_OPCODE();
18816 }
18817
ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18818 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18819 {
18820 USE_OPLINE
18821
18822 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
18823 SAVE_OPLINE();
18824 if (UNEXPECTED(!EX(func)->common.scope)) {
18825 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
18826 ZVAL_UNDEF(EX_VAR(opline->result.var));
18827 HANDLE_EXCEPTION();
18828 } else {
18829 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
18830 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
18831 if (UNEXPECTED(EG(exception))) {
18832 HANDLE_EXCEPTION();
18833 }
18834 ZEND_VM_NEXT_OPCODE();
18835 }
18836 } else {
18837 zval *op1;
18838
18839 SAVE_OPLINE();
18840 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18841 while (1) {
18842 if (Z_TYPE_P(op1) == IS_OBJECT) {
18843 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
18844 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
18845 op1 = Z_REFVAL_P(op1);
18846 continue;
18847 } else {
18848 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18849 ZVAL_UNDEFINED_OP1();
18850 }
18851 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
18852 ZVAL_UNDEF(EX_VAR(opline->result.var));
18853 }
18854 break;
18855 }
18856 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18857 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18858 }
18859 }
18860
ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18861 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18862 {
18863 USE_OPLINE
18864 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18865 zval *result = EX_VAR(opline->result.var);
18866 ZVAL_COPY(result, value);
18867 ZEND_VM_NEXT_OPCODE();
18868 }
18869
ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18870 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18871 {
18872 USE_OPLINE
18873 zval *op1, *op2;
18874
18875 SAVE_OPLINE();
18876 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18877 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
18878 div_function(EX_VAR(opline->result.var), op1, op2);
18879 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18880
18881 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18882 }
18883
ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18884 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18885 {
18886 USE_OPLINE
18887 zval *op1, *op2;
18888
18889 SAVE_OPLINE();
18890 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18891 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
18892 pow_function(EX_VAR(opline->result.var), op1, op2);
18893 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18894
18895 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18896 }
18897
ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18898 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18899 {
18900 USE_OPLINE
18901 zval *op1, *op2;
18902
18903 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18904 op2 = EX_VAR(opline->op2.var);
18905
18906 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
18907 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
18908 zend_string *op1_str = Z_STR_P(op1);
18909 zend_string *op2_str = Z_STR_P(op2);
18910 zend_string *str;
18911 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
18912
18913 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18914 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
18915 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
18916 } else {
18917 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18918 }
18919 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18920 zend_string_release_ex(op1_str, 0);
18921 }
18922 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18923 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
18924 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
18925 } else {
18926 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18927 }
18928 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18929 zend_string_release_ex(op2_str, 0);
18930 }
18931 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
18932 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
18933 size_t len = ZSTR_LEN(op1_str);
18934
18935 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
18936 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
18937 }
18938 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
18939 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18940 GC_ADD_FLAGS(str, flags);
18941 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18942 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18943 zend_string_release_ex(op2_str, 0);
18944 }
18945 } else {
18946 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18947 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18948 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18949 GC_ADD_FLAGS(str, flags);
18950 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18951 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18952 zend_string_release_ex(op1_str, 0);
18953 }
18954 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18955 zend_string_release_ex(op2_str, 0);
18956 }
18957 }
18958 ZEND_VM_NEXT_OPCODE();
18959 } else {
18960 SAVE_OPLINE();
18961
18962 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18963 op1 = ZVAL_UNDEFINED_OP1();
18964 }
18965 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
18966 op2 = ZVAL_UNDEFINED_OP2();
18967 }
18968 concat_function(EX_VAR(opline->result.var), op1, op2);
18969 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18970
18971 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18972 }
18973 }
18974
ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18975 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18976 {
18977 USE_OPLINE
18978 zval *op1, *op2;
18979
18980 SAVE_OPLINE();
18981 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18982 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
18983 compare_function(EX_VAR(opline->result.var), op1, op2);
18984 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18985
18986 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18987 }
18988
ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18989 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18990 {
18991 USE_OPLINE
18992 zval *container, *dim, *value;
18993
18994 SAVE_OPLINE();
18995 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18996 dim = EX_VAR(opline->op2.var);
18997 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18998 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18999 fetch_dim_r_array:
19000 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
19001 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
19002 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
19003 container = Z_REFVAL_P(container);
19004 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19005 goto fetch_dim_r_array;
19006 } else {
19007 goto fetch_dim_r_slow;
19008 }
19009 } else {
19010 fetch_dim_r_slow:
19011 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
19012 dim++;
19013 }
19014 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
19015 }
19016 } else {
19017 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
19018 }
19019
19020 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19021 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19022 }
19023
ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19024 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19025 {
19026 USE_OPLINE
19027 zval *container;
19028
19029 SAVE_OPLINE();
19030 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19031 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
19032
19033 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19034 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19035 }
19036
ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19037 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19038 {
19039 USE_OPLINE
19040 zval *container;
19041 void **cache_slot = NULL;
19042
19043 SAVE_OPLINE();
19044 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19045
19046 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19047 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19048 do {
19049 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19050 container = Z_REFVAL_P(container);
19051 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
19052 break;
19053 }
19054 }
19055 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
19056 ZVAL_UNDEFINED_OP1();
19057 }
19058 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19059 ZVAL_NULL(EX_VAR(opline->result.var));
19060 goto fetch_obj_r_finish;
19061 } while (0);
19062 }
19063
19064 /* here we are sure we are dealing with an object */
19065 do {
19066 zend_object *zobj = Z_OBJ_P(container);
19067 zend_string *name, *tmp_name;
19068 zval *retval;
19069
19070 if (IS_CV == IS_CONST) {
19071 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
19072
19073 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
19074 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
19075
19076 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
19077 fetch_obj_r_simple:
19078 retval = OBJ_PROP(zobj, prop_offset);
19079 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
19080 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19081 goto fetch_obj_r_copy;
19082 } else {
19083 fetch_obj_r_fast_copy:
19084 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19085 ZEND_VM_NEXT_OPCODE();
19086 }
19087 }
19088 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
19089 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
19090 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
19091 prop_offset = prop_info->offset;
19092 goto fetch_obj_r_simple;
19093 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
19094 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
19095 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
19096 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
19097
19098 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
19099 if ((IS_TMP_VAR|IS_VAR) & IS_CV) {
19100 GC_ADDREF(zobj);
19101 }
19102 if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) {
19103 call_info |= ZEND_CALL_RELEASE_THIS;
19104 }
19105 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
19106 call->prev_execute_data = execute_data;
19107 call->call = NULL;
19108 call->return_value = EX_VAR(opline->result.var);
19109 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
19110
19111 execute_data = call;
19112 EG(current_execute_data) = execute_data;
19113 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
19114
19115 #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
19116 opline = hook->op_array.opcodes;
19117 #else
19118 EX(opline) = hook->op_array.opcodes;
19119 #endif
19120 LOAD_OPLINE_EX();
19121
19122
19123 ZEND_VM_ENTER_EX();
19124 }
19125 /* Fall through to read_property for hooks. */
19126 } else if (EXPECTED(zobj->properties != NULL)) {
19127 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
19128 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19129 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
19130 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
19131
19132 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
19133 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
19134
19135 if (EXPECTED(p->key == name) ||
19136 (EXPECTED(p->h == ZSTR_H(name)) &&
19137 EXPECTED(p->key != NULL) &&
19138 EXPECTED(zend_string_equal_content(p->key, name)))) {
19139 retval = &p->val;
19140 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19141 goto fetch_obj_r_copy;
19142 } else {
19143 goto fetch_obj_r_fast_copy;
19144 }
19145 }
19146 }
19147 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
19148 }
19149 retval = zend_hash_find_known_hash(zobj->properties, name);
19150 if (EXPECTED(retval)) {
19151 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
19152 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
19153 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19154 goto fetch_obj_r_copy;
19155 } else {
19156 goto fetch_obj_r_fast_copy;
19157 }
19158 }
19159 }
19160 }
19161 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19162 } else {
19163 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
19164 if (UNEXPECTED(!name)) {
19165 ZVAL_UNDEF(EX_VAR(opline->result.var));
19166 break;
19167 }
19168 }
19169
19170 #if ZEND_DEBUG
19171 /* For non-standard object handlers, verify a declared property type in debug builds.
19172 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
19173 zend_property_info *prop_info = NULL;
19174 if (zobj->handlers->read_property != zend_std_read_property) {
19175 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
19176 }
19177 #endif
19178 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
19179 #if ZEND_DEBUG
19180 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
19181 && ZEND_TYPE_IS_SET(prop_info->type)) {
19182 ZVAL_OPT_DEREF(retval);
19183 zend_verify_property_type(prop_info, retval, /* strict */ true);
19184 }
19185 #endif
19186
19187 if (IS_CV != IS_CONST) {
19188 zend_tmp_string_release(tmp_name);
19189 }
19190
19191 if (retval != EX_VAR(opline->result.var)) {
19192 fetch_obj_r_copy:
19193 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19194 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
19195 zend_unwrap_reference(retval);
19196 }
19197 } while (0);
19198
19199 fetch_obj_r_finish:
19200
19201 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19202 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19203 }
19204
ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19205 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19206 {
19207 USE_OPLINE
19208 zval *container;
19209 void **cache_slot = NULL;
19210
19211 SAVE_OPLINE();
19212 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19213
19214 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19215 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19216 do {
19217 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19218 container = Z_REFVAL_P(container);
19219 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
19220 break;
19221 }
19222 }
19223 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
19224 ZVAL_UNDEFINED_OP2();
19225 }
19226 ZVAL_NULL(EX_VAR(opline->result.var));
19227 goto fetch_obj_is_finish;
19228 } while (0);
19229 }
19230
19231 /* here we are sure we are dealing with an object */
19232 do {
19233 zend_object *zobj = Z_OBJ_P(container);
19234 zend_string *name, *tmp_name;
19235 zval *retval;
19236
19237 if (IS_CV == IS_CONST) {
19238 cache_slot = CACHE_ADDR(opline->extended_value);
19239
19240 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
19241 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
19242
19243 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
19244 fetch_obj_is_simple:
19245 retval = OBJ_PROP(zobj, prop_offset);
19246 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
19247 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19248 goto fetch_obj_is_copy;
19249 } else {
19250 fetch_obj_is_fast_copy:
19251 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19252 ZEND_VM_NEXT_OPCODE();
19253 }
19254 }
19255 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
19256 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
19257 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
19258 prop_offset = prop_info->offset;
19259 goto fetch_obj_is_simple;
19260 }
19261 /* Fall through to read_property for hooks. */
19262 } else if (EXPECTED(zobj->properties != NULL)) {
19263 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
19264 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19265 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
19266 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
19267
19268 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
19269 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
19270
19271 if (EXPECTED(p->key == name) ||
19272 (EXPECTED(p->h == ZSTR_H(name)) &&
19273 EXPECTED(p->key != NULL) &&
19274 EXPECTED(zend_string_equal_content(p->key, name)))) {
19275 retval = &p->val;
19276 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19277 goto fetch_obj_is_copy;
19278 } else {
19279 goto fetch_obj_is_fast_copy;
19280 }
19281 }
19282 }
19283 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
19284 }
19285 retval = zend_hash_find_known_hash(zobj->properties, name);
19286 if (EXPECTED(retval)) {
19287 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
19288 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
19289 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
19290 goto fetch_obj_is_copy;
19291 } else {
19292 goto fetch_obj_is_fast_copy;
19293 }
19294 }
19295 }
19296 }
19297 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
19298 } else {
19299 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
19300 if (UNEXPECTED(!name)) {
19301 ZVAL_UNDEF(EX_VAR(opline->result.var));
19302 break;
19303 }
19304 }
19305
19306 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
19307
19308 if (IS_CV != IS_CONST) {
19309 zend_tmp_string_release(tmp_name);
19310 }
19311
19312 if (retval != EX_VAR(opline->result.var)) {
19313 fetch_obj_is_copy:
19314 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
19315 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
19316 zend_unwrap_reference(retval);
19317 }
19318 } while (0);
19319
19320 fetch_obj_is_finish:
19321
19322 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19323 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19324 }
19325
ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19326 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19327 {
19328 USE_OPLINE
19329 zval *op1, *op2;
19330 zend_string *op1_str, *op2_str, *str;
19331
19332
19333 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19334 op2 = EX_VAR(opline->op2.var);
19335 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
19336 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
19337 zend_string *op1_str = Z_STR_P(op1);
19338 zend_string *op2_str = Z_STR_P(op2);
19339 zend_string *str;
19340 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
19341
19342 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
19343 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
19344 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
19345 } else {
19346 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
19347 }
19348 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19349 zend_string_release_ex(op1_str, 0);
19350 }
19351 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
19352 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
19353 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
19354 } else {
19355 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
19356 }
19357 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19358 zend_string_release_ex(op2_str, 0);
19359 }
19360 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
19361 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
19362 size_t len = ZSTR_LEN(op1_str);
19363
19364 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
19365 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19366 GC_ADD_FLAGS(str, flags);
19367 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19368 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19369 zend_string_release_ex(op2_str, 0);
19370 }
19371 } else {
19372 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
19373 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
19374 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19375 GC_ADD_FLAGS(str, flags);
19376 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19377 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
19378 zend_string_release_ex(op1_str, 0);
19379 }
19380 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
19381 zend_string_release_ex(op2_str, 0);
19382 }
19383 }
19384 ZEND_VM_NEXT_OPCODE();
19385 }
19386
19387 SAVE_OPLINE();
19388 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
19389 op1_str = Z_STR_P(op1);
19390 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
19391 op1_str = zend_string_copy(Z_STR_P(op1));
19392 } else {
19393 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
19394 ZVAL_UNDEFINED_OP1();
19395 }
19396 op1_str = zval_get_string_func(op1);
19397 }
19398 if (IS_CV == IS_CONST) {
19399 op2_str = Z_STR_P(op2);
19400 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
19401 op2_str = zend_string_copy(Z_STR_P(op2));
19402 } else {
19403 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
19404 ZVAL_UNDEFINED_OP2();
19405 }
19406 op2_str = zval_get_string_func(op2);
19407 }
19408 do {
19409 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
19410 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
19411 if (IS_CV == IS_CONST) {
19412 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
19413 GC_ADDREF(op2_str);
19414 }
19415 }
19416 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
19417 zend_string_release_ex(op1_str, 0);
19418 break;
19419 }
19420 }
19421 if (IS_CV != IS_CONST) {
19422 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
19423 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
19424 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
19425 GC_ADDREF(op1_str);
19426 }
19427 }
19428 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
19429 zend_string_release_ex(op2_str, 0);
19430 break;
19431 }
19432 }
19433 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
19434 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
19435 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
19436
19437 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
19438 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
19439 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
19440 zend_string_release_ex(op1_str, 0);
19441 }
19442 if (IS_CV != IS_CONST) {
19443 zend_string_release_ex(op2_str, 0);
19444 }
19445 } while (0);
19446 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19447
19448 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19449 }
19450
ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19451 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19452 {
19453 USE_OPLINE
19454 zval *function_name;
19455 zval *object;
19456 zend_function *fbc;
19457 zend_class_entry *called_scope;
19458 zend_object *obj;
19459 zend_execute_data *call;
19460 uint32_t call_info;
19461
19462 SAVE_OPLINE();
19463
19464 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19465
19466 if (IS_CV != IS_CONST) {
19467 function_name = EX_VAR(opline->op2.var);
19468 }
19469
19470 if (IS_CV != IS_CONST &&
19471 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
19472 do {
19473 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
19474 function_name = Z_REFVAL_P(function_name);
19475 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
19476 break;
19477 }
19478 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
19479 ZVAL_UNDEFINED_OP2();
19480 if (UNEXPECTED(EG(exception) != NULL)) {
19481 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19482 HANDLE_EXCEPTION();
19483 }
19484 }
19485 zend_throw_error(NULL, "Method name must be a string");
19486
19487 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19488 HANDLE_EXCEPTION();
19489 } while (0);
19490 }
19491
19492 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
19493 obj = Z_OBJ_P(object);
19494 } else {
19495 do {
19496 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
19497 obj = Z_OBJ_P(object);
19498 } else {
19499 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
19500 zend_reference *ref = Z_REF_P(object);
19501
19502 object = &ref->val;
19503 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
19504 obj = Z_OBJ_P(object);
19505 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
19506 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19507 efree_size(ref, sizeof(zend_reference));
19508 } else {
19509 Z_ADDREF_P(object);
19510 }
19511 }
19512 break;
19513 }
19514 }
19515 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
19516 object = ZVAL_UNDEFINED_OP1();
19517 if (UNEXPECTED(EG(exception) != NULL)) {
19518 if (IS_CV != IS_CONST) {
19519
19520 }
19521 HANDLE_EXCEPTION();
19522 }
19523 }
19524 if (IS_CV == IS_CONST) {
19525 function_name = EX_VAR(opline->op2.var);
19526 }
19527 zend_invalid_method_call(object, function_name);
19528
19529 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19530 HANDLE_EXCEPTION();
19531 }
19532 } while (0);
19533 }
19534
19535 called_scope = obj->ce;
19536
19537 if (IS_CV == IS_CONST &&
19538 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
19539 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
19540 } else {
19541 zend_object *orig_obj = obj;
19542
19543 if (IS_CV == IS_CONST) {
19544 function_name = EX_VAR(opline->op2.var);
19545 }
19546
19547 /* First, locate the function. */
19548 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
19549 if (UNEXPECTED(fbc == NULL)) {
19550 if (EXPECTED(!EG(exception))) {
19551 zend_undefined_method(obj->ce, Z_STR_P(function_name));
19552 }
19553
19554 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
19555 zend_objects_store_del(orig_obj);
19556 }
19557 HANDLE_EXCEPTION();
19558 }
19559 if (IS_CV == IS_CONST &&
19560 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
19561 EXPECTED(obj == orig_obj)) {
19562 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
19563 }
19564 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
19565 GC_ADDREF(obj); /* For $this pointer */
19566 if (GC_DELREF(orig_obj) == 0) {
19567 zend_objects_store_del(orig_obj);
19568 }
19569 }
19570 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
19571 init_func_run_time_cache(&fbc->op_array);
19572 }
19573 }
19574
19575 if (IS_CV != IS_CONST) {
19576
19577 }
19578
19579 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
19580 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
19581 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
19582 zend_objects_store_del(obj);
19583 if (UNEXPECTED(EG(exception))) {
19584 HANDLE_EXCEPTION();
19585 }
19586 }
19587 /* call static method */
19588 obj = (zend_object*)called_scope;
19589 call_info = ZEND_CALL_NESTED_FUNCTION;
19590 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
19591 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
19592 GC_ADDREF(obj); /* For $this pointer */
19593 }
19594 /* CV may be changed indirectly (e.g. when it's a reference) */
19595 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
19596 }
19597
19598 call = zend_vm_stack_push_call_frame(call_info,
19599 fbc, opline->extended_value, obj);
19600 call->prev_execute_data = EX(call);
19601 EX(call) = call;
19602
19603 ZEND_VM_NEXT_OPCODE();
19604 }
19605
ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19606 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19607 {
19608 USE_OPLINE
19609 zval *op1, *op2;
19610 double d1, d2;
19611
19612 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19613 op2 = EX_VAR(opline->op2.var);
19614 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
19615 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19616 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
19617 case_true:
19618 ZEND_VM_SMART_BRANCH_TRUE();
19619 } else {
19620 case_false:
19621 ZEND_VM_SMART_BRANCH_FALSE();
19622 }
19623 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19624 d1 = (double)Z_LVAL_P(op1);
19625 d2 = Z_DVAL_P(op2);
19626 goto case_double;
19627 }
19628 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
19629 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19630 d1 = Z_DVAL_P(op1);
19631 d2 = Z_DVAL_P(op2);
19632 case_double:
19633 if (d1 == d2) {
19634 goto case_true;
19635 } else {
19636 goto case_false;
19637 }
19638 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19639 d1 = Z_DVAL_P(op1);
19640 d2 = (double)Z_LVAL_P(op2);
19641 goto case_double;
19642 }
19643 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
19644 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
19645 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
19646
19647 if (result) {
19648 goto case_true;
19649 } else {
19650 goto case_false;
19651 }
19652 }
19653 }
19654 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
19655 }
19656
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19657 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19658 {
19659 USE_OPLINE
19660 zval *container;
19661 bool result;
19662 zend_ulong hval;
19663 zval *offset;
19664
19665 SAVE_OPLINE();
19666 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19667 offset = EX_VAR(opline->op2.var);
19668
19669 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19670 HashTable *ht;
19671 zval *value;
19672 zend_string *str;
19673
19674 isset_dim_obj_array:
19675 ht = Z_ARRVAL_P(container);
19676 isset_again:
19677 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
19678 str = Z_STR_P(offset);
19679 if (IS_CV != IS_CONST) {
19680 if (ZEND_HANDLE_NUMERIC(str, hval)) {
19681 goto num_index_prop;
19682 }
19683 }
19684 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
19685 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
19686 hval = Z_LVAL_P(offset);
19687 num_index_prop:
19688 value = zend_hash_index_find(ht, hval);
19689 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
19690 offset = Z_REFVAL_P(offset);
19691 goto isset_again;
19692 } else {
19693 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
19694 if (UNEXPECTED(EG(exception))) {
19695 result = 0;
19696 goto isset_dim_obj_exit;
19697 }
19698 }
19699
19700 if (!(opline->extended_value & ZEND_ISEMPTY)) {
19701 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
19702 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
19703 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
19704
19705 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
19706 /* avoid exception check */
19707
19708 ZEND_VM_SMART_BRANCH(result, 0);
19709 }
19710 } else {
19711 result = (value == NULL || !i_zend_is_true(value));
19712 }
19713 goto isset_dim_obj_exit;
19714 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
19715 container = Z_REFVAL_P(container);
19716 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19717 goto isset_dim_obj_array;
19718 }
19719 }
19720
19721 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
19722 offset++;
19723 }
19724 if (!(opline->extended_value & ZEND_ISEMPTY)) {
19725 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
19726 } else {
19727 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
19728 }
19729
19730 isset_dim_obj_exit:
19731
19732 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19733 ZEND_VM_SMART_BRANCH(result, 1);
19734 }
19735
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19736 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19737 {
19738 USE_OPLINE
19739 zval *container;
19740 int result;
19741 zval *offset;
19742 zend_string *name, *tmp_name;
19743
19744 SAVE_OPLINE();
19745 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19746 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19747
19748 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19749 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19750 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19751 container = Z_REFVAL_P(container);
19752 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
19753 result = (opline->extended_value & ZEND_ISEMPTY);
19754 goto isset_object_finish;
19755 }
19756 } else {
19757 result = (opline->extended_value & ZEND_ISEMPTY);
19758 goto isset_object_finish;
19759 }
19760 }
19761
19762 if (IS_CV == IS_CONST) {
19763 name = Z_STR_P(offset);
19764 } else {
19765 name = zval_try_get_tmp_string(offset, &tmp_name);
19766 if (UNEXPECTED(!name)) {
19767 result = 0;
19768 goto isset_object_finish;
19769 }
19770 }
19771
19772 result =
19773 (opline->extended_value & ZEND_ISEMPTY) ^
19774 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));
19775
19776 if (IS_CV != IS_CONST) {
19777 zend_tmp_string_release(tmp_name);
19778 }
19779
19780 isset_object_finish:
19781
19782 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19783 ZEND_VM_SMART_BRANCH(result, 1);
19784 }
19785
ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19786 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19787 {
19788 USE_OPLINE
19789
19790 zval *key, *subject;
19791 HashTable *ht;
19792 bool result;
19793
19794 SAVE_OPLINE();
19795
19796 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19797 subject = EX_VAR(opline->op2.var);
19798
19799 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
19800 array_key_exists_array:
19801 ht = Z_ARRVAL_P(subject);
19802 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
19803 } else {
19804 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
19805 subject = Z_REFVAL_P(subject);
19806 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
19807 goto array_key_exists_array;
19808 }
19809 }
19810 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
19811 result = 0;
19812 }
19813
19814 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19815 ZEND_VM_SMART_BRANCH(result, 1);
19816 }
19817
ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19818 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19819 {
19820 USE_OPLINE
19821 zval *retval_ptr;
19822 zval *return_value;
19823
19824 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19825 return_value = EX(return_value);
19826
19827 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
19828 SAVE_OPLINE();
19829 retval_ptr = ZVAL_UNDEFINED_OP1();
19830 if (return_value) {
19831 ZVAL_NULL(return_value);
19832 }
19833 } else if (!return_value) {
19834 if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
19835 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
19836 SAVE_OPLINE();
19837 rc_dtor_func(Z_COUNTED_P(retval_ptr));
19838 }
19839 }
19840 } else {
19841 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
19842 ZVAL_COPY_VALUE(return_value, retval_ptr);
19843 if (IS_TMP_VAR == IS_CONST) {
19844 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
19845 Z_ADDREF_P(return_value);
19846 }
19847 }
19848 } else if (IS_TMP_VAR == IS_CV) {
19849 do {
19850 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19851 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
19852 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
19853 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
19854 ZVAL_COPY_VALUE(return_value, retval_ptr);
19855 if (GC_MAY_LEAK(ref)) {
19856 SAVE_OPLINE();
19857 gc_possible_root(ref);
19858 }
19859 ZVAL_NULL(retval_ptr);
19860 break;
19861 } else {
19862 Z_ADDREF_P(retval_ptr);
19863 }
19864 } else {
19865 retval_ptr = Z_REFVAL_P(retval_ptr);
19866 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19867 Z_ADDREF_P(retval_ptr);
19868 }
19869 }
19870 }
19871 ZVAL_COPY_VALUE(return_value, retval_ptr);
19872 } while (0);
19873 } else /* if (IS_TMP_VAR == IS_VAR) */ {
19874 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
19875 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
19876
19877 retval_ptr = Z_REFVAL_P(retval_ptr);
19878 ZVAL_COPY_VALUE(return_value, retval_ptr);
19879 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19880 efree_size(ref, sizeof(zend_reference));
19881 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19882 Z_ADDREF_P(retval_ptr);
19883 }
19884 } else {
19885 ZVAL_COPY_VALUE(return_value, retval_ptr);
19886 }
19887 }
19888 }
19889
19890
19891
19892 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
19893 }
19894
ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19895 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19896 {
19897 USE_OPLINE
19898 zval *retval_ptr;
19899 zval *return_value;
19900
19901 SAVE_OPLINE();
19902
19903 return_value = EX(return_value);
19904
19905 do {
19906 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) ||
19907 (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
19908 /* Not supposed to happen, but we'll allow it */
19909 zend_error(E_NOTICE, "Only variable references should be returned by reference");
19910
19911 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19912 if (!return_value) {
19913 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19914 } else {
19915 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
19916 ZVAL_COPY_VALUE(return_value, retval_ptr);
19917 break;
19918 }
19919
19920 ZVAL_NEW_REF(return_value, retval_ptr);
19921 if (IS_TMP_VAR == IS_CONST) {
19922 Z_TRY_ADDREF_P(retval_ptr);
19923 }
19924 }
19925 break;
19926 }
19927
19928 retval_ptr = zend_get_bad_ptr();
19929
19930 if (IS_TMP_VAR == IS_VAR) {
19931 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
19932 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
19933 zend_error(E_NOTICE, "Only variable references should be returned by reference");
19934 if (return_value) {
19935 ZVAL_NEW_REF(return_value, retval_ptr);
19936 } else {
19937 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19938 }
19939 break;
19940 }
19941 }
19942
19943 if (return_value) {
19944 if (Z_ISREF_P(retval_ptr)) {
19945 Z_ADDREF_P(retval_ptr);
19946 } else {
19947 ZVAL_MAKE_REF_EX(retval_ptr, 2);
19948 }
19949 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
19950 }
19951
19952 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19953 } while (0);
19954
19955
19956 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
19957 }
19958
ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19959 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19960 {
19961 USE_OPLINE
19962 zval *retval;
19963
19964 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
19965
19966 SAVE_OPLINE();
19967 retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19968
19969 /* Copy return value into generator->retval */
19970 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
19971 ZVAL_COPY_VALUE(&generator->retval, retval);
19972 if (IS_TMP_VAR == IS_CONST) {
19973 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
19974 Z_ADDREF(generator->retval);
19975 }
19976 }
19977 } else if (IS_TMP_VAR == IS_CV) {
19978 ZVAL_COPY_DEREF(&generator->retval, retval);
19979 } else /* if (IS_TMP_VAR == IS_VAR) */ {
19980 if (UNEXPECTED(Z_ISREF_P(retval))) {
19981 zend_refcounted *ref = Z_COUNTED_P(retval);
19982
19983 retval = Z_REFVAL_P(retval);
19984 ZVAL_COPY_VALUE(&generator->retval, retval);
19985 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19986 efree_size(ref, sizeof(zend_reference));
19987 } else if (Z_OPT_REFCOUNTED_P(retval)) {
19988 Z_ADDREF_P(retval);
19989 }
19990 } else {
19991 ZVAL_COPY_VALUE(&generator->retval, retval);
19992 }
19993 }
19994
19995 EG(current_execute_data) = EX(prev_execute_data);
19996
19997 /* Close the generator to free up resources */
19998 zend_generator_close(generator, 1);
19999
20000 /* Pass execution back to handling code */
20001 ZEND_VM_RETURN();
20002 }
20003
ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20004 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20005 {
20006 USE_OPLINE
20007 zval *arg, *param;
20008
20009 SAVE_OPLINE();
20010
20011 arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20012 param = ZEND_CALL_VAR(EX(call), opline->result.var);
20013 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
20014 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
20015 Z_TRY_ADDREF_P(arg);
20016 ZVAL_NEW_REF(param, arg);
20017 } else {
20018 ZVAL_COPY(param, arg);
20019 }
20020
20021 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20022 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20023 }
20024
ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20025 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20026 {
20027 USE_OPLINE
20028 zval *expr;
20029 zval *result = EX_VAR(opline->result.var);
20030 HashTable *ht;
20031
20032 SAVE_OPLINE();
20033 expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20034
20035 switch (opline->extended_value) {
20036 case IS_LONG:
20037 ZVAL_LONG(result, zval_get_long(expr));
20038 break;
20039 case IS_DOUBLE:
20040 ZVAL_DOUBLE(result, zval_get_double(expr));
20041 break;
20042 case IS_STRING:
20043 ZVAL_STR(result, zval_get_string(expr));
20044 break;
20045 default:
20046 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
20047 if (IS_TMP_VAR & (IS_VAR|IS_CV)) {
20048 ZVAL_DEREF(expr);
20049 }
20050 /* If value is already of correct type, return it directly */
20051 if (Z_TYPE_P(expr) == opline->extended_value) {
20052 ZVAL_COPY_VALUE(result, expr);
20053 if (IS_TMP_VAR == IS_CONST) {
20054 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20055 } else if (IS_TMP_VAR != IS_TMP_VAR) {
20056 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20057 }
20058
20059 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20060 }
20061
20062 if (opline->extended_value == IS_ARRAY) {
20063 if (IS_TMP_VAR == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
20064 if (Z_TYPE_P(expr) != IS_NULL) {
20065 ZVAL_ARR(result, zend_new_array(1));
20066 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
20067 if (IS_TMP_VAR == IS_CONST) {
20068 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
20069 } else {
20070 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
20071 }
20072 } else {
20073 ZVAL_EMPTY_ARRAY(result);
20074 }
20075 } else if (ZEND_STD_BUILD_OBJECT_PROPERTIES_ARRAY_COMPATIBLE(expr)) {
20076 /* Optimized version without rebuilding properties HashTable */
20077 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
20078 } else {
20079 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
20080 if (obj_ht) {
20081 /* fast copy */
20082 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
20083 (Z_OBJCE_P(expr)->default_properties_count ||
20084 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
20085 GC_IS_RECURSIVE(obj_ht))));
20086 zend_release_properties(obj_ht);
20087 } else {
20088 ZVAL_EMPTY_ARRAY(result);
20089 }
20090 }
20091 } else {
20092 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
20093 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
20094 if (Z_TYPE_P(expr) == IS_ARRAY) {
20095 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
20096 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
20097 /* TODO: try not to duplicate immutable arrays as well ??? */
20098 ht = zend_array_dup(ht);
20099 }
20100 Z_OBJ_P(result)->properties = ht;
20101 } else if (Z_TYPE_P(expr) != IS_NULL) {
20102 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
20103 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
20104 if (IS_TMP_VAR == IS_CONST) {
20105 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
20106 } else {
20107 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
20108 }
20109 }
20110 }
20111 }
20112
20113 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20114 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20115 }
20116
ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20117 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20118 {
20119 USE_OPLINE
20120 zval *array_ptr, *result;
20121
20122 SAVE_OPLINE();
20123
20124 array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20125 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
20126 result = EX_VAR(opline->result.var);
20127 ZVAL_COPY_VALUE(result, array_ptr);
20128 if (IS_TMP_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
20129 Z_ADDREF_P(array_ptr);
20130 }
20131 Z_FE_POS_P(result) = 0;
20132
20133 ZEND_VM_NEXT_OPCODE();
20134 } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
20135 zend_object *zobj = Z_OBJ_P(array_ptr);
20136 if (!zobj->ce->get_iterator) {
20137 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
20138 zobj = zend_lazy_object_init(zobj);
20139 if (UNEXPECTED(EG(exception))) {
20140 UNDEF_RESULT();
20141
20142 HANDLE_EXCEPTION();
20143 }
20144 }
20145 HashTable *properties = zobj->properties;
20146 if (properties) {
20147 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
20148 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
20149 GC_DELREF(properties);
20150 }
20151 properties = zobj->properties = zend_array_dup(properties);
20152 }
20153 } else {
20154 properties = zobj->handlers->get_properties(zobj);
20155 }
20156
20157 result = EX_VAR(opline->result.var);
20158 ZVAL_COPY_VALUE(result, array_ptr);
20159 if (IS_TMP_VAR != IS_TMP_VAR) {
20160 Z_ADDREF_P(array_ptr);
20161 }
20162
20163 if (zend_hash_num_elements(properties) == 0) {
20164 Z_FE_ITER_P(result) = (uint32_t) -1;
20165
20166 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20167 }
20168
20169 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
20170
20171 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20172 } else {
20173 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
20174
20175 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20176 if (UNEXPECTED(EG(exception))) {
20177 HANDLE_EXCEPTION();
20178 } else if (is_empty) {
20179 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20180 } else {
20181 ZEND_VM_NEXT_OPCODE();
20182 }
20183 }
20184 } else {
20185 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
20186 ZVAL_UNDEF(EX_VAR(opline->result.var));
20187 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
20188 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20189 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20190 }
20191 }
20192
ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20193 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20194 {
20195 USE_OPLINE
20196 zval *array_ptr, *array_ref;
20197
20198 SAVE_OPLINE();
20199
20200 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20201 array_ref = array_ptr = zend_get_bad_ptr();
20202 if (Z_ISREF_P(array_ref)) {
20203 array_ptr = Z_REFVAL_P(array_ref);
20204 }
20205 } else {
20206 array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20207 }
20208
20209 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
20210 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20211 if (array_ptr == array_ref) {
20212 ZVAL_NEW_REF(array_ref, array_ref);
20213 array_ptr = Z_REFVAL_P(array_ref);
20214 }
20215 Z_ADDREF_P(array_ref);
20216 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
20217 } else {
20218 array_ref = EX_VAR(opline->result.var);
20219 ZVAL_NEW_REF(array_ref, array_ptr);
20220 array_ptr = Z_REFVAL_P(array_ref);
20221 }
20222 if (IS_TMP_VAR == IS_CONST) {
20223 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
20224 } else {
20225 SEPARATE_ARRAY(array_ptr);
20226 }
20227 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
20228
20229 ZEND_VM_NEXT_OPCODE();
20230 } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
20231 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
20232 zend_object *zobj = Z_OBJ_P(array_ptr);
20233 HashTable *properties;
20234 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
20235 zobj = zend_lazy_object_init(zobj);
20236 if (UNEXPECTED(EG(exception))) {
20237 UNDEF_RESULT();
20238
20239 HANDLE_EXCEPTION();
20240 }
20241 }
20242 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
20243 if (array_ptr == array_ref) {
20244 ZVAL_NEW_REF(array_ref, array_ref);
20245 array_ptr = Z_REFVAL_P(array_ref);
20246 }
20247 Z_ADDREF_P(array_ref);
20248 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
20249 } else {
20250 array_ptr = EX_VAR(opline->result.var);
20251 ZVAL_COPY_VALUE(array_ptr, array_ref);
20252 }
20253 if (Z_OBJ_P(array_ptr)->properties
20254 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
20255 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
20256 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
20257 }
20258 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
20259 }
20260
20261 properties = Z_OBJPROP_P(array_ptr);
20262 if (zend_hash_num_elements(properties) == 0) {
20263 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
20264
20265 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20266 }
20267
20268 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
20269
20270 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20271 } else {
20272 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
20273 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20274 if (UNEXPECTED(EG(exception))) {
20275 HANDLE_EXCEPTION();
20276 } else if (is_empty) {
20277 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20278 } else {
20279 ZEND_VM_NEXT_OPCODE();
20280 }
20281 }
20282 } else {
20283 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
20284 ZVAL_UNDEF(EX_VAR(opline->result.var));
20285 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
20286 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20287 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
20288 }
20289 }
20290
ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20291 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20292 {
20293 USE_OPLINE
20294
20295 if (E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))
20296 && !E_HAS_ONLY_FATAL_ERRORS(Z_LVAL_P(EX_VAR(opline->op1.var)))) {
20297 EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var));
20298 }
20299 ZEND_VM_NEXT_OPCODE();
20300 }
20301
ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20302 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20303 {
20304 USE_OPLINE
20305 zval *value;
20306 zend_reference *ref = NULL;
20307 bool ret;
20308
20309 SAVE_OPLINE();
20310 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20311
20312 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) {
20313 if (IS_TMP_VAR == IS_VAR) {
20314 ref = Z_REF_P(value);
20315 }
20316 value = Z_REFVAL_P(value);
20317 }
20318
20319 ret = i_zend_is_true(value);
20320
20321 if (UNEXPECTED(EG(exception))) {
20322 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20323 ZVAL_UNDEF(EX_VAR(opline->result.var));
20324 HANDLE_EXCEPTION();
20325 }
20326
20327 if (ret) {
20328 zval *result = EX_VAR(opline->result.var);
20329
20330 ZVAL_COPY_VALUE(result, value);
20331 if (IS_TMP_VAR == IS_CONST) {
20332 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20333 } else if (IS_TMP_VAR == IS_CV) {
20334 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20335 } else if (IS_TMP_VAR == IS_VAR && ref) {
20336 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20337 efree_size(ref, sizeof(zend_reference));
20338 } else if (Z_OPT_REFCOUNTED_P(result)) {
20339 Z_ADDREF_P(result);
20340 }
20341 }
20342 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20343 }
20344
20345 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20346 ZEND_VM_NEXT_OPCODE();
20347 }
20348
ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20349 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20350 {
20351 USE_OPLINE
20352 zval *value;
20353 zend_reference *ref = NULL;
20354
20355 SAVE_OPLINE();
20356 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20357
20358 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
20359 if (IS_TMP_VAR & IS_VAR) {
20360 ref = Z_REF_P(value);
20361 }
20362 value = Z_REFVAL_P(value);
20363 }
20364
20365 if (Z_TYPE_P(value) > IS_NULL) {
20366 zval *result = EX_VAR(opline->result.var);
20367 ZVAL_COPY_VALUE(result, value);
20368 if (IS_TMP_VAR == IS_CONST) {
20369 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
20370 } else if (IS_TMP_VAR == IS_CV) {
20371 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
20372 } else if ((IS_TMP_VAR & IS_VAR) && ref) {
20373 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20374 efree_size(ref, sizeof(zend_reference));
20375 } else if (Z_OPT_REFCOUNTED_P(result)) {
20376 Z_ADDREF_P(result);
20377 }
20378 }
20379 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20380 }
20381
20382 if ((IS_TMP_VAR & IS_VAR) && ref) {
20383 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20384 efree_size(ref, sizeof(zend_reference));
20385 }
20386 }
20387 ZEND_VM_NEXT_OPCODE();
20388 }
20389
ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20390 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20391 {
20392 USE_OPLINE
20393 zval *val, *result;
20394
20395 val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20396
20397 if (Z_TYPE_P(val) > IS_NULL) {
20398 do {
20399 if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
20400 val = Z_REFVAL_P(val);
20401 if (Z_TYPE_P(val) <= IS_NULL) {
20402 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20403 break;
20404 }
20405 }
20406 ZEND_VM_NEXT_OPCODE();
20407 } while (0);
20408 }
20409
20410 result = EX_VAR(opline->result.var);
20411 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
20412 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
20413 ZVAL_NULL(result);
20414 if (IS_TMP_VAR == IS_CV
20415 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
20416 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
20417 ) {
20418 SAVE_OPLINE();
20419 ZVAL_UNDEFINED_OP1();
20420 if (UNEXPECTED(EG(exception) != NULL)) {
20421 HANDLE_EXCEPTION();
20422 }
20423 }
20424 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
20425 ZVAL_FALSE(result);
20426 } else {
20427 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
20428 ZVAL_TRUE(result);
20429 }
20430
20431 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
20432 }
20433
ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20434 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20435 {
20436 USE_OPLINE
20437 zval *value;
20438 zval *result = EX_VAR(opline->result.var);
20439
20440 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20441 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
20442 SAVE_OPLINE();
20443 ZVAL_UNDEFINED_OP1();
20444 ZVAL_NULL(result);
20445 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20446 }
20447
20448 if (IS_TMP_VAR == IS_CV) {
20449 ZVAL_COPY_DEREF(result, value);
20450 } else if (IS_TMP_VAR == IS_VAR) {
20451 if (UNEXPECTED(Z_ISREF_P(value))) {
20452 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
20453 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
20454 efree_size(Z_REF_P(value), sizeof(zend_reference));
20455 } else if (Z_OPT_REFCOUNTED_P(result)) {
20456 Z_ADDREF_P(result);
20457 }
20458 } else {
20459 ZVAL_COPY_VALUE(result, value);
20460 }
20461 } else {
20462 ZVAL_COPY_VALUE(result, value);
20463 if (IS_TMP_VAR == IS_CONST) {
20464 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
20465 Z_ADDREF_P(result);
20466 }
20467 }
20468 }
20469 ZEND_VM_NEXT_OPCODE();
20470 }
20471
ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20472 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20473 {
20474 USE_OPLINE
20475 zval *op1, *op2;
20476 bool result;
20477
20478 SAVE_OPLINE();
20479 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20480 op2 = RT_CONSTANT(opline, opline->op2);
20481 result = fast_is_identical_function(op1, op2);
20482 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20483
20484 ZEND_VM_SMART_BRANCH(result, 1);
20485 }
20486
ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20487 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20488 {
20489 USE_OPLINE
20490 zval *op1, *op2;
20491 bool result;
20492
20493 SAVE_OPLINE();
20494 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20495 op2 = RT_CONSTANT(opline, opline->op2);
20496 result = fast_is_identical_function(op1, op2);
20497
20498 ZEND_VM_SMART_BRANCH(result, 1);
20499 }
20500
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20501 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20502 {
20503 USE_OPLINE
20504 zval *op1, *op2;
20505 bool result;
20506
20507 SAVE_OPLINE();
20508 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20509 op2 = RT_CONSTANT(opline, opline->op2);
20510 result = fast_is_not_identical_function(op1, op2);
20511 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20512
20513 ZEND_VM_SMART_BRANCH(result, 1);
20514 }
20515
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20516 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20517 {
20518 #if 0
20519 USE_OPLINE
20520 #endif
20521
20522 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20523 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20524 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20525 }
20526 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20527 } else {
20528 if (IS_CONST == IS_UNUSED) {
20529 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20530 }
20531 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20532 }
20533 }
20534
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20535 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20536 {
20537 #if 0
20538 USE_OPLINE
20539 #endif
20540
20541 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20542 /* Behave like FETCH_OBJ_W */
20543 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20544 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20545 }
20546 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20547 } else {
20548 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20549 }
20550 }
20551
ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20552 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20553 {
20554 USE_OPLINE
20555 zend_string **rope;
20556 zval *var;
20557
20558 /* op1 and result are the same */
20559 rope = (zend_string**)EX_VAR(opline->op1.var);
20560 if (IS_CONST == IS_CONST) {
20561 var = RT_CONSTANT(opline, opline->op2);
20562 rope[opline->extended_value] = Z_STR_P(var);
20563 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20564 Z_ADDREF_P(var);
20565 }
20566 } else {
20567 var = RT_CONSTANT(opline, opline->op2);
20568 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20569 if (IS_CONST == IS_CV) {
20570 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20571 } else {
20572 rope[opline->extended_value] = Z_STR_P(var);
20573 }
20574 } else {
20575 SAVE_OPLINE();
20576 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20577 ZVAL_UNDEFINED_OP2();
20578 }
20579 rope[opline->extended_value] = zval_get_string_func(var);
20580
20581 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20582 }
20583 }
20584 ZEND_VM_NEXT_OPCODE();
20585 }
20586
ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20587 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20588 {
20589 USE_OPLINE
20590 zend_string **rope;
20591 zval *var, *ret;
20592 uint32_t i;
20593
20594 rope = (zend_string**)EX_VAR(opline->op1.var);
20595 if (IS_CONST == IS_CONST) {
20596 var = RT_CONSTANT(opline, opline->op2);
20597 rope[opline->extended_value] = Z_STR_P(var);
20598 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20599 Z_ADDREF_P(var);
20600 }
20601 } else {
20602 var = RT_CONSTANT(opline, opline->op2);
20603 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20604 if (IS_CONST == IS_CV) {
20605 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20606 } else {
20607 rope[opline->extended_value] = Z_STR_P(var);
20608 }
20609 } else {
20610 SAVE_OPLINE();
20611 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20612 ZVAL_UNDEFINED_OP2();
20613 }
20614 rope[opline->extended_value] = zval_get_string_func(var);
20615
20616 if (UNEXPECTED(EG(exception))) {
20617 for (i = 0; i <= opline->extended_value; i++) {
20618 zend_string_release_ex(rope[i], 0);
20619 }
20620 ZVAL_UNDEF(EX_VAR(opline->result.var));
20621 HANDLE_EXCEPTION();
20622 }
20623 }
20624 }
20625
20626 size_t len = 0;
20627 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
20628 for (i = 0; i <= opline->extended_value; i++) {
20629 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
20630 len += ZSTR_LEN(rope[i]);
20631 }
20632 ret = EX_VAR(opline->result.var);
20633 ZVAL_STR(ret, zend_string_alloc(len, 0));
20634 GC_ADD_FLAGS(Z_STR_P(ret), flags);
20635
20636 char *target = Z_STRVAL_P(ret);
20637 for (i = 0; i <= opline->extended_value; i++) {
20638 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
20639 target += ZSTR_LEN(rope[i]);
20640 zend_string_release_ex(rope[i], 0);
20641 }
20642 *target = '\0';
20643
20644 ZEND_VM_NEXT_OPCODE();
20645 }
20646
ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20647 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20648 {
20649 USE_OPLINE
20650 zval *value, *arg;
20651 uint32_t arg_num;
20652
20653 if (IS_CONST == IS_CONST) {
20654 SAVE_OPLINE();
20655 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
20656 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
20657 if (UNEXPECTED(!arg)) {
20658 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20659 HANDLE_EXCEPTION();
20660 }
20661 } else {
20662 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
20663 arg_num = opline->op2.num;
20664 }
20665
20666 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
20667 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20668 goto send_val_by_ref;
20669 }
20670 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20671 send_val_by_ref:
20672 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
20673 }
20674 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20675 ZVAL_COPY_VALUE(arg, value);
20676 if (IS_TMP_VAR == IS_CONST) {
20677 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
20678 Z_ADDREF_P(arg);
20679 }
20680 }
20681 ZEND_VM_NEXT_OPCODE();
20682 }
20683
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20684 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20685 {
20686 USE_OPLINE
20687 zval *expr_ptr, new_expr;
20688
20689 SAVE_OPLINE();
20690 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
20691 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
20692 expr_ptr = zend_get_bad_ptr();
20693 if (Z_ISREF_P(expr_ptr)) {
20694 Z_ADDREF_P(expr_ptr);
20695 } else {
20696 ZVAL_MAKE_REF_EX(expr_ptr, 2);
20697 }
20698 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20699 } else {
20700 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20701 if (IS_TMP_VAR == IS_TMP_VAR) {
20702 /* pass */
20703 } else if (IS_TMP_VAR == IS_CONST) {
20704 Z_TRY_ADDREF_P(expr_ptr);
20705 } else if (IS_TMP_VAR == IS_CV) {
20706 ZVAL_DEREF(expr_ptr);
20707 Z_TRY_ADDREF_P(expr_ptr);
20708 } else /* if (IS_TMP_VAR == IS_VAR) */ {
20709 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
20710 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
20711
20712 expr_ptr = Z_REFVAL_P(expr_ptr);
20713 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20714 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
20715 expr_ptr = &new_expr;
20716 efree_size(ref, sizeof(zend_reference));
20717 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
20718 Z_ADDREF_P(expr_ptr);
20719 }
20720 }
20721 }
20722 }
20723
20724 if (IS_CONST != IS_UNUSED) {
20725 zval *offset = RT_CONSTANT(opline, opline->op2);
20726 zend_string *str;
20727 zend_ulong hval;
20728
20729 add_again:
20730 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
20731 str = Z_STR_P(offset);
20732 if (IS_CONST != IS_CONST) {
20733 if (ZEND_HANDLE_NUMERIC(str, hval)) {
20734 goto num_index;
20735 }
20736 }
20737 str_index:
20738 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
20739 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
20740 hval = Z_LVAL_P(offset);
20741 num_index:
20742 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
20743 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
20744 offset = Z_REFVAL_P(offset);
20745 goto add_again;
20746 } else if (Z_TYPE_P(offset) == IS_NULL) {
20747 str = ZSTR_EMPTY_ALLOC();
20748 goto str_index;
20749 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
20750 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
20751 goto num_index;
20752 } else if (Z_TYPE_P(offset) == IS_FALSE) {
20753 hval = 0;
20754 goto num_index;
20755 } else if (Z_TYPE_P(offset) == IS_TRUE) {
20756 hval = 1;
20757 goto num_index;
20758 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
20759 zend_use_resource_as_offset(offset);
20760 hval = Z_RES_HANDLE_P(offset);
20761 goto num_index;
20762 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
20763 ZVAL_UNDEFINED_OP2();
20764 str = ZSTR_EMPTY_ALLOC();
20765 goto str_index;
20766 } else {
20767 zend_illegal_array_offset_access(offset);
20768 zval_ptr_dtor_nogc(expr_ptr);
20769 }
20770
20771 } else {
20772 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
20773 zend_cannot_add_element();
20774 zval_ptr_dtor_nogc(expr_ptr);
20775 }
20776 }
20777 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20778 }
20779
ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20780 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20781 {
20782 zval *array;
20783 uint32_t size;
20784 USE_OPLINE
20785
20786 array = EX_VAR(opline->result.var);
20787 if (IS_TMP_VAR != IS_UNUSED) {
20788 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
20789 ZVAL_ARR(array, zend_new_array(size));
20790 /* Explicitly initialize array as not-packed if flag is set */
20791 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
20792 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
20793 }
20794 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20795 } else {
20796 ZVAL_ARR(array, zend_new_array(0));
20797 ZEND_VM_NEXT_OPCODE();
20798 }
20799 }
20800
ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20801 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20802 {
20803 USE_OPLINE
20804
20805 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
20806
20807 SAVE_OPLINE();
20808 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
20809 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20810 }
20811
20812 /* Destroy the previously yielded value */
20813 zval_ptr_dtor(&generator->value);
20814
20815 /* Destroy the previously yielded key */
20816 zval_ptr_dtor(&generator->key);
20817
20818 /* Set the new yielded value */
20819 if (IS_TMP_VAR != IS_UNUSED) {
20820 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
20821 /* Constants and temporary variables aren't yieldable by reference,
20822 * but we still allow them with a notice. */
20823 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
20824 zval *value;
20825
20826 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20827
20828 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20829 ZVAL_COPY_VALUE(&generator->value, value);
20830 if (IS_TMP_VAR == IS_CONST) {
20831 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20832 Z_ADDREF(generator->value);
20833 }
20834 }
20835 } else {
20836 zval *value_ptr = zend_get_bad_ptr();
20837
20838 /* If a function call result is yielded and the function did
20839 * not return by reference we throw a notice. */
20840 do {
20841 if (IS_TMP_VAR == IS_VAR) {
20842 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
20843 if (opline->extended_value == ZEND_RETURNS_FUNCTION
20844 && !Z_ISREF_P(value_ptr)) {
20845 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20846 ZVAL_COPY(&generator->value, value_ptr);
20847 break;
20848 }
20849 }
20850 if (Z_ISREF_P(value_ptr)) {
20851 Z_ADDREF_P(value_ptr);
20852 } else {
20853 ZVAL_MAKE_REF_EX(value_ptr, 2);
20854 }
20855 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
20856 } while (0);
20857
20858 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20859 }
20860 } else {
20861 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20862
20863 /* Consts, temporary variables and references need copying */
20864 if (IS_TMP_VAR == IS_CONST) {
20865 ZVAL_COPY_VALUE(&generator->value, value);
20866 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20867 Z_ADDREF(generator->value);
20868 }
20869 } else if (IS_TMP_VAR == IS_TMP_VAR) {
20870 ZVAL_COPY_VALUE(&generator->value, value);
20871 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
20872 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
20873
20874 } else {
20875 ZVAL_COPY_VALUE(&generator->value, value);
20876 if (IS_TMP_VAR == IS_CV) {
20877 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
20878 }
20879 }
20880 }
20881 } else {
20882 /* If no value was specified yield null */
20883 ZVAL_NULL(&generator->value);
20884 }
20885
20886 /* Set the new yielded key */
20887 if (IS_CONST != IS_UNUSED) {
20888 zval *key = RT_CONSTANT(opline, opline->op2);
20889 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
20890 key = Z_REFVAL_P(key);
20891 }
20892 ZVAL_COPY(&generator->key, key);
20893
20894 if (Z_TYPE(generator->key) == IS_LONG
20895 && Z_LVAL(generator->key) > generator->largest_used_integer_key
20896 ) {
20897 generator->largest_used_integer_key = Z_LVAL(generator->key);
20898 }
20899 } else {
20900 /* If no key was specified we use auto-increment keys */
20901 generator->largest_used_integer_key++;
20902 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
20903 }
20904
20905 if (RETURN_VALUE_USED(opline)) {
20906 /* If the return value of yield is used set the send
20907 * target and initialize it to NULL */
20908 generator->send_target = EX_VAR(opline->result.var);
20909 ZVAL_NULL(generator->send_target);
20910 } else {
20911 generator->send_target = NULL;
20912 }
20913
20914 /* The GOTO VM uses a local opline variable. We need to set the opline
20915 * variable in execute_data so we don't resume at an old position. */
20916 SAVE_OPLINE();
20917
20918 ZEND_VM_RETURN();
20919 }
20920
ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20921 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20922 {
20923 USE_OPLINE
20924 zval *op1;
20925 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
20926 zval *result;
20927
20928 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20929 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
20930 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_TMP_VAR == IS_CONST);
20931 if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) {
20932 zval_ptr_dtor_str(op1);
20933 }
20934 ZEND_VM_SMART_BRANCH(result, 0);
20935 }
20936
20937 if (opline->extended_value) {
20938 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
20939 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
20940 ZEND_VM_SMART_BRANCH(result, 0);
20941 }
20942 SAVE_OPLINE();
20943 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
20944 op1 = Z_REFVAL_P(op1);
20945 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
20946 result = zend_hash_find(ht, Z_STR_P(op1));
20947 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20948 ZEND_VM_SMART_BRANCH(result, 0);
20949 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
20950 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
20951 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20952 ZEND_VM_SMART_BRANCH(result, 0);
20953 }
20954 } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
20955 ZVAL_UNDEFINED_OP1();
20956 }
20957 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
20958 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
20959 SAVE_OPLINE();
20960 ZVAL_UNDEFINED_OP1();
20961 if (UNEXPECTED(EG(exception) != NULL)) {
20962 HANDLE_EXCEPTION();
20963 }
20964 }
20965 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
20966 ZEND_VM_SMART_BRANCH(result, 0);
20967 } else {
20968 zend_string *key;
20969 zval key_tmp;
20970
20971 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
20972 op1 = Z_REFVAL_P(op1);
20973 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
20974 result = zend_hash_find(ht, Z_STR_P(op1));
20975 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20976 ZEND_VM_SMART_BRANCH(result, 0);
20977 }
20978 }
20979
20980 SAVE_OPLINE();
20981 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
20982 ZVAL_STR(&key_tmp, key);
20983 if (zend_compare(op1, &key_tmp) == 0) {
20984 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20985 ZEND_VM_SMART_BRANCH(1, 1);
20986 }
20987 } ZEND_HASH_FOREACH_END();
20988 }
20989 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20990 ZEND_VM_SMART_BRANCH(0, 1);
20991 }
20992
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20993 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20994 {
20995 #if 0
20996 USE_OPLINE
20997 #endif
20998
20999 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21000 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21001 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21002 }
21003 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21004 } else {
21005 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
21006 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21007 }
21008 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21009 }
21010 }
21011
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21012 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21013 {
21014 #if 0
21015 USE_OPLINE
21016 #endif
21017
21018 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21019 /* Behave like FETCH_OBJ_W */
21020 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21021 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21022 }
21023 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21024 } else {
21025 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21026 }
21027 }
21028
ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21029 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21030 {
21031 USE_OPLINE
21032 zend_string **rope;
21033 zval *var;
21034
21035 /* op1 and result are the same */
21036 rope = (zend_string**)EX_VAR(opline->op1.var);
21037 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
21038 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21039 rope[opline->extended_value] = Z_STR_P(var);
21040 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21041 Z_ADDREF_P(var);
21042 }
21043 } else {
21044 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21045 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21046 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
21047 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21048 } else {
21049 rope[opline->extended_value] = Z_STR_P(var);
21050 }
21051 } else {
21052 SAVE_OPLINE();
21053 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21054 ZVAL_UNDEFINED_OP2();
21055 }
21056 rope[opline->extended_value] = zval_get_string_func(var);
21057 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21058 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21059 }
21060 }
21061 ZEND_VM_NEXT_OPCODE();
21062 }
21063
ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21064 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21065 {
21066 USE_OPLINE
21067 zend_string **rope;
21068 zval *var, *ret;
21069 uint32_t i;
21070
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 if (UNEXPECTED(EG(exception))) {
21094 for (i = 0; i <= opline->extended_value; i++) {
21095 zend_string_release_ex(rope[i], 0);
21096 }
21097 ZVAL_UNDEF(EX_VAR(opline->result.var));
21098 HANDLE_EXCEPTION();
21099 }
21100 }
21101 }
21102
21103 size_t len = 0;
21104 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
21105 for (i = 0; i <= opline->extended_value; i++) {
21106 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
21107 len += ZSTR_LEN(rope[i]);
21108 }
21109 ret = EX_VAR(opline->result.var);
21110 ZVAL_STR(ret, zend_string_alloc(len, 0));
21111 GC_ADD_FLAGS(Z_STR_P(ret), flags);
21112
21113 char *target = Z_STRVAL_P(ret);
21114 for (i = 0; i <= opline->extended_value; i++) {
21115 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
21116 target += ZSTR_LEN(rope[i]);
21117 zend_string_release_ex(rope[i], 0);
21118 }
21119 *target = '\0';
21120
21121 ZEND_VM_NEXT_OPCODE();
21122 }
21123
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21124 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21125 {
21126 USE_OPLINE
21127 zval *expr_ptr, new_expr;
21128
21129 SAVE_OPLINE();
21130 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21131 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21132 expr_ptr = zend_get_bad_ptr();
21133 if (Z_ISREF_P(expr_ptr)) {
21134 Z_ADDREF_P(expr_ptr);
21135 } else {
21136 ZVAL_MAKE_REF_EX(expr_ptr, 2);
21137 }
21138 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21139 } else {
21140 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21141 if (IS_TMP_VAR == IS_TMP_VAR) {
21142 /* pass */
21143 } else if (IS_TMP_VAR == IS_CONST) {
21144 Z_TRY_ADDREF_P(expr_ptr);
21145 } else if (IS_TMP_VAR == IS_CV) {
21146 ZVAL_DEREF(expr_ptr);
21147 Z_TRY_ADDREF_P(expr_ptr);
21148 } else /* if (IS_TMP_VAR == IS_VAR) */ {
21149 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21150 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21151
21152 expr_ptr = Z_REFVAL_P(expr_ptr);
21153 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21154 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21155 expr_ptr = &new_expr;
21156 efree_size(ref, sizeof(zend_reference));
21157 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21158 Z_ADDREF_P(expr_ptr);
21159 }
21160 }
21161 }
21162 }
21163
21164 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
21165 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21166 zend_string *str;
21167 zend_ulong hval;
21168
21169 add_again:
21170 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21171 str = Z_STR_P(offset);
21172 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
21173 if (ZEND_HANDLE_NUMERIC(str, hval)) {
21174 goto num_index;
21175 }
21176 }
21177 str_index:
21178 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21179 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21180 hval = Z_LVAL_P(offset);
21181 num_index:
21182 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21183 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21184 offset = Z_REFVAL_P(offset);
21185 goto add_again;
21186 } else if (Z_TYPE_P(offset) == IS_NULL) {
21187 str = ZSTR_EMPTY_ALLOC();
21188 goto str_index;
21189 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21190 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21191 goto num_index;
21192 } else if (Z_TYPE_P(offset) == IS_FALSE) {
21193 hval = 0;
21194 goto num_index;
21195 } else if (Z_TYPE_P(offset) == IS_TRUE) {
21196 hval = 1;
21197 goto num_index;
21198 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21199 zend_use_resource_as_offset(offset);
21200 hval = Z_RES_HANDLE_P(offset);
21201 goto num_index;
21202 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21203 ZVAL_UNDEFINED_OP2();
21204 str = ZSTR_EMPTY_ALLOC();
21205 goto str_index;
21206 } else {
21207 zend_illegal_array_offset_access(offset);
21208 zval_ptr_dtor_nogc(expr_ptr);
21209 }
21210 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21211 } else {
21212 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21213 zend_cannot_add_element();
21214 zval_ptr_dtor_nogc(expr_ptr);
21215 }
21216 }
21217 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21218 }
21219
ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21220 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21221 {
21222 zval *array;
21223 uint32_t size;
21224 USE_OPLINE
21225
21226 array = EX_VAR(opline->result.var);
21227 if (IS_TMP_VAR != IS_UNUSED) {
21228 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21229 ZVAL_ARR(array, zend_new_array(size));
21230 /* Explicitly initialize array as not-packed if flag is set */
21231 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21232 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21233 }
21234 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21235 } else {
21236 ZVAL_ARR(array, zend_new_array(0));
21237 ZEND_VM_NEXT_OPCODE();
21238 }
21239 }
21240
ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21241 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21242 {
21243 USE_OPLINE
21244
21245 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21246
21247 SAVE_OPLINE();
21248 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21249 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21250 }
21251
21252 /* Destroy the previously yielded value */
21253 zval_ptr_dtor(&generator->value);
21254
21255 /* Destroy the previously yielded key */
21256 zval_ptr_dtor(&generator->key);
21257
21258 /* Set the new yielded value */
21259 if (IS_TMP_VAR != IS_UNUSED) {
21260 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21261 /* Constants and temporary variables aren't yieldable by reference,
21262 * but we still allow them with a notice. */
21263 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21264 zval *value;
21265
21266 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21267
21268 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21269 ZVAL_COPY_VALUE(&generator->value, value);
21270 if (IS_TMP_VAR == IS_CONST) {
21271 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21272 Z_ADDREF(generator->value);
21273 }
21274 }
21275 } else {
21276 zval *value_ptr = zend_get_bad_ptr();
21277
21278 /* If a function call result is yielded and the function did
21279 * not return by reference we throw a notice. */
21280 do {
21281 if (IS_TMP_VAR == IS_VAR) {
21282 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21283 if (opline->extended_value == ZEND_RETURNS_FUNCTION
21284 && !Z_ISREF_P(value_ptr)) {
21285 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21286 ZVAL_COPY(&generator->value, value_ptr);
21287 break;
21288 }
21289 }
21290 if (Z_ISREF_P(value_ptr)) {
21291 Z_ADDREF_P(value_ptr);
21292 } else {
21293 ZVAL_MAKE_REF_EX(value_ptr, 2);
21294 }
21295 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21296 } while (0);
21297
21298 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21299 }
21300 } else {
21301 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21302
21303 /* Consts, temporary variables and references need copying */
21304 if (IS_TMP_VAR == IS_CONST) {
21305 ZVAL_COPY_VALUE(&generator->value, value);
21306 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21307 Z_ADDREF(generator->value);
21308 }
21309 } else if (IS_TMP_VAR == IS_TMP_VAR) {
21310 ZVAL_COPY_VALUE(&generator->value, value);
21311 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21312 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21313
21314 } else {
21315 ZVAL_COPY_VALUE(&generator->value, value);
21316 if (IS_TMP_VAR == IS_CV) {
21317 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21318 }
21319 }
21320 }
21321 } else {
21322 /* If no value was specified yield null */
21323 ZVAL_NULL(&generator->value);
21324 }
21325
21326 /* Set the new yielded key */
21327 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
21328 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
21329 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21330 key = Z_REFVAL_P(key);
21331 }
21332 ZVAL_COPY(&generator->key, key);
21333 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21334
21335 if (Z_TYPE(generator->key) == IS_LONG
21336 && Z_LVAL(generator->key) > generator->largest_used_integer_key
21337 ) {
21338 generator->largest_used_integer_key = Z_LVAL(generator->key);
21339 }
21340 } else {
21341 /* If no key was specified we use auto-increment keys */
21342 generator->largest_used_integer_key++;
21343 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21344 }
21345
21346 if (RETURN_VALUE_USED(opline)) {
21347 /* If the return value of yield is used set the send
21348 * target and initialize it to NULL */
21349 generator->send_target = EX_VAR(opline->result.var);
21350 ZVAL_NULL(generator->send_target);
21351 } else {
21352 generator->send_target = NULL;
21353 }
21354
21355 /* The GOTO VM uses a local opline variable. We need to set the opline
21356 * variable in execute_data so we don't resume at an old position. */
21357 SAVE_OPLINE();
21358
21359 ZEND_VM_RETURN();
21360 }
21361
ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21362 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21363 {
21364 USE_OPLINE
21365 zval *op1, *op2;
21366 bool result;
21367
21368 SAVE_OPLINE();
21369 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21370 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21371 result = fast_is_identical_function(op1, op2);
21372 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21373 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21374 ZEND_VM_SMART_BRANCH(result, 1);
21375 }
21376
ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21377 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21378 {
21379 USE_OPLINE
21380 zval *op1, *op2;
21381 bool result;
21382
21383 SAVE_OPLINE();
21384 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21385 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21386 result = fast_is_identical_function(op1, op2);
21387 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21388 ZEND_VM_SMART_BRANCH(result, 1);
21389 }
21390
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21391 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21392 {
21393 USE_OPLINE
21394 zval *op1, *op2;
21395 bool result;
21396
21397 SAVE_OPLINE();
21398 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21399 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
21400 result = fast_is_not_identical_function(op1, op2);
21401 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21402 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21403 ZEND_VM_SMART_BRANCH(result, 1);
21404 }
21405
ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21406 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21407 {
21408 USE_OPLINE
21409 zval *op1, *op2;
21410 bool result;
21411
21412 SAVE_OPLINE();
21413 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21414 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
21415 result = fast_is_identical_function(op1, op2);
21416 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
21417 ZEND_VM_SMART_BRANCH(result, 1);
21418 }
21419
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21420 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21421 {
21422 #if 0
21423 USE_OPLINE
21424 #endif
21425
21426 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21427 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21428 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21429 }
21430 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21431 } else {
21432 if (IS_UNUSED == IS_UNUSED) {
21433 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21434 }
21435 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21436 }
21437 }
21438
ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21439 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21440 {
21441 if (IS_TMP_VAR == IS_UNUSED) {
21442 SAVE_OPLINE();
21443 zend_verify_missing_return_type(EX(func));
21444 HANDLE_EXCEPTION();
21445 } else {
21446 /* prevents "undefined variable opline" errors */
21447 #if 0 || (IS_TMP_VAR != IS_UNUSED)
21448 USE_OPLINE
21449 zval *retval_ref, *retval_ptr;
21450 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
21451 retval_ref = retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21452
21453 if (IS_TMP_VAR == IS_CONST) {
21454 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
21455 retval_ref = retval_ptr = EX_VAR(opline->result.var);
21456 } else if (IS_TMP_VAR == IS_VAR) {
21457 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
21458 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
21459 }
21460 ZVAL_DEREF(retval_ptr);
21461 } else if (IS_TMP_VAR == IS_CV) {
21462 ZVAL_DEREF(retval_ptr);
21463 }
21464
21465 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
21466 ZEND_VM_NEXT_OPCODE();
21467 }
21468
21469 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
21470 SAVE_OPLINE();
21471 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
21472 if (UNEXPECTED(EG(exception))) {
21473 HANDLE_EXCEPTION();
21474 }
21475 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
21476 ZEND_VM_NEXT_OPCODE();
21477 }
21478 }
21479
21480 zend_reference *ref = NULL;
21481 void *cache_slot = CACHE_ADDR(opline->op2.num);
21482 if (UNEXPECTED(retval_ref != retval_ptr)) {
21483 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21484 ref = Z_REF_P(retval_ref);
21485 } else {
21486 /* A cast might happen - unwrap the reference if this is a by-value return */
21487 if (Z_REFCOUNT_P(retval_ref) == 1) {
21488 ZVAL_UNREF(retval_ref);
21489 } else {
21490 Z_DELREF_P(retval_ref);
21491 ZVAL_COPY(retval_ref, retval_ptr);
21492 }
21493 retval_ptr = retval_ref;
21494 }
21495 }
21496
21497 SAVE_OPLINE();
21498 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
21499 zend_verify_return_error(EX(func), retval_ptr);
21500 HANDLE_EXCEPTION();
21501 }
21502 ZEND_VM_NEXT_OPCODE();
21503 #endif
21504 }
21505 }
21506
ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21507 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21508 {
21509 USE_OPLINE
21510 zval *value, *arg;
21511 uint32_t arg_num;
21512
21513 if (IS_UNUSED == IS_CONST) {
21514 SAVE_OPLINE();
21515 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21516 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21517 if (UNEXPECTED(!arg)) {
21518 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21519 HANDLE_EXCEPTION();
21520 }
21521 } else {
21522 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21523 arg_num = opline->op2.num;
21524 }
21525
21526 if (EXPECTED(0)) {
21527 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21528 goto send_val_by_ref;
21529 }
21530 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21531 send_val_by_ref:
21532 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
21533 }
21534 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21535 ZVAL_COPY_VALUE(arg, value);
21536 if (IS_TMP_VAR == IS_CONST) {
21537 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21538 Z_ADDREF_P(arg);
21539 }
21540 }
21541 ZEND_VM_NEXT_OPCODE();
21542 }
21543
ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21544 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21545 {
21546 USE_OPLINE
21547 zval *value, *arg;
21548 uint32_t arg_num;
21549
21550 if (IS_UNUSED == IS_CONST) {
21551 SAVE_OPLINE();
21552 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21553 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21554 if (UNEXPECTED(!arg)) {
21555 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21556 HANDLE_EXCEPTION();
21557 }
21558 } else {
21559 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21560 arg_num = opline->op2.num;
21561 }
21562
21563 if (EXPECTED(1)) {
21564 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21565 goto send_val_by_ref;
21566 }
21567 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21568 send_val_by_ref:
21569 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
21570 }
21571 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21572 ZVAL_COPY_VALUE(arg, value);
21573 if (IS_TMP_VAR == IS_CONST) {
21574 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21575 Z_ADDREF_P(arg);
21576 }
21577 }
21578 ZEND_VM_NEXT_OPCODE();
21579 }
21580
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21581 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21582 {
21583 USE_OPLINE
21584 zval *expr_ptr, new_expr;
21585
21586 SAVE_OPLINE();
21587 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21588 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21589 expr_ptr = zend_get_bad_ptr();
21590 if (Z_ISREF_P(expr_ptr)) {
21591 Z_ADDREF_P(expr_ptr);
21592 } else {
21593 ZVAL_MAKE_REF_EX(expr_ptr, 2);
21594 }
21595 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21596 } else {
21597 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21598 if (IS_TMP_VAR == IS_TMP_VAR) {
21599 /* pass */
21600 } else if (IS_TMP_VAR == IS_CONST) {
21601 Z_TRY_ADDREF_P(expr_ptr);
21602 } else if (IS_TMP_VAR == IS_CV) {
21603 ZVAL_DEREF(expr_ptr);
21604 Z_TRY_ADDREF_P(expr_ptr);
21605 } else /* if (IS_TMP_VAR == IS_VAR) */ {
21606 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21607 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21608
21609 expr_ptr = Z_REFVAL_P(expr_ptr);
21610 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21611 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21612 expr_ptr = &new_expr;
21613 efree_size(ref, sizeof(zend_reference));
21614 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21615 Z_ADDREF_P(expr_ptr);
21616 }
21617 }
21618 }
21619 }
21620
21621 if (IS_UNUSED != IS_UNUSED) {
21622 zval *offset = NULL;
21623 zend_string *str;
21624 zend_ulong hval;
21625
21626 add_again:
21627 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21628 str = Z_STR_P(offset);
21629 if (IS_UNUSED != IS_CONST) {
21630 if (ZEND_HANDLE_NUMERIC(str, hval)) {
21631 goto num_index;
21632 }
21633 }
21634 str_index:
21635 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21636 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21637 hval = Z_LVAL_P(offset);
21638 num_index:
21639 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21640 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21641 offset = Z_REFVAL_P(offset);
21642 goto add_again;
21643 } else if (Z_TYPE_P(offset) == IS_NULL) {
21644 str = ZSTR_EMPTY_ALLOC();
21645 goto str_index;
21646 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21647 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21648 goto num_index;
21649 } else if (Z_TYPE_P(offset) == IS_FALSE) {
21650 hval = 0;
21651 goto num_index;
21652 } else if (Z_TYPE_P(offset) == IS_TRUE) {
21653 hval = 1;
21654 goto num_index;
21655 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21656 zend_use_resource_as_offset(offset);
21657 hval = Z_RES_HANDLE_P(offset);
21658 goto num_index;
21659 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21660 ZVAL_UNDEFINED_OP2();
21661 str = ZSTR_EMPTY_ALLOC();
21662 goto str_index;
21663 } else {
21664 zend_illegal_array_offset_access(offset);
21665 zval_ptr_dtor_nogc(expr_ptr);
21666 }
21667
21668 } else {
21669 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21670 zend_cannot_add_element();
21671 zval_ptr_dtor_nogc(expr_ptr);
21672 }
21673 }
21674 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21675 }
21676
ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21677 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21678 {
21679 zval *array;
21680 uint32_t size;
21681 USE_OPLINE
21682
21683 array = EX_VAR(opline->result.var);
21684 if (IS_TMP_VAR != IS_UNUSED) {
21685 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21686 ZVAL_ARR(array, zend_new_array(size));
21687 /* Explicitly initialize array as not-packed if flag is set */
21688 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21689 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21690 }
21691 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21692 } else {
21693 ZVAL_ARR(array, zend_new_array(0));
21694 ZEND_VM_NEXT_OPCODE();
21695 }
21696 }
21697
ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21698 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21699 {
21700 USE_OPLINE
21701
21702 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21703
21704 SAVE_OPLINE();
21705 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21706 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21707 }
21708
21709 /* Destroy the previously yielded value */
21710 zval_ptr_dtor(&generator->value);
21711
21712 /* Destroy the previously yielded key */
21713 zval_ptr_dtor(&generator->key);
21714
21715 /* Set the new yielded value */
21716 if (IS_TMP_VAR != IS_UNUSED) {
21717 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21718 /* Constants and temporary variables aren't yieldable by reference,
21719 * but we still allow them with a notice. */
21720 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21721 zval *value;
21722
21723 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21724
21725 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21726 ZVAL_COPY_VALUE(&generator->value, value);
21727 if (IS_TMP_VAR == IS_CONST) {
21728 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21729 Z_ADDREF(generator->value);
21730 }
21731 }
21732 } else {
21733 zval *value_ptr = zend_get_bad_ptr();
21734
21735 /* If a function call result is yielded and the function did
21736 * not return by reference we throw a notice. */
21737 do {
21738 if (IS_TMP_VAR == IS_VAR) {
21739 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21740 if (opline->extended_value == ZEND_RETURNS_FUNCTION
21741 && !Z_ISREF_P(value_ptr)) {
21742 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21743 ZVAL_COPY(&generator->value, value_ptr);
21744 break;
21745 }
21746 }
21747 if (Z_ISREF_P(value_ptr)) {
21748 Z_ADDREF_P(value_ptr);
21749 } else {
21750 ZVAL_MAKE_REF_EX(value_ptr, 2);
21751 }
21752 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21753 } while (0);
21754
21755 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21756 }
21757 } else {
21758 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21759
21760 /* Consts, temporary variables and references need copying */
21761 if (IS_TMP_VAR == IS_CONST) {
21762 ZVAL_COPY_VALUE(&generator->value, value);
21763 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21764 Z_ADDREF(generator->value);
21765 }
21766 } else if (IS_TMP_VAR == IS_TMP_VAR) {
21767 ZVAL_COPY_VALUE(&generator->value, value);
21768 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21769 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21770
21771 } else {
21772 ZVAL_COPY_VALUE(&generator->value, value);
21773 if (IS_TMP_VAR == IS_CV) {
21774 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21775 }
21776 }
21777 }
21778 } else {
21779 /* If no value was specified yield null */
21780 ZVAL_NULL(&generator->value);
21781 }
21782
21783 /* Set the new yielded key */
21784 if (IS_UNUSED != IS_UNUSED) {
21785 zval *key = NULL;
21786 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21787 key = Z_REFVAL_P(key);
21788 }
21789 ZVAL_COPY(&generator->key, key);
21790
21791 if (Z_TYPE(generator->key) == IS_LONG
21792 && Z_LVAL(generator->key) > generator->largest_used_integer_key
21793 ) {
21794 generator->largest_used_integer_key = Z_LVAL(generator->key);
21795 }
21796 } else {
21797 /* If no key was specified we use auto-increment keys */
21798 generator->largest_used_integer_key++;
21799 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21800 }
21801
21802 if (RETURN_VALUE_USED(opline)) {
21803 /* If the return value of yield is used set the send
21804 * target and initialize it to NULL */
21805 generator->send_target = EX_VAR(opline->result.var);
21806 ZVAL_NULL(generator->send_target);
21807 } else {
21808 generator->send_target = NULL;
21809 }
21810
21811 /* The GOTO VM uses a local opline variable. We need to set the opline
21812 * variable in execute_data so we don't resume at an old position. */
21813 SAVE_OPLINE();
21814
21815 ZEND_VM_RETURN();
21816 }
21817
ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21818 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21819 {
21820 USE_OPLINE
21821 zval *op1;
21822 zend_string *type;
21823
21824 SAVE_OPLINE();
21825 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21826 type = zend_zval_get_legacy_type(op1);
21827 if (EXPECTED(type)) {
21828 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
21829 } else {
21830 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
21831 }
21832 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21833 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21834 }
21835
ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21836 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21837 {
21838 USE_OPLINE
21839 zval *op1, *op2;
21840 bool result;
21841
21842 SAVE_OPLINE();
21843 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21844 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21845 result = fast_is_identical_function(op1, op2);
21846
21847 ZEND_VM_SMART_BRANCH(result, 1);
21848 }
21849
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21850 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21851 {
21852 #if 0
21853 USE_OPLINE
21854 #endif
21855
21856 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21857 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21858 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21859 }
21860 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21861 } else {
21862 if (IS_CV == IS_UNUSED) {
21863 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21864 }
21865 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21866 }
21867 }
21868
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21869 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21870 {
21871 #if 0
21872 USE_OPLINE
21873 #endif
21874
21875 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21876 /* Behave like FETCH_OBJ_W */
21877 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21878 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21879 }
21880 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21881 } else {
21882 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21883 }
21884 }
21885
ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21886 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21887 {
21888 USE_OPLINE
21889 zend_string **rope;
21890 zval *var;
21891
21892 /* op1 and result are the same */
21893 rope = (zend_string**)EX_VAR(opline->op1.var);
21894 if (IS_CV == IS_CONST) {
21895 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21896 rope[opline->extended_value] = Z_STR_P(var);
21897 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21898 Z_ADDREF_P(var);
21899 }
21900 } else {
21901 var = EX_VAR(opline->op2.var);
21902 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21903 if (IS_CV == IS_CV) {
21904 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21905 } else {
21906 rope[opline->extended_value] = Z_STR_P(var);
21907 }
21908 } else {
21909 SAVE_OPLINE();
21910 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21911 ZVAL_UNDEFINED_OP2();
21912 }
21913 rope[opline->extended_value] = zval_get_string_func(var);
21914
21915 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21916 }
21917 }
21918 ZEND_VM_NEXT_OPCODE();
21919 }
21920
ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21921 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21922 {
21923 USE_OPLINE
21924 zend_string **rope;
21925 zval *var, *ret;
21926 uint32_t i;
21927
21928 rope = (zend_string**)EX_VAR(opline->op1.var);
21929 if (IS_CV == IS_CONST) {
21930 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21931 rope[opline->extended_value] = Z_STR_P(var);
21932 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21933 Z_ADDREF_P(var);
21934 }
21935 } else {
21936 var = EX_VAR(opline->op2.var);
21937 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21938 if (IS_CV == IS_CV) {
21939 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21940 } else {
21941 rope[opline->extended_value] = Z_STR_P(var);
21942 }
21943 } else {
21944 SAVE_OPLINE();
21945 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21946 ZVAL_UNDEFINED_OP2();
21947 }
21948 rope[opline->extended_value] = zval_get_string_func(var);
21949
21950 if (UNEXPECTED(EG(exception))) {
21951 for (i = 0; i <= opline->extended_value; i++) {
21952 zend_string_release_ex(rope[i], 0);
21953 }
21954 ZVAL_UNDEF(EX_VAR(opline->result.var));
21955 HANDLE_EXCEPTION();
21956 }
21957 }
21958 }
21959
21960 size_t len = 0;
21961 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
21962 for (i = 0; i <= opline->extended_value; i++) {
21963 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
21964 len += ZSTR_LEN(rope[i]);
21965 }
21966 ret = EX_VAR(opline->result.var);
21967 ZVAL_STR(ret, zend_string_alloc(len, 0));
21968 GC_ADD_FLAGS(Z_STR_P(ret), flags);
21969
21970 char *target = Z_STRVAL_P(ret);
21971 for (i = 0; i <= opline->extended_value; i++) {
21972 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
21973 target += ZSTR_LEN(rope[i]);
21974 zend_string_release_ex(rope[i], 0);
21975 }
21976 *target = '\0';
21977
21978 ZEND_VM_NEXT_OPCODE();
21979 }
21980
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21981 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21982 {
21983 USE_OPLINE
21984 zval *expr_ptr, new_expr;
21985
21986 SAVE_OPLINE();
21987 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21988 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21989 expr_ptr = zend_get_bad_ptr();
21990 if (Z_ISREF_P(expr_ptr)) {
21991 Z_ADDREF_P(expr_ptr);
21992 } else {
21993 ZVAL_MAKE_REF_EX(expr_ptr, 2);
21994 }
21995 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21996 } else {
21997 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21998 if (IS_TMP_VAR == IS_TMP_VAR) {
21999 /* pass */
22000 } else if (IS_TMP_VAR == IS_CONST) {
22001 Z_TRY_ADDREF_P(expr_ptr);
22002 } else if (IS_TMP_VAR == IS_CV) {
22003 ZVAL_DEREF(expr_ptr);
22004 Z_TRY_ADDREF_P(expr_ptr);
22005 } else /* if (IS_TMP_VAR == IS_VAR) */ {
22006 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
22007 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
22008
22009 expr_ptr = Z_REFVAL_P(expr_ptr);
22010 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22011 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
22012 expr_ptr = &new_expr;
22013 efree_size(ref, sizeof(zend_reference));
22014 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
22015 Z_ADDREF_P(expr_ptr);
22016 }
22017 }
22018 }
22019 }
22020
22021 if (IS_CV != IS_UNUSED) {
22022 zval *offset = EX_VAR(opline->op2.var);
22023 zend_string *str;
22024 zend_ulong hval;
22025
22026 add_again:
22027 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
22028 str = Z_STR_P(offset);
22029 if (IS_CV != IS_CONST) {
22030 if (ZEND_HANDLE_NUMERIC(str, hval)) {
22031 goto num_index;
22032 }
22033 }
22034 str_index:
22035 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
22036 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
22037 hval = Z_LVAL_P(offset);
22038 num_index:
22039 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
22040 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
22041 offset = Z_REFVAL_P(offset);
22042 goto add_again;
22043 } else if (Z_TYPE_P(offset) == IS_NULL) {
22044 str = ZSTR_EMPTY_ALLOC();
22045 goto str_index;
22046 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
22047 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
22048 goto num_index;
22049 } else if (Z_TYPE_P(offset) == IS_FALSE) {
22050 hval = 0;
22051 goto num_index;
22052 } else if (Z_TYPE_P(offset) == IS_TRUE) {
22053 hval = 1;
22054 goto num_index;
22055 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
22056 zend_use_resource_as_offset(offset);
22057 hval = Z_RES_HANDLE_P(offset);
22058 goto num_index;
22059 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
22060 ZVAL_UNDEFINED_OP2();
22061 str = ZSTR_EMPTY_ALLOC();
22062 goto str_index;
22063 } else {
22064 zend_illegal_array_offset_access(offset);
22065 zval_ptr_dtor_nogc(expr_ptr);
22066 }
22067
22068 } else {
22069 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
22070 zend_cannot_add_element();
22071 zval_ptr_dtor_nogc(expr_ptr);
22072 }
22073 }
22074 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22075 }
22076
ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22077 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22078 {
22079 zval *array;
22080 uint32_t size;
22081 USE_OPLINE
22082
22083 array = EX_VAR(opline->result.var);
22084 if (IS_TMP_VAR != IS_UNUSED) {
22085 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
22086 ZVAL_ARR(array, zend_new_array(size));
22087 /* Explicitly initialize array as not-packed if flag is set */
22088 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
22089 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
22090 }
22091 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22092 } else {
22093 ZVAL_ARR(array, zend_new_array(0));
22094 ZEND_VM_NEXT_OPCODE();
22095 }
22096 }
22097
ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22098 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22099 {
22100 USE_OPLINE
22101
22102 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
22103
22104 SAVE_OPLINE();
22105 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
22106 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22107 }
22108
22109 /* Destroy the previously yielded value */
22110 zval_ptr_dtor(&generator->value);
22111
22112 /* Destroy the previously yielded key */
22113 zval_ptr_dtor(&generator->key);
22114
22115 /* Set the new yielded value */
22116 if (IS_TMP_VAR != IS_UNUSED) {
22117 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
22118 /* Constants and temporary variables aren't yieldable by reference,
22119 * but we still allow them with a notice. */
22120 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
22121 zval *value;
22122
22123 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22124
22125 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22126 ZVAL_COPY_VALUE(&generator->value, value);
22127 if (IS_TMP_VAR == IS_CONST) {
22128 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
22129 Z_ADDREF(generator->value);
22130 }
22131 }
22132 } else {
22133 zval *value_ptr = zend_get_bad_ptr();
22134
22135 /* If a function call result is yielded and the function did
22136 * not return by reference we throw a notice. */
22137 do {
22138 if (IS_TMP_VAR == IS_VAR) {
22139 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
22140 if (opline->extended_value == ZEND_RETURNS_FUNCTION
22141 && !Z_ISREF_P(value_ptr)) {
22142 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
22143 ZVAL_COPY(&generator->value, value_ptr);
22144 break;
22145 }
22146 }
22147 if (Z_ISREF_P(value_ptr)) {
22148 Z_ADDREF_P(value_ptr);
22149 } else {
22150 ZVAL_MAKE_REF_EX(value_ptr, 2);
22151 }
22152 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
22153 } while (0);
22154
22155 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22156 }
22157 } else {
22158 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22159
22160 /* Consts, temporary variables and references need copying */
22161 if (IS_TMP_VAR == IS_CONST) {
22162 ZVAL_COPY_VALUE(&generator->value, value);
22163 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
22164 Z_ADDREF(generator->value);
22165 }
22166 } else if (IS_TMP_VAR == IS_TMP_VAR) {
22167 ZVAL_COPY_VALUE(&generator->value, value);
22168 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
22169 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
22170
22171 } else {
22172 ZVAL_COPY_VALUE(&generator->value, value);
22173 if (IS_TMP_VAR == IS_CV) {
22174 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
22175 }
22176 }
22177 }
22178 } else {
22179 /* If no value was specified yield null */
22180 ZVAL_NULL(&generator->value);
22181 }
22182
22183 /* Set the new yielded key */
22184 if (IS_CV != IS_UNUSED) {
22185 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
22186 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
22187 key = Z_REFVAL_P(key);
22188 }
22189 ZVAL_COPY(&generator->key, key);
22190
22191 if (Z_TYPE(generator->key) == IS_LONG
22192 && Z_LVAL(generator->key) > generator->largest_used_integer_key
22193 ) {
22194 generator->largest_used_integer_key = Z_LVAL(generator->key);
22195 }
22196 } else {
22197 /* If no key was specified we use auto-increment keys */
22198 generator->largest_used_integer_key++;
22199 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
22200 }
22201
22202 if (RETURN_VALUE_USED(opline)) {
22203 /* If the return value of yield is used set the send
22204 * target and initialize it to NULL */
22205 generator->send_target = EX_VAR(opline->result.var);
22206 ZVAL_NULL(generator->send_target);
22207 } else {
22208 generator->send_target = NULL;
22209 }
22210
22211 /* The GOTO VM uses a local opline variable. We need to set the opline
22212 * variable in execute_data so we don't resume at an old position. */
22213 SAVE_OPLINE();
22214
22215 ZEND_VM_RETURN();
22216 }
22217
ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22218 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22219 {
22220 USE_OPLINE
22221 zval *closure, *var;
22222
22223 closure = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
22224 if (opline->extended_value & ZEND_BIND_REF) {
22225 /* By-ref binding */
22226 var = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
22227 if (Z_ISREF_P(var)) {
22228 Z_ADDREF_P(var);
22229 } else {
22230 ZVAL_MAKE_REF_EX(var, 2);
22231 }
22232 } else {
22233 var = EX_VAR(opline->op2.var);
22234 if (UNEXPECTED(Z_ISUNDEF_P(var)) && !(opline->extended_value & ZEND_BIND_IMPLICIT)) {
22235 SAVE_OPLINE();
22236 var = ZVAL_UNDEFINED_OP2();
22237 if (UNEXPECTED(EG(exception))) {
22238 HANDLE_EXCEPTION();
22239 }
22240 }
22241 ZVAL_DEREF(var);
22242 Z_TRY_ADDREF_P(var);
22243 }
22244
22245 zend_closure_bind_var_ex(closure,
22246 (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT)), var);
22247 ZEND_VM_NEXT_OPCODE();
22248 }
22249
zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)22250 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22251 {
22252 USE_OPLINE
22253 zval *var_ptr;
22254
22255 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22256
22257 SAVE_OPLINE();
22258 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22259 ZVAL_UNDEFINED_OP1();
22260 ZVAL_NULL(var_ptr);
22261 }
22262
22263 do {
22264 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22265 zend_reference *ref = Z_REF_P(var_ptr);
22266 var_ptr = Z_REFVAL_P(var_ptr);
22267 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22268 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
22269 break;
22270 }
22271 }
22272 increment_function(var_ptr);
22273 } while (0);
22274
22275 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
22276 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22277 }
22278
22279 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22280 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22281 }
22282
ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22283 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22284 {
22285 USE_OPLINE
22286 zval *var_ptr;
22287
22288 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22289
22290 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22291 fast_long_increment_function(var_ptr);
22292 if (UNEXPECTED(0)) {
22293 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22294 }
22295 ZEND_VM_NEXT_OPCODE();
22296 }
22297
22298 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22299 }
22300
ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22301 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22302 {
22303 USE_OPLINE
22304 zval *var_ptr;
22305
22306 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22307
22308 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22309 fast_long_increment_function(var_ptr);
22310 if (UNEXPECTED(1)) {
22311 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22312 }
22313 ZEND_VM_NEXT_OPCODE();
22314 }
22315
22316 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22317 }
22318
zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)22319 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22320 {
22321 USE_OPLINE
22322 zval *var_ptr;
22323
22324 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22325
22326 SAVE_OPLINE();
22327 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22328 ZVAL_UNDEFINED_OP1();
22329 ZVAL_NULL(var_ptr);
22330 }
22331
22332 do {
22333 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22334 zend_reference *ref = Z_REF_P(var_ptr);
22335 var_ptr = Z_REFVAL_P(var_ptr);
22336
22337 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22338 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
22339 break;
22340 }
22341 }
22342 decrement_function(var_ptr);
22343 } while (0);
22344
22345 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
22346 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22347 }
22348
22349 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22350 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22351 }
22352
ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22353 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22354 {
22355 USE_OPLINE
22356 zval *var_ptr;
22357
22358 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22359
22360 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22361 fast_long_decrement_function(var_ptr);
22362 if (UNEXPECTED(0)) {
22363 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22364 }
22365 ZEND_VM_NEXT_OPCODE();
22366 }
22367
22368 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22369 }
22370
ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22371 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22372 {
22373 USE_OPLINE
22374 zval *var_ptr;
22375
22376 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22377
22378 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22379 fast_long_decrement_function(var_ptr);
22380 if (UNEXPECTED(1)) {
22381 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
22382 }
22383 ZEND_VM_NEXT_OPCODE();
22384 }
22385
22386 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22387 }
22388
zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)22389 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22390 {
22391 USE_OPLINE
22392 zval *var_ptr;
22393
22394 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22395
22396 SAVE_OPLINE();
22397 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22398 ZVAL_UNDEFINED_OP1();
22399 ZVAL_NULL(var_ptr);
22400 }
22401
22402 do {
22403 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22404 zend_reference *ref = Z_REF_P(var_ptr);
22405 var_ptr = Z_REFVAL_P(var_ptr);
22406
22407 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22408 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
22409 break;
22410 }
22411 }
22412 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22413
22414 increment_function(var_ptr);
22415 } while (0);
22416
22417 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22418 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22419 }
22420
ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22421 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22422 {
22423 USE_OPLINE
22424 zval *var_ptr;
22425
22426 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22427
22428 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22429 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
22430 fast_long_increment_function(var_ptr);
22431 ZEND_VM_NEXT_OPCODE();
22432 }
22433
22434 ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22435 }
22436
zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)22437 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
22438 {
22439 USE_OPLINE
22440 zval *var_ptr;
22441
22442 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22443
22444 SAVE_OPLINE();
22445 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
22446 ZVAL_UNDEFINED_OP1();
22447 ZVAL_NULL(var_ptr);
22448 }
22449
22450 do {
22451 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
22452 zend_reference *ref = Z_REF_P(var_ptr);
22453 var_ptr = Z_REFVAL_P(var_ptr);
22454
22455 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
22456 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
22457 break;
22458 }
22459 }
22460 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
22461
22462 decrement_function(var_ptr);
22463 } while (0);
22464
22465 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22466 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22467 }
22468
ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22469 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22470 {
22471 USE_OPLINE
22472 zval *var_ptr;
22473
22474 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22475
22476 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
22477 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
22478 fast_long_decrement_function(var_ptr);
22479 ZEND_VM_NEXT_OPCODE();
22480 }
22481
22482 ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22483 }
22484
ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22485 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22486 {
22487 USE_OPLINE
22488 zval *retval_ptr;
22489 zval *return_value;
22490
22491 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22492 return_value = EX(return_value);
22493
22494 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
22495 SAVE_OPLINE();
22496 retval_ptr = ZVAL_UNDEFINED_OP1();
22497 if (return_value) {
22498 ZVAL_NULL(return_value);
22499 }
22500 } else if (!return_value) {
22501 if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
22502 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
22503 SAVE_OPLINE();
22504 rc_dtor_func(Z_COUNTED_P(retval_ptr));
22505 }
22506 }
22507 } else {
22508 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22509 ZVAL_COPY_VALUE(return_value, retval_ptr);
22510 if (IS_VAR == IS_CONST) {
22511 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
22512 Z_ADDREF_P(return_value);
22513 }
22514 }
22515 } else if (IS_VAR == IS_CV) {
22516 do {
22517 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22518 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
22519 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
22520 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22521 ZVAL_COPY_VALUE(return_value, retval_ptr);
22522 if (GC_MAY_LEAK(ref)) {
22523 SAVE_OPLINE();
22524 gc_possible_root(ref);
22525 }
22526 ZVAL_NULL(retval_ptr);
22527 break;
22528 } else {
22529 Z_ADDREF_P(retval_ptr);
22530 }
22531 } else {
22532 retval_ptr = Z_REFVAL_P(retval_ptr);
22533 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22534 Z_ADDREF_P(retval_ptr);
22535 }
22536 }
22537 }
22538 ZVAL_COPY_VALUE(return_value, retval_ptr);
22539 } while (0);
22540 } else /* if (IS_VAR == IS_VAR) */ {
22541 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22542 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22543
22544 retval_ptr = Z_REFVAL_P(retval_ptr);
22545 ZVAL_COPY_VALUE(return_value, retval_ptr);
22546 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22547 efree_size(ref, sizeof(zend_reference));
22548 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22549 Z_ADDREF_P(retval_ptr);
22550 }
22551 } else {
22552 ZVAL_COPY_VALUE(return_value, retval_ptr);
22553 }
22554 }
22555 }
22556
22557
22558
22559 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22560 }
22561
ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22562 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22563 {
22564 USE_OPLINE
22565 zval *retval_ptr;
22566 zval *return_value;
22567
22568 SAVE_OPLINE();
22569
22570 return_value = EX(return_value);
22571
22572 do {
22573 if ((IS_VAR & (IS_CONST|IS_TMP_VAR)) ||
22574 (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
22575 /* Not supposed to happen, but we'll allow it */
22576 zend_error(E_NOTICE, "Only variable references should be returned by reference");
22577
22578 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22579 if (!return_value) {
22580 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22581 } else {
22582 if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22583 ZVAL_COPY_VALUE(return_value, retval_ptr);
22584 break;
22585 }
22586
22587 ZVAL_NEW_REF(return_value, retval_ptr);
22588 if (IS_VAR == IS_CONST) {
22589 Z_TRY_ADDREF_P(retval_ptr);
22590 }
22591 }
22592 break;
22593 }
22594
22595 retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22596
22597 if (IS_VAR == IS_VAR) {
22598 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
22599 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
22600 zend_error(E_NOTICE, "Only variable references should be returned by reference");
22601 if (return_value) {
22602 ZVAL_NEW_REF(return_value, retval_ptr);
22603 } else {
22604 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22605 }
22606 break;
22607 }
22608 }
22609
22610 if (return_value) {
22611 if (Z_ISREF_P(retval_ptr)) {
22612 Z_ADDREF_P(retval_ptr);
22613 } else {
22614 ZVAL_MAKE_REF_EX(retval_ptr, 2);
22615 }
22616 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
22617 }
22618
22619 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22620 } while (0);
22621
22622
22623 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22624 }
22625
ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22626 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22627 {
22628 USE_OPLINE
22629 zval *retval;
22630
22631 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
22632
22633 SAVE_OPLINE();
22634 retval = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22635
22636 /* Copy return value into generator->retval */
22637 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22638 ZVAL_COPY_VALUE(&generator->retval, retval);
22639 if (IS_VAR == IS_CONST) {
22640 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
22641 Z_ADDREF(generator->retval);
22642 }
22643 }
22644 } else if (IS_VAR == IS_CV) {
22645 ZVAL_COPY_DEREF(&generator->retval, retval);
22646 } else /* if (IS_VAR == IS_VAR) */ {
22647 if (UNEXPECTED(Z_ISREF_P(retval))) {
22648 zend_refcounted *ref = Z_COUNTED_P(retval);
22649
22650 retval = Z_REFVAL_P(retval);
22651 ZVAL_COPY_VALUE(&generator->retval, retval);
22652 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22653 efree_size(ref, sizeof(zend_reference));
22654 } else if (Z_OPT_REFCOUNTED_P(retval)) {
22655 Z_ADDREF_P(retval);
22656 }
22657 } else {
22658 ZVAL_COPY_VALUE(&generator->retval, retval);
22659 }
22660 }
22661
22662 EG(current_execute_data) = EX(prev_execute_data);
22663
22664 /* Close the generator to free up resources */
22665 zend_generator_close(generator, 1);
22666
22667 /* Pass execution back to handling code */
22668 ZEND_VM_RETURN();
22669 }
22670
ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22671 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22672 {
22673 USE_OPLINE
22674 zval *arg, *param;
22675
22676 SAVE_OPLINE();
22677
22678 arg = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22679 param = ZEND_CALL_VAR(EX(call), opline->result.var);
22680 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
22681 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
22682 Z_TRY_ADDREF_P(arg);
22683 ZVAL_NEW_REF(param, arg);
22684 } else {
22685 ZVAL_COPY(param, arg);
22686 }
22687
22688 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22689 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22690 }
22691
ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22692 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22693 {
22694 USE_OPLINE
22695 zval *expr;
22696 zval *result = EX_VAR(opline->result.var);
22697 HashTable *ht;
22698
22699 SAVE_OPLINE();
22700 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22701
22702 switch (opline->extended_value) {
22703 case IS_LONG:
22704 ZVAL_LONG(result, zval_get_long(expr));
22705 break;
22706 case IS_DOUBLE:
22707 ZVAL_DOUBLE(result, zval_get_double(expr));
22708 break;
22709 case IS_STRING:
22710 ZVAL_STR(result, zval_get_string(expr));
22711 break;
22712 default:
22713 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
22714 if (IS_VAR & (IS_VAR|IS_CV)) {
22715 ZVAL_DEREF(expr);
22716 }
22717 /* If value is already of correct type, return it directly */
22718 if (Z_TYPE_P(expr) == opline->extended_value) {
22719 ZVAL_COPY_VALUE(result, expr);
22720 if (IS_VAR == IS_CONST) {
22721 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
22722 } else if (IS_VAR != IS_TMP_VAR) {
22723 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
22724 }
22725
22726 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22727 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22728 }
22729
22730 if (opline->extended_value == IS_ARRAY) {
22731 if (IS_VAR == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
22732 if (Z_TYPE_P(expr) != IS_NULL) {
22733 ZVAL_ARR(result, zend_new_array(1));
22734 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
22735 if (IS_VAR == IS_CONST) {
22736 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
22737 } else {
22738 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
22739 }
22740 } else {
22741 ZVAL_EMPTY_ARRAY(result);
22742 }
22743 } else if (ZEND_STD_BUILD_OBJECT_PROPERTIES_ARRAY_COMPATIBLE(expr)) {
22744 /* Optimized version without rebuilding properties HashTable */
22745 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
22746 } else {
22747 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
22748 if (obj_ht) {
22749 /* fast copy */
22750 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
22751 (Z_OBJCE_P(expr)->default_properties_count ||
22752 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
22753 GC_IS_RECURSIVE(obj_ht))));
22754 zend_release_properties(obj_ht);
22755 } else {
22756 ZVAL_EMPTY_ARRAY(result);
22757 }
22758 }
22759 } else {
22760 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
22761 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
22762 if (Z_TYPE_P(expr) == IS_ARRAY) {
22763 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
22764 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
22765 /* TODO: try not to duplicate immutable arrays as well ??? */
22766 ht = zend_array_dup(ht);
22767 }
22768 Z_OBJ_P(result)->properties = ht;
22769 } else if (Z_TYPE_P(expr) != IS_NULL) {
22770 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
22771 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
22772 if (IS_VAR == IS_CONST) {
22773 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
22774 } else {
22775 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
22776 }
22777 }
22778 }
22779 }
22780
22781 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22782 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22783 }
22784
ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22785 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22786 {
22787 USE_OPLINE
22788 zval *array_ptr, *result;
22789
22790 SAVE_OPLINE();
22791
22792 array_ptr = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22793 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
22794 result = EX_VAR(opline->result.var);
22795 ZVAL_COPY_VALUE(result, array_ptr);
22796 if (IS_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
22797 Z_ADDREF_P(array_ptr);
22798 }
22799 Z_FE_POS_P(result) = 0;
22800
22801 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22802 ZEND_VM_NEXT_OPCODE();
22803 } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
22804 zend_object *zobj = Z_OBJ_P(array_ptr);
22805 if (!zobj->ce->get_iterator) {
22806 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
22807 zobj = zend_lazy_object_init(zobj);
22808 if (UNEXPECTED(EG(exception))) {
22809 UNDEF_RESULT();
22810 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22811 HANDLE_EXCEPTION();
22812 }
22813 }
22814 HashTable *properties = zobj->properties;
22815 if (properties) {
22816 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
22817 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
22818 GC_DELREF(properties);
22819 }
22820 properties = zobj->properties = zend_array_dup(properties);
22821 }
22822 } else {
22823 properties = zobj->handlers->get_properties(zobj);
22824 }
22825
22826 result = EX_VAR(opline->result.var);
22827 ZVAL_COPY_VALUE(result, array_ptr);
22828 if (IS_VAR != IS_TMP_VAR) {
22829 Z_ADDREF_P(array_ptr);
22830 }
22831
22832 if (zend_hash_num_elements(properties) == 0) {
22833 Z_FE_ITER_P(result) = (uint32_t) -1;
22834 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22835 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22836 }
22837
22838 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
22839 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22840 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22841 } else {
22842 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
22843
22844 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22845 if (UNEXPECTED(EG(exception))) {
22846 HANDLE_EXCEPTION();
22847 } else if (is_empty) {
22848 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22849 } else {
22850 ZEND_VM_NEXT_OPCODE();
22851 }
22852 }
22853 } else {
22854 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
22855 ZVAL_UNDEF(EX_VAR(opline->result.var));
22856 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
22857 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22858 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22859 }
22860 }
22861
ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22862 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22863 {
22864 USE_OPLINE
22865 zval *array_ptr, *array_ref;
22866
22867 SAVE_OPLINE();
22868
22869 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22870 array_ref = array_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22871 if (Z_ISREF_P(array_ref)) {
22872 array_ptr = Z_REFVAL_P(array_ref);
22873 }
22874 } else {
22875 array_ref = array_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22876 }
22877
22878 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
22879 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22880 if (array_ptr == array_ref) {
22881 ZVAL_NEW_REF(array_ref, array_ref);
22882 array_ptr = Z_REFVAL_P(array_ref);
22883 }
22884 Z_ADDREF_P(array_ref);
22885 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
22886 } else {
22887 array_ref = EX_VAR(opline->result.var);
22888 ZVAL_NEW_REF(array_ref, array_ptr);
22889 array_ptr = Z_REFVAL_P(array_ref);
22890 }
22891 if (IS_VAR == IS_CONST) {
22892 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
22893 } else {
22894 SEPARATE_ARRAY(array_ptr);
22895 }
22896 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
22897
22898 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22899 ZEND_VM_NEXT_OPCODE();
22900 } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
22901 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
22902 zend_object *zobj = Z_OBJ_P(array_ptr);
22903 HashTable *properties;
22904 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
22905 zobj = zend_lazy_object_init(zobj);
22906 if (UNEXPECTED(EG(exception))) {
22907 UNDEF_RESULT();
22908 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22909 HANDLE_EXCEPTION();
22910 }
22911 }
22912 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22913 if (array_ptr == array_ref) {
22914 ZVAL_NEW_REF(array_ref, array_ref);
22915 array_ptr = Z_REFVAL_P(array_ref);
22916 }
22917 Z_ADDREF_P(array_ref);
22918 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
22919 } else {
22920 array_ptr = EX_VAR(opline->result.var);
22921 ZVAL_COPY_VALUE(array_ptr, array_ref);
22922 }
22923 if (Z_OBJ_P(array_ptr)->properties
22924 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
22925 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
22926 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
22927 }
22928 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
22929 }
22930
22931 properties = Z_OBJPROP_P(array_ptr);
22932 if (zend_hash_num_elements(properties) == 0) {
22933 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
22934 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22935 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22936 }
22937
22938 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
22939 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22940 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22941 } else {
22942 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
22943 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22944 if (UNEXPECTED(EG(exception))) {
22945 HANDLE_EXCEPTION();
22946 } else if (is_empty) {
22947 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22948 } else {
22949 ZEND_VM_NEXT_OPCODE();
22950 }
22951 }
22952 } else {
22953 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
22954 ZVAL_UNDEF(EX_VAR(opline->result.var));
22955 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
22956 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22957 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22958 }
22959 }
22960
ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22961 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22962 {
22963 USE_OPLINE
22964 zval *array;
22965 zval *value;
22966 uint32_t value_type;
22967 HashTable *fe_ht;
22968 HashPosition pos;
22969
22970 array = EX_VAR(opline->op1.var);
22971 if (UNEXPECTED(Z_TYPE_P(array) != IS_ARRAY)) {
22972 ZEND_VM_TAIL_CALL(zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22973 }
22974 fe_ht = Z_ARRVAL_P(array);
22975 pos = Z_FE_POS_P(array);
22976 if (HT_IS_PACKED(fe_ht)) {
22977 value = fe_ht->arPacked + pos;
22978 while (1) {
22979 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
22980 /* reached end of iteration */
22981 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
22982 ZEND_VM_CONTINUE();
22983 }
22984 value_type = Z_TYPE_INFO_P(value);
22985 ZEND_ASSERT(value_type != IS_INDIRECT);
22986 if (EXPECTED(value_type != IS_UNDEF)) {
22987 break;
22988 }
22989 pos++;
22990 value++;
22991 }
22992 Z_FE_POS_P(array) = pos + 1;
22993 if (RETURN_VALUE_USED(opline)) {
22994 ZVAL_LONG(EX_VAR(opline->result.var), pos);
22995 }
22996 } else {
22997 Bucket *p;
22998
22999 p = fe_ht->arData + pos;
23000 while (1) {
23001 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23002 /* reached end of iteration */
23003 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
23004 ZEND_VM_CONTINUE();
23005 }
23006 pos++;
23007 value = &p->val;
23008 value_type = Z_TYPE_INFO_P(value);
23009 ZEND_ASSERT(value_type != IS_INDIRECT);
23010 if (EXPECTED(value_type != IS_UNDEF)) {
23011 break;
23012 }
23013 p++;
23014 }
23015 Z_FE_POS_P(array) = pos;
23016 if (RETURN_VALUE_USED(opline)) {
23017 if (!p->key) {
23018 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23019 } else {
23020 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23021 }
23022 }
23023 }
23024 if (EXPECTED(opline->op2_type == IS_CV)) {
23025 zval *variable_ptr = EX_VAR(opline->op2.var);
23026 SAVE_OPLINE();
23027 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
23028 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23029 } else {
23030 zval *res = EX_VAR(opline->op2.var);
23031 zend_refcounted *gc = Z_COUNTED_P(value);
23032
23033 ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
23034 if (Z_TYPE_INFO_REFCOUNTED(value_type)) {
23035 GC_ADDREF(gc);
23036 }
23037 ZEND_VM_NEXT_OPCODE();
23038 }
23039 }
23040
ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23041 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23042 {
23043 USE_OPLINE
23044 zval *array;
23045 zval *value;
23046 uint32_t value_type;
23047 HashTable *fe_ht;
23048 HashPosition pos;
23049 Bucket *p;
23050
23051 array = EX_VAR(opline->op1.var);
23052 SAVE_OPLINE();
23053
23054 ZVAL_DEREF(array);
23055 if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
23056 pos = zend_hash_iterator_pos_ex(Z_FE_ITER_P(EX_VAR(opline->op1.var)), array);
23057 fe_ht = Z_ARRVAL_P(array);
23058 if (HT_IS_PACKED(fe_ht)) {
23059 value = fe_ht->arPacked + pos;
23060 while (1) {
23061 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23062 /* reached end of iteration */
23063 goto fe_fetch_w_exit;
23064 }
23065 value_type = Z_TYPE_INFO_P(value);
23066 ZEND_ASSERT(value_type != IS_INDIRECT);
23067 if (EXPECTED(value_type != IS_UNDEF)) {
23068 break;
23069 }
23070 pos++;
23071 value++;
23072 }
23073 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos + 1;
23074 if (RETURN_VALUE_USED(opline)) {
23075 ZVAL_LONG(EX_VAR(opline->result.var), pos);
23076 }
23077 } else {
23078 p = fe_ht->arData + pos;
23079 while (1) {
23080 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23081 /* reached end of iteration */
23082 goto fe_fetch_w_exit;
23083 }
23084 pos++;
23085 value = &p->val;
23086 value_type = Z_TYPE_INFO_P(value);
23087 ZEND_ASSERT(value_type != IS_INDIRECT);
23088 if (EXPECTED(value_type != IS_UNDEF)) {
23089 break;
23090 }
23091 p++;
23092 }
23093 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
23094 if (RETURN_VALUE_USED(opline)) {
23095 if (!p->key) {
23096 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23097 } else {
23098 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23099 }
23100 }
23101 }
23102 } else if (EXPECTED(Z_TYPE_P(array) == IS_OBJECT)) {
23103 zend_object_iterator *iter;
23104
23105 if ((iter = zend_iterator_unwrap(array)) == NULL) {
23106 /* plain object */
23107
23108 fe_ht = Z_OBJPROP_P(array);
23109 pos = zend_hash_iterator_pos(Z_FE_ITER_P(EX_VAR(opline->op1.var)), fe_ht);
23110 p = fe_ht->arData + pos;
23111 while (1) {
23112 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
23113 /* reached end of iteration */
23114 goto fe_fetch_w_exit;
23115 }
23116 pos++;
23117 value = &p->val;
23118 value_type = Z_TYPE_INFO_P(value);
23119 if (EXPECTED(value_type != IS_UNDEF)) {
23120 if (UNEXPECTED(value_type == IS_INDIRECT)) {
23121 value = Z_INDIRECT_P(value);
23122 value_type = Z_TYPE_INFO_P(value);
23123 if (EXPECTED(value_type != IS_UNDEF)
23124 && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
23125 if ((value_type & Z_TYPE_MASK) != IS_REFERENCE) {
23126 zend_property_info *prop_info =
23127 zend_get_property_info_for_slot(Z_OBJ_P(array), value);
23128 if (prop_info) {
23129 if (UNEXPECTED(prop_info->flags & ZEND_ACC_READONLY)) {
23130 zend_throw_error(NULL,
23131 "Cannot acquire reference to readonly property %s::$%s",
23132 ZSTR_VAL(prop_info->ce->name), ZSTR_VAL(p->key));
23133 UNDEF_RESULT();
23134 HANDLE_EXCEPTION();
23135 }
23136 if (ZEND_TYPE_IS_SET(prop_info->type)) {
23137 ZVAL_NEW_REF(value, value);
23138 ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(value), prop_info);
23139 value_type = IS_REFERENCE_EX;
23140 }
23141 }
23142 }
23143 break;
23144 }
23145 } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
23146 || !p->key
23147 || zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
23148 break;
23149 }
23150 }
23151 p++;
23152 }
23153 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
23154 if (RETURN_VALUE_USED(opline)) {
23155 if (UNEXPECTED(!p->key)) {
23156 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
23157 } else if (ZSTR_VAL(p->key)[0]) {
23158 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
23159 } else {
23160 const char *class_name, *prop_name;
23161 size_t prop_name_len;
23162 zend_unmangle_property_name_ex(
23163 p->key, &class_name, &prop_name, &prop_name_len);
23164 ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
23165 }
23166 }
23167 } else {
23168 const zend_object_iterator_funcs *funcs = iter->funcs;
23169 if (++iter->index > 0) {
23170 /* This could cause an endless loop if index becomes zero again.
23171 * In case that ever happens we need an additional flag. */
23172 funcs->move_forward(iter);
23173 if (UNEXPECTED(EG(exception) != NULL)) {
23174 UNDEF_RESULT();
23175 HANDLE_EXCEPTION();
23176 }
23177 if (UNEXPECTED(funcs->valid(iter) == FAILURE)) {
23178 /* reached end of iteration */
23179 if (UNEXPECTED(EG(exception) != NULL)) {
23180 UNDEF_RESULT();
23181 HANDLE_EXCEPTION();
23182 }
23183 goto fe_fetch_w_exit;
23184 }
23185 }
23186 value = funcs->get_current_data(iter);
23187 if (UNEXPECTED(EG(exception) != NULL)) {
23188 UNDEF_RESULT();
23189 HANDLE_EXCEPTION();
23190 }
23191 if (!value) {
23192 /* failure in get_current_data */
23193 goto fe_fetch_w_exit;
23194 }
23195 if (RETURN_VALUE_USED(opline)) {
23196 if (funcs->get_current_key) {
23197 funcs->get_current_key(iter, EX_VAR(opline->result.var));
23198 if (UNEXPECTED(EG(exception) != NULL)) {
23199 UNDEF_RESULT();
23200 HANDLE_EXCEPTION();
23201 }
23202 } else {
23203 ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
23204 }
23205 }
23206 value_type = Z_TYPE_INFO_P(value);
23207 }
23208 } else {
23209 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array));
23210 if (UNEXPECTED(EG(exception))) {
23211 UNDEF_RESULT();
23212 HANDLE_EXCEPTION();
23213 }
23214 fe_fetch_w_exit:
23215 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
23216 ZEND_VM_CONTINUE();
23217 }
23218
23219 if (EXPECTED((value_type & Z_TYPE_MASK) != IS_REFERENCE)) {
23220 zend_refcounted *gc = Z_COUNTED_P(value);
23221 zval *ref;
23222 ZVAL_NEW_EMPTY_REF(value);
23223 ref = Z_REFVAL_P(value);
23224 ZVAL_COPY_VALUE_EX(ref, value, gc, value_type);
23225 }
23226 if (EXPECTED(opline->op2_type == IS_CV)) {
23227 zval *variable_ptr = EX_VAR(opline->op2.var);
23228 if (EXPECTED(variable_ptr != value)) {
23229 zend_reference *ref;
23230
23231 ref = Z_REF_P(value);
23232 GC_ADDREF(ref);
23233 i_zval_ptr_dtor(variable_ptr);
23234 ZVAL_REF(variable_ptr, ref);
23235 }
23236 } else {
23237 Z_ADDREF_P(value);
23238 ZVAL_REF(EX_VAR(opline->op2.var), Z_REF_P(value));
23239 }
23240 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23241 }
23242
ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23243 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23244 {
23245 USE_OPLINE
23246 zval *value;
23247 zend_reference *ref = NULL;
23248 bool ret;
23249
23250 SAVE_OPLINE();
23251 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23252
23253 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && Z_ISREF_P(value)) {
23254 if (IS_VAR == IS_VAR) {
23255 ref = Z_REF_P(value);
23256 }
23257 value = Z_REFVAL_P(value);
23258 }
23259
23260 ret = i_zend_is_true(value);
23261
23262 if (UNEXPECTED(EG(exception))) {
23263 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23264 ZVAL_UNDEF(EX_VAR(opline->result.var));
23265 HANDLE_EXCEPTION();
23266 }
23267
23268 if (ret) {
23269 zval *result = EX_VAR(opline->result.var);
23270
23271 ZVAL_COPY_VALUE(result, value);
23272 if (IS_VAR == IS_CONST) {
23273 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
23274 } else if (IS_VAR == IS_CV) {
23275 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
23276 } else if (IS_VAR == IS_VAR && ref) {
23277 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23278 efree_size(ref, sizeof(zend_reference));
23279 } else if (Z_OPT_REFCOUNTED_P(result)) {
23280 Z_ADDREF_P(result);
23281 }
23282 }
23283 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23284 }
23285
23286 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23287 ZEND_VM_NEXT_OPCODE();
23288 }
23289
ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23290 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23291 {
23292 USE_OPLINE
23293 zval *value;
23294 zend_reference *ref = NULL;
23295
23296 SAVE_OPLINE();
23297 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23298
23299 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
23300 if (IS_VAR & IS_VAR) {
23301 ref = Z_REF_P(value);
23302 }
23303 value = Z_REFVAL_P(value);
23304 }
23305
23306 if (Z_TYPE_P(value) > IS_NULL) {
23307 zval *result = EX_VAR(opline->result.var);
23308 ZVAL_COPY_VALUE(result, value);
23309 if (IS_VAR == IS_CONST) {
23310 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
23311 } else if (IS_VAR == IS_CV) {
23312 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
23313 } else if ((IS_VAR & IS_VAR) && ref) {
23314 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23315 efree_size(ref, sizeof(zend_reference));
23316 } else if (Z_OPT_REFCOUNTED_P(result)) {
23317 Z_ADDREF_P(result);
23318 }
23319 }
23320 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23321 }
23322
23323 if ((IS_VAR & IS_VAR) && ref) {
23324 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
23325 efree_size(ref, sizeof(zend_reference));
23326 }
23327 }
23328 ZEND_VM_NEXT_OPCODE();
23329 }
23330
ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23331 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23332 {
23333 USE_OPLINE
23334 zval *val, *result;
23335
23336 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23337
23338 if (Z_TYPE_P(val) > IS_NULL) {
23339 do {
23340 if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
23341 val = Z_REFVAL_P(val);
23342 if (Z_TYPE_P(val) <= IS_NULL) {
23343 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23344 break;
23345 }
23346 }
23347 ZEND_VM_NEXT_OPCODE();
23348 } while (0);
23349 }
23350
23351 result = EX_VAR(opline->result.var);
23352 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
23353 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
23354 ZVAL_NULL(result);
23355 if (IS_VAR == IS_CV
23356 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
23357 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
23358 ) {
23359 SAVE_OPLINE();
23360 ZVAL_UNDEFINED_OP1();
23361 if (UNEXPECTED(EG(exception) != NULL)) {
23362 HANDLE_EXCEPTION();
23363 }
23364 }
23365 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
23366 ZVAL_FALSE(result);
23367 } else {
23368 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
23369 ZVAL_TRUE(result);
23370 }
23371
23372 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
23373 }
23374
ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23375 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23376 {
23377 USE_OPLINE
23378 zval *value;
23379 zval *result = EX_VAR(opline->result.var);
23380
23381 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23382 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
23383 SAVE_OPLINE();
23384 ZVAL_UNDEFINED_OP1();
23385 ZVAL_NULL(result);
23386 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23387 }
23388
23389 if (IS_VAR == IS_CV) {
23390 ZVAL_COPY_DEREF(result, value);
23391 } else if (IS_VAR == IS_VAR) {
23392 if (UNEXPECTED(Z_ISREF_P(value))) {
23393 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
23394 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
23395 efree_size(Z_REF_P(value), sizeof(zend_reference));
23396 } else if (Z_OPT_REFCOUNTED_P(result)) {
23397 Z_ADDREF_P(result);
23398 }
23399 } else {
23400 ZVAL_COPY_VALUE(result, value);
23401 }
23402 } else {
23403 ZVAL_COPY_VALUE(result, value);
23404 if (IS_VAR == IS_CONST) {
23405 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
23406 Z_ADDREF_P(result);
23407 }
23408 }
23409 }
23410 ZEND_VM_NEXT_OPCODE();
23411 }
23412
ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23413 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23414 {
23415 USE_OPLINE
23416 zval *varptr, *arg;
23417
23418 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23419 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
23420
23421 if (IS_VAR == IS_CV) {
23422 ZVAL_COPY(arg, varptr);
23423 } else /* if (IS_VAR == IS_VAR) */ {
23424 ZVAL_COPY_VALUE(arg, varptr);
23425 }
23426
23427 ZEND_VM_NEXT_OPCODE();
23428 }
23429
ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23430 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23431 {
23432 USE_OPLINE
23433 zval *op1, *op2;
23434 bool result;
23435
23436 SAVE_OPLINE();
23437 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23438 op2 = RT_CONSTANT(opline, opline->op2);
23439 result = fast_is_identical_function(op1, op2);
23440 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23441
23442 ZEND_VM_SMART_BRANCH(result, 1);
23443 }
23444
ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23445 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23446 {
23447 USE_OPLINE
23448 zval *op1, *op2;
23449 bool result;
23450
23451 SAVE_OPLINE();
23452 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23453 op2 = RT_CONSTANT(opline, opline->op2);
23454 result = fast_is_identical_function(op1, op2);
23455
23456 ZEND_VM_SMART_BRANCH(result, 1);
23457 }
23458
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23459 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23460 {
23461 USE_OPLINE
23462 zval *op1, *op2;
23463 bool result;
23464
23465 SAVE_OPLINE();
23466 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
23467 op2 = RT_CONSTANT(opline, opline->op2);
23468 result = fast_is_not_identical_function(op1, op2);
23469 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23470
23471 ZEND_VM_SMART_BRANCH(result, 1);
23472 }
23473
ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23474 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23475 {
23476 USE_OPLINE
23477 zval *object;
23478 zval *property;
23479 zval *value;
23480 zval *zptr;
23481 void *_cache_slot[3] = {0};
23482 void **cache_slot;
23483 zend_property_info *prop_info;
23484 zend_object *zobj;
23485 zend_string *name, *tmp_name;
23486
23487 SAVE_OPLINE();
23488 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23489 property = RT_CONSTANT(opline, opline->op2);
23490
23491 do {
23492 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
23493
23494 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23495 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23496 object = Z_REFVAL_P(object);
23497 goto assign_op_object;
23498 }
23499 if (IS_VAR == IS_CV
23500 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23501 ZVAL_UNDEFINED_OP1();
23502 }
23503 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23504 break;
23505 }
23506
23507 assign_op_object:
23508 /* here we are sure we are dealing with an object */
23509 zobj = Z_OBJ_P(object);
23510 if (IS_CONST == IS_CONST) {
23511 name = Z_STR_P(property);
23512 } else {
23513 name = zval_try_get_tmp_string(property, &tmp_name);
23514 if (UNEXPECTED(!name)) {
23515 UNDEF_RESULT();
23516 break;
23517 }
23518 }
23519 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
23520 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23521 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23522 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23523 ZVAL_NULL(EX_VAR(opline->result.var));
23524 }
23525 } else {
23526 zend_reference *ref;
23527
23528 do {
23529 if (UNEXPECTED(Z_ISREF_P(zptr))) {
23530 ref = Z_REF_P(zptr);
23531 zptr = Z_REFVAL_P(zptr);
23532 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23533 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23534 break;
23535 }
23536 }
23537
23538 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23539 if (prop_info) {
23540 /* special case for typed properties */
23541 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
23542 } else {
23543 zend_binary_op(zptr, zptr, value OPLINE_CC);
23544 }
23545 } while (0);
23546
23547 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23548 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
23549 }
23550 }
23551 } else {
23552 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
23553 }
23554 if (IS_CONST != IS_CONST) {
23555 zend_tmp_string_release(tmp_name);
23556 }
23557 } while (0);
23558
23559 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23560
23561 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23562 /* assign_obj has two opcodes! */
23563 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23564 }
23565
23566 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23567 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23568 {
23569 USE_OPLINE
23570 zval *var_ptr;
23571 zval *value, *container, *dim;
23572 HashTable *ht;
23573
23574 SAVE_OPLINE();
23575 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23576
23577 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23578 assign_dim_op_array:
23579 SEPARATE_ARRAY(container);
23580 ht = Z_ARRVAL_P(container);
23581 assign_dim_op_new_array:
23582 dim = RT_CONSTANT(opline, opline->op2);
23583 if (IS_CONST == IS_UNUSED) {
23584 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
23585 if (UNEXPECTED(!var_ptr)) {
23586 zend_cannot_add_element();
23587 goto assign_dim_op_ret_null;
23588 }
23589 } else {
23590 if (IS_CONST == IS_CONST) {
23591 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
23592 } else {
23593 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
23594 }
23595 if (UNEXPECTED(!var_ptr)) {
23596 goto assign_dim_op_ret_null;
23597 }
23598 }
23599
23600 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
23601
23602 do {
23603 if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
23604 zend_reference *ref = Z_REF_P(var_ptr);
23605 var_ptr = Z_REFVAL_P(var_ptr);
23606 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23607 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23608 break;
23609 }
23610 }
23611 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23612 } while (0);
23613
23614 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23615 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23616 }
23617 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23618 } else {
23619 if (EXPECTED(Z_ISREF_P(container))) {
23620 container = Z_REFVAL_P(container);
23621 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23622 goto assign_dim_op_array;
23623 }
23624 }
23625
23626 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
23627 zend_object *obj = Z_OBJ_P(container);
23628
23629 dim = RT_CONSTANT(opline, opline->op2);
23630 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
23631 dim++;
23632 }
23633 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
23634 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
23635 uint8_t old_type;
23636
23637 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
23638 ZVAL_UNDEFINED_OP1();
23639 }
23640 ht = zend_new_array(8);
23641 old_type = Z_TYPE_P(container);
23642 ZVAL_ARR(container, ht);
23643 if (UNEXPECTED(old_type == IS_FALSE)) {
23644 GC_ADDREF(ht);
23645 zend_false_to_array_deprecated();
23646 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
23647 zend_array_destroy(ht);
23648 goto assign_dim_op_ret_null;
23649 }
23650 }
23651 goto assign_dim_op_new_array;
23652 } else {
23653 dim = RT_CONSTANT(opline, opline->op2);
23654 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
23655 assign_dim_op_ret_null:
23656 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23657 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23658 ZVAL_NULL(EX_VAR(opline->result.var));
23659 }
23660 }
23661 }
23662
23663 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23664 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23665 }
23666
ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23667 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23668 {
23669 USE_OPLINE
23670 zval *var_ptr;
23671 zval *value;
23672
23673 SAVE_OPLINE();
23674 value = RT_CONSTANT(opline, opline->op2);
23675 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23676
23677 do {
23678 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
23679 zend_reference *ref = Z_REF_P(var_ptr);
23680 var_ptr = Z_REFVAL_P(var_ptr);
23681 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23682 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23683 break;
23684 }
23685 }
23686 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23687 } while (0);
23688
23689 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23690 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23691 }
23692
23693 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23694 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23695 }
23696
ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23697 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23698 {
23699 USE_OPLINE
23700 zval *object;
23701 zval *property;
23702 zval *zptr;
23703 void *_cache_slot[3] = {0};
23704 void **cache_slot;
23705 zend_property_info *prop_info;
23706 zend_object *zobj;
23707 zend_string *name, *tmp_name;
23708
23709 SAVE_OPLINE();
23710 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23711 property = RT_CONSTANT(opline, opline->op2);
23712
23713 do {
23714 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23715 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23716 object = Z_REFVAL_P(object);
23717 goto pre_incdec_object;
23718 }
23719 if (IS_VAR == IS_CV
23720 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23721 ZVAL_UNDEFINED_OP1();
23722 }
23723 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23724 break;
23725 }
23726
23727 pre_incdec_object:
23728 /* here we are sure we are dealing with an object */
23729 zobj = Z_OBJ_P(object);
23730 if (IS_CONST == IS_CONST) {
23731 name = Z_STR_P(property);
23732 } else {
23733 name = zval_try_get_tmp_string(property, &tmp_name);
23734 if (UNEXPECTED(!name)) {
23735 UNDEF_RESULT();
23736 break;
23737 }
23738 }
23739 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
23740 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23741 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23742 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23743 ZVAL_NULL(EX_VAR(opline->result.var));
23744 }
23745 } else {
23746 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
23747 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23748 }
23749 } else {
23750 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23751 }
23752 if (IS_CONST != IS_CONST) {
23753 zend_tmp_string_release(tmp_name);
23754 }
23755 } while (0);
23756
23757 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23758 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23759 }
23760
ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23761 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23762 {
23763 USE_OPLINE
23764 zval *object;
23765 zval *property;
23766 zval *zptr;
23767 void *_cache_slot[3] = {0};
23768 void **cache_slot;
23769 zend_property_info *prop_info;
23770 zend_object *zobj;
23771 zend_string *name, *tmp_name;
23772
23773 SAVE_OPLINE();
23774 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23775 property = RT_CONSTANT(opline, opline->op2);
23776
23777 do {
23778 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23779 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23780 object = Z_REFVAL_P(object);
23781 goto post_incdec_object;
23782 }
23783 if (IS_VAR == IS_CV
23784 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23785 ZVAL_UNDEFINED_OP1();
23786 }
23787 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23788 break;
23789 }
23790
23791 post_incdec_object:
23792 /* here we are sure we are dealing with an object */
23793 zobj = Z_OBJ_P(object);
23794 if (IS_CONST == IS_CONST) {
23795 name = Z_STR_P(property);
23796 } else {
23797 name = zval_try_get_tmp_string(property, &tmp_name);
23798 if (UNEXPECTED(!name)) {
23799 ZVAL_UNDEF(EX_VAR(opline->result.var));
23800 break;
23801 }
23802 }
23803 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
23804 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23805 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23806 ZVAL_NULL(EX_VAR(opline->result.var));
23807 } else {
23808 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23809 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23810 }
23811 } else {
23812 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23813 }
23814 if (IS_CONST != IS_CONST) {
23815 zend_tmp_string_release(tmp_name);
23816 }
23817 } while (0);
23818
23819 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23820 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23821 }
23822
ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23823 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23824 {
23825 USE_OPLINE
23826 zval *container;
23827
23828 SAVE_OPLINE();
23829 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23830 zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23831
23832 if (IS_VAR == IS_VAR) {
23833 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23834 }
23835 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23836 }
23837
ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23838 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23839 {
23840 USE_OPLINE
23841 zval *container;
23842
23843 SAVE_OPLINE();
23844 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23845 zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23846
23847 if (IS_VAR == IS_VAR) {
23848 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23849 }
23850 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23851 }
23852
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23853 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23854 {
23855 #if 0
23856 USE_OPLINE
23857 #endif
23858
23859 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
23860 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
23861 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23862 }
23863 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23864 } else {
23865 if (IS_CONST == IS_UNUSED) {
23866 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23867 }
23868 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23869 }
23870 }
23871
ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23872 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23873 {
23874 USE_OPLINE
23875 zval *container;
23876
23877 SAVE_OPLINE();
23878 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23879 zend_fetch_dimension_address_UNSET(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23880
23881 if (IS_VAR == IS_VAR) {
23882 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23883 }
23884 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23885 }
23886
ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23887 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23888 {
23889 USE_OPLINE
23890 zval *property, *container, *result;
23891
23892 SAVE_OPLINE();
23893
23894 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23895 property = RT_CONSTANT(opline, opline->op2);
23896 result = EX_VAR(opline->result.var);
23897 zend_fetch_property_address(
23898 result, container, IS_VAR, property, IS_CONST,
23899 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
23900 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
23901
23902 if (IS_VAR == IS_VAR) {
23903 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23904 }
23905 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23906 }
23907
ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23908 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23909 {
23910 USE_OPLINE
23911 zval *property, *container, *result;
23912
23913 SAVE_OPLINE();
23914 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23915 property = RT_CONSTANT(opline, opline->op2);
23916 result = EX_VAR(opline->result.var);
23917 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);
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
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23925 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23926 {
23927 #if 0
23928 USE_OPLINE
23929 #endif
23930
23931 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
23932 /* Behave like FETCH_OBJ_W */
23933 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
23934 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23935 }
23936 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23937 } else {
23938 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23939 }
23940 }
23941
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23942 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23943 {
23944 USE_OPLINE
23945 zval *container, *property, *result;
23946
23947 SAVE_OPLINE();
23948 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23949 property = RT_CONSTANT(opline, opline->op2);
23950 result = EX_VAR(opline->result.var);
23951 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);
23952
23953 if (IS_VAR == IS_VAR) {
23954 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23955 }
23956 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23957 }
23958
ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23959 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23960 {
23961 USE_OPLINE
23962 zval *container, *dim;
23963
23964 SAVE_OPLINE();
23965 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23966 dim = RT_CONSTANT(opline, opline->op2);
23967
23968 if (IS_VAR == IS_VAR
23969 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
23970 && UNEXPECTED(!Z_ISREF_P(container))
23971 ) {
23972 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
23973 zend_fetch_dimension_address_LIST_r(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23974 } else {
23975 zend_fetch_dimension_address_W(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23976 }
23977
23978 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23979 }
23980
ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23981 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23982 {
23983 USE_OPLINE
23984 zval *object, *value, tmp;
23985 zend_object *zobj;
23986 zend_string *name, *tmp_name;
23987 zend_refcounted *garbage = NULL;
23988
23989 SAVE_OPLINE();
23990 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23991 value = RT_CONSTANT((opline+1), (opline+1)->op1);
23992
23993 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23994 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23995 object = Z_REFVAL_P(object);
23996 goto assign_object;
23997 }
23998 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
23999 value = &EG(uninitialized_zval);
24000 goto free_and_exit_assign_obj;
24001 }
24002
24003 assign_object:
24004 zobj = Z_OBJ_P(object);
24005 if (IS_CONST == IS_CONST) {
24006 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24007 void **cache_slot = CACHE_ADDR(opline->extended_value);
24008 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24009 zval *property_val;
24010
24011 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24012 property_val = OBJ_PROP(zobj, prop_offset);
24013 if (Z_TYPE_P(property_val) != IS_UNDEF) {
24014 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24015
24016 if (prop_info != NULL) {
24017 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24018 goto free_and_exit_assign_obj;
24019 } else {
24020 fast_assign_obj:
24021 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24022 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24023 ZVAL_COPY(EX_VAR(opline->result.var), value);
24024 }
24025 goto exit_assign_obj;
24026 }
24027 }
24028 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24029 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24030 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24031 zobj = zend_lazy_object_init(zobj);
24032 if (!zobj) {
24033 value = &EG(uninitialized_zval);
24034 goto free_and_exit_assign_obj;
24035 }
24036 }
24037 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24038 rebuild_object_properties_internal(zobj);
24039 }
24040 if (EXPECTED(zobj->properties != NULL)) {
24041 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24042 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24043 GC_DELREF(zobj->properties);
24044 }
24045 zobj->properties = zend_array_dup(zobj->properties);
24046 }
24047 property_val = zend_hash_find_known_hash(zobj->properties, name);
24048 if (property_val) {
24049 goto fast_assign_obj;
24050 }
24051 }
24052
24053 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24054 if (IS_CONST == IS_CONST) {
24055 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24056 Z_ADDREF_P(value);
24057 }
24058 } else if (IS_CONST != IS_TMP_VAR) {
24059 if (Z_ISREF_P(value)) {
24060 if (IS_CONST == IS_VAR) {
24061 zend_reference *ref = Z_REF_P(value);
24062 if (GC_DELREF(ref) == 0) {
24063 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24064 efree_size(ref, sizeof(zend_reference));
24065 value = &tmp;
24066 } else {
24067 value = Z_REFVAL_P(value);
24068 Z_TRY_ADDREF_P(value);
24069 }
24070 } else {
24071 value = Z_REFVAL_P(value);
24072 Z_TRY_ADDREF_P(value);
24073 }
24074 } else if (IS_CONST == IS_CV) {
24075 Z_TRY_ADDREF_P(value);
24076 }
24077 }
24078 zend_hash_add_new(zobj->properties, name, value);
24079 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24080 ZVAL_COPY(EX_VAR(opline->result.var), value);
24081 }
24082 goto exit_assign_obj;
24083 }
24084 } else {
24085 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24086 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24087 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
24088 property_val = OBJ_PROP(zobj, prop_info->offset);
24089 if (ZEND_TYPE_IS_SET(prop_info->type)) {
24090 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24091 goto free_and_exit_assign_obj;
24092 } else {
24093 goto fast_assign_obj;
24094 }
24095 }
24096 /* Fall through to write_property for hooks. */
24097 }
24098 }
24099 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24100 } else {
24101 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24102 if (UNEXPECTED(!name)) {
24103
24104 UNDEF_RESULT();
24105 goto exit_assign_obj;
24106 }
24107 }
24108
24109 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24110 ZVAL_DEREF(value);
24111 }
24112
24113 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24114
24115 if (IS_CONST != IS_CONST) {
24116 zend_tmp_string_release(tmp_name);
24117 }
24118
24119 free_and_exit_assign_obj:
24120 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24121 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24122 }
24123
24124 exit_assign_obj:
24125 if (garbage) {
24126 GC_DTOR_NO_REF(garbage);
24127 }
24128
24129 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24130 /* assign_obj has two opcodes! */
24131 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24132 }
24133
24134 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24135 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24136 {
24137 USE_OPLINE
24138 zval *object, *value, tmp;
24139 zend_object *zobj;
24140 zend_string *name, *tmp_name;
24141 zend_refcounted *garbage = NULL;
24142
24143 SAVE_OPLINE();
24144 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24145 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24146
24147 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24148 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24149 object = Z_REFVAL_P(object);
24150 goto assign_object;
24151 }
24152 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24153 value = &EG(uninitialized_zval);
24154 goto free_and_exit_assign_obj;
24155 }
24156
24157 assign_object:
24158 zobj = Z_OBJ_P(object);
24159 if (IS_CONST == IS_CONST) {
24160 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24161 void **cache_slot = CACHE_ADDR(opline->extended_value);
24162 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24163 zval *property_val;
24164
24165 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24166 property_val = OBJ_PROP(zobj, prop_offset);
24167 if (Z_TYPE_P(property_val) != IS_UNDEF) {
24168 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24169
24170 if (prop_info != NULL) {
24171 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24172 goto free_and_exit_assign_obj;
24173 } else {
24174 fast_assign_obj:
24175 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
24176 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24177 ZVAL_COPY(EX_VAR(opline->result.var), value);
24178 }
24179 goto exit_assign_obj;
24180 }
24181 }
24182 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24183 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24184 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24185 zobj = zend_lazy_object_init(zobj);
24186 if (!zobj) {
24187 value = &EG(uninitialized_zval);
24188 goto free_and_exit_assign_obj;
24189 }
24190 }
24191 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24192 rebuild_object_properties_internal(zobj);
24193 }
24194 if (EXPECTED(zobj->properties != NULL)) {
24195 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24196 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24197 GC_DELREF(zobj->properties);
24198 }
24199 zobj->properties = zend_array_dup(zobj->properties);
24200 }
24201 property_val = zend_hash_find_known_hash(zobj->properties, name);
24202 if (property_val) {
24203 goto fast_assign_obj;
24204 }
24205 }
24206
24207 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24208 if (IS_TMP_VAR == IS_CONST) {
24209 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24210 Z_ADDREF_P(value);
24211 }
24212 } else if (IS_TMP_VAR != IS_TMP_VAR) {
24213 if (Z_ISREF_P(value)) {
24214 if (IS_TMP_VAR == IS_VAR) {
24215 zend_reference *ref = Z_REF_P(value);
24216 if (GC_DELREF(ref) == 0) {
24217 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24218 efree_size(ref, sizeof(zend_reference));
24219 value = &tmp;
24220 } else {
24221 value = Z_REFVAL_P(value);
24222 Z_TRY_ADDREF_P(value);
24223 }
24224 } else {
24225 value = Z_REFVAL_P(value);
24226 Z_TRY_ADDREF_P(value);
24227 }
24228 } else if (IS_TMP_VAR == IS_CV) {
24229 Z_TRY_ADDREF_P(value);
24230 }
24231 }
24232 zend_hash_add_new(zobj->properties, name, value);
24233 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24234 ZVAL_COPY(EX_VAR(opline->result.var), value);
24235 }
24236 goto exit_assign_obj;
24237 }
24238 } else {
24239 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24240 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24241 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
24242 property_val = OBJ_PROP(zobj, prop_info->offset);
24243 if (ZEND_TYPE_IS_SET(prop_info->type)) {
24244 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24245 goto free_and_exit_assign_obj;
24246 } else {
24247 goto fast_assign_obj;
24248 }
24249 }
24250 /* Fall through to write_property for hooks. */
24251 }
24252 }
24253 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24254 } else {
24255 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24256 if (UNEXPECTED(!name)) {
24257 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24258 UNDEF_RESULT();
24259 goto exit_assign_obj;
24260 }
24261 }
24262
24263 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
24264 ZVAL_DEREF(value);
24265 }
24266
24267 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24268
24269 if (IS_CONST != IS_CONST) {
24270 zend_tmp_string_release(tmp_name);
24271 }
24272
24273 free_and_exit_assign_obj:
24274 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24275 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24276 }
24277 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24278 exit_assign_obj:
24279 if (garbage) {
24280 GC_DTOR_NO_REF(garbage);
24281 }
24282
24283 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24284 /* assign_obj has two opcodes! */
24285 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24286 }
24287
24288 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24289 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24290 {
24291 USE_OPLINE
24292 zval *object, *value, tmp;
24293 zend_object *zobj;
24294 zend_string *name, *tmp_name;
24295 zend_refcounted *garbage = NULL;
24296
24297 SAVE_OPLINE();
24298 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24299 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24300
24301 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24302 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24303 object = Z_REFVAL_P(object);
24304 goto assign_object;
24305 }
24306 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24307 value = &EG(uninitialized_zval);
24308 goto free_and_exit_assign_obj;
24309 }
24310
24311 assign_object:
24312 zobj = Z_OBJ_P(object);
24313 if (IS_CONST == IS_CONST) {
24314 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24315 void **cache_slot = CACHE_ADDR(opline->extended_value);
24316 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24317 zval *property_val;
24318
24319 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24320 property_val = OBJ_PROP(zobj, prop_offset);
24321 if (Z_TYPE_P(property_val) != IS_UNDEF) {
24322 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24323
24324 if (prop_info != NULL) {
24325 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24326 goto free_and_exit_assign_obj;
24327 } else {
24328 fast_assign_obj:
24329 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
24330 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24331 ZVAL_COPY(EX_VAR(opline->result.var), value);
24332 }
24333 goto exit_assign_obj;
24334 }
24335 }
24336 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24337 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24338 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24339 zobj = zend_lazy_object_init(zobj);
24340 if (!zobj) {
24341 value = &EG(uninitialized_zval);
24342 goto free_and_exit_assign_obj;
24343 }
24344 }
24345 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24346 rebuild_object_properties_internal(zobj);
24347 }
24348 if (EXPECTED(zobj->properties != NULL)) {
24349 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24350 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24351 GC_DELREF(zobj->properties);
24352 }
24353 zobj->properties = zend_array_dup(zobj->properties);
24354 }
24355 property_val = zend_hash_find_known_hash(zobj->properties, name);
24356 if (property_val) {
24357 goto fast_assign_obj;
24358 }
24359 }
24360
24361 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24362 if (IS_VAR == IS_CONST) {
24363 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24364 Z_ADDREF_P(value);
24365 }
24366 } else if (IS_VAR != IS_TMP_VAR) {
24367 if (Z_ISREF_P(value)) {
24368 if (IS_VAR == IS_VAR) {
24369 zend_reference *ref = Z_REF_P(value);
24370 if (GC_DELREF(ref) == 0) {
24371 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24372 efree_size(ref, sizeof(zend_reference));
24373 value = &tmp;
24374 } else {
24375 value = Z_REFVAL_P(value);
24376 Z_TRY_ADDREF_P(value);
24377 }
24378 } else {
24379 value = Z_REFVAL_P(value);
24380 Z_TRY_ADDREF_P(value);
24381 }
24382 } else if (IS_VAR == IS_CV) {
24383 Z_TRY_ADDREF_P(value);
24384 }
24385 }
24386 zend_hash_add_new(zobj->properties, name, value);
24387 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24388 ZVAL_COPY(EX_VAR(opline->result.var), value);
24389 }
24390 goto exit_assign_obj;
24391 }
24392 } else {
24393 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24394 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24395 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
24396 property_val = OBJ_PROP(zobj, prop_info->offset);
24397 if (ZEND_TYPE_IS_SET(prop_info->type)) {
24398 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24399 goto free_and_exit_assign_obj;
24400 } else {
24401 goto fast_assign_obj;
24402 }
24403 }
24404 /* Fall through to write_property for hooks. */
24405 }
24406 }
24407 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24408 } else {
24409 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24410 if (UNEXPECTED(!name)) {
24411 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24412 UNDEF_RESULT();
24413 goto exit_assign_obj;
24414 }
24415 }
24416
24417 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
24418 ZVAL_DEREF(value);
24419 }
24420
24421 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24422
24423 if (IS_CONST != IS_CONST) {
24424 zend_tmp_string_release(tmp_name);
24425 }
24426
24427 free_and_exit_assign_obj:
24428 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24429 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24430 }
24431 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24432 exit_assign_obj:
24433 if (garbage) {
24434 GC_DTOR_NO_REF(garbage);
24435 }
24436
24437 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24438 /* assign_obj has two opcodes! */
24439 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24440 }
24441
24442 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24443 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24444 {
24445 USE_OPLINE
24446 zval *object, *value, tmp;
24447 zend_object *zobj;
24448 zend_string *name, *tmp_name;
24449 zend_refcounted *garbage = NULL;
24450
24451 SAVE_OPLINE();
24452 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24453 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
24454
24455 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
24456 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
24457 object = Z_REFVAL_P(object);
24458 goto assign_object;
24459 }
24460 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
24461 value = &EG(uninitialized_zval);
24462 goto free_and_exit_assign_obj;
24463 }
24464
24465 assign_object:
24466 zobj = Z_OBJ_P(object);
24467 if (IS_CONST == IS_CONST) {
24468 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
24469 void **cache_slot = CACHE_ADDR(opline->extended_value);
24470 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
24471 zval *property_val;
24472
24473 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
24474 property_val = OBJ_PROP(zobj, prop_offset);
24475 if (Z_TYPE_P(property_val) != IS_UNDEF) {
24476 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
24477
24478 if (prop_info != NULL) {
24479 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24480 goto free_and_exit_assign_obj;
24481 } else {
24482 fast_assign_obj:
24483 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
24484 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24485 ZVAL_COPY(EX_VAR(opline->result.var), value);
24486 }
24487 goto exit_assign_obj;
24488 }
24489 }
24490 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
24491 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24492 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
24493 zobj = zend_lazy_object_init(zobj);
24494 if (!zobj) {
24495 value = &EG(uninitialized_zval);
24496 goto free_and_exit_assign_obj;
24497 }
24498 }
24499 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24500 rebuild_object_properties_internal(zobj);
24501 }
24502 if (EXPECTED(zobj->properties != NULL)) {
24503 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
24504 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
24505 GC_DELREF(zobj->properties);
24506 }
24507 zobj->properties = zend_array_dup(zobj->properties);
24508 }
24509 property_val = zend_hash_find_known_hash(zobj->properties, name);
24510 if (property_val) {
24511 goto fast_assign_obj;
24512 }
24513 }
24514
24515 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
24516 if (IS_CV == IS_CONST) {
24517 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
24518 Z_ADDREF_P(value);
24519 }
24520 } else if (IS_CV != IS_TMP_VAR) {
24521 if (Z_ISREF_P(value)) {
24522 if (IS_CV == IS_VAR) {
24523 zend_reference *ref = Z_REF_P(value);
24524 if (GC_DELREF(ref) == 0) {
24525 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
24526 efree_size(ref, sizeof(zend_reference));
24527 value = &tmp;
24528 } else {
24529 value = Z_REFVAL_P(value);
24530 Z_TRY_ADDREF_P(value);
24531 }
24532 } else {
24533 value = Z_REFVAL_P(value);
24534 Z_TRY_ADDREF_P(value);
24535 }
24536 } else if (IS_CV == IS_CV) {
24537 Z_TRY_ADDREF_P(value);
24538 }
24539 }
24540 zend_hash_add_new(zobj->properties, name, value);
24541 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24542 ZVAL_COPY(EX_VAR(opline->result.var), value);
24543 }
24544 goto exit_assign_obj;
24545 }
24546 } else {
24547 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
24548 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
24549 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
24550 property_val = OBJ_PROP(zobj, prop_info->offset);
24551 if (ZEND_TYPE_IS_SET(prop_info->type)) {
24552 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
24553 goto free_and_exit_assign_obj;
24554 } else {
24555 goto fast_assign_obj;
24556 }
24557 }
24558 /* Fall through to write_property for hooks. */
24559 }
24560 }
24561 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24562 } else {
24563 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
24564 if (UNEXPECTED(!name)) {
24565
24566 UNDEF_RESULT();
24567 goto exit_assign_obj;
24568 }
24569 }
24570
24571 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24572 ZVAL_DEREF(value);
24573 }
24574
24575 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
24576
24577 if (IS_CONST != IS_CONST) {
24578 zend_tmp_string_release(tmp_name);
24579 }
24580
24581 free_and_exit_assign_obj:
24582 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
24583 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
24584 }
24585
24586 exit_assign_obj:
24587 if (garbage) {
24588 GC_DTOR_NO_REF(garbage);
24589 }
24590
24591 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24592 /* assign_obj has two opcodes! */
24593 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24594 }
24595
24596 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24597 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24598 {
24599 USE_OPLINE
24600 zval *object_ptr, *orig_object_ptr;
24601 zval *value;
24602 zval *variable_ptr;
24603 zval *dim;
24604 zend_refcounted *garbage = NULL;
24605
24606 SAVE_OPLINE();
24607 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24608
24609 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24610 try_assign_dim_array:
24611 SEPARATE_ARRAY(object_ptr);
24612 if (IS_CONST == IS_UNUSED) {
24613 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24614 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24615 HashTable *ht = Z_ARRVAL_P(object_ptr);
24616 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24617 GC_ADDREF(ht);
24618 }
24619 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24620 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24621 zend_array_destroy(ht);
24622 goto assign_dim_error;
24623 }
24624 }
24625 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24626 ZVAL_DEREF(value);
24627 }
24628 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24629 if (UNEXPECTED(value == NULL)) {
24630 zend_cannot_add_element();
24631 goto assign_dim_error;
24632 } else if (IS_CONST == IS_CV) {
24633 if (Z_REFCOUNTED_P(value)) {
24634 Z_ADDREF_P(value);
24635 }
24636 } else if (IS_CONST == IS_VAR) {
24637 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24638 if (Z_ISREF_P(free_op_data)) {
24639 if (Z_REFCOUNTED_P(value)) {
24640 Z_ADDREF_P(value);
24641 }
24642 zval_ptr_dtor_nogc(free_op_data);
24643 }
24644 } else if (IS_CONST == IS_CONST) {
24645 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24646 Z_ADDREF_P(value);
24647 }
24648 }
24649 } else {
24650 dim = RT_CONSTANT(opline, opline->op2);
24651 if (IS_CONST == IS_CONST) {
24652 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24653 } else {
24654 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24655 }
24656 if (UNEXPECTED(variable_ptr == NULL)) {
24657 goto assign_dim_error;
24658 }
24659 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24660 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24661 }
24662 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24663 ZVAL_COPY(EX_VAR(opline->result.var), value);
24664 }
24665 if (garbage) {
24666 GC_DTOR_NO_REF(garbage);
24667 }
24668 } else {
24669 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24670 object_ptr = Z_REFVAL_P(object_ptr);
24671 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24672 goto try_assign_dim_array;
24673 }
24674 }
24675 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24676 zend_object *obj = Z_OBJ_P(object_ptr);
24677
24678 GC_ADDREF(obj);
24679 dim = RT_CONSTANT(opline, opline->op2);
24680 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24681 dim = ZVAL_UNDEFINED_OP2();
24682 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24683 dim++;
24684 }
24685
24686 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24687 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24688 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24689 } else if (IS_CONST & (IS_CV|IS_VAR)) {
24690 ZVAL_DEREF(value);
24691 }
24692
24693 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24694
24695 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24696 zend_objects_store_del(obj);
24697 }
24698 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24699 if (IS_CONST == IS_UNUSED) {
24700 zend_use_new_element_for_string();
24701
24702 UNDEF_RESULT();
24703 } else {
24704 dim = RT_CONSTANT(opline, opline->op2);
24705 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24706 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24707
24708 }
24709 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24710 if (Z_ISREF_P(orig_object_ptr)
24711 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24712 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24713 dim = RT_CONSTANT(opline, opline->op2);
24714
24715 UNDEF_RESULT();
24716 } else {
24717 HashTable *ht = zend_new_array(8);
24718 uint8_t old_type = Z_TYPE_P(object_ptr);
24719
24720 ZVAL_ARR(object_ptr, ht);
24721 if (UNEXPECTED(old_type == IS_FALSE)) {
24722 GC_ADDREF(ht);
24723 zend_false_to_array_deprecated();
24724 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24725 zend_array_destroy(ht);
24726 goto assign_dim_error;
24727 }
24728 }
24729 goto try_assign_dim_array;
24730 }
24731 } else {
24732 zend_use_scalar_as_array();
24733 dim = RT_CONSTANT(opline, opline->op2);
24734 assign_dim_error:
24735
24736 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24737 ZVAL_NULL(EX_VAR(opline->result.var));
24738 }
24739 }
24740 }
24741 if (IS_CONST != IS_UNUSED) {
24742
24743 }
24744 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24745 /* assign_dim has two opcodes! */
24746 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24747 }
24748
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24749 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24750 {
24751 USE_OPLINE
24752 zval *object_ptr, *orig_object_ptr;
24753 zval *value;
24754 zval *variable_ptr;
24755 zval *dim;
24756 zend_refcounted *garbage = NULL;
24757
24758 SAVE_OPLINE();
24759 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24760
24761 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24762 try_assign_dim_array:
24763 SEPARATE_ARRAY(object_ptr);
24764 if (IS_CONST == IS_UNUSED) {
24765 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24766 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24767 HashTable *ht = Z_ARRVAL_P(object_ptr);
24768 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24769 GC_ADDREF(ht);
24770 }
24771 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24772 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24773 zend_array_destroy(ht);
24774 goto assign_dim_error;
24775 }
24776 }
24777 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
24778 ZVAL_DEREF(value);
24779 }
24780 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24781 if (UNEXPECTED(value == NULL)) {
24782 zend_cannot_add_element();
24783 goto assign_dim_error;
24784 } else if (IS_TMP_VAR == IS_CV) {
24785 if (Z_REFCOUNTED_P(value)) {
24786 Z_ADDREF_P(value);
24787 }
24788 } else if (IS_TMP_VAR == IS_VAR) {
24789 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24790 if (Z_ISREF_P(free_op_data)) {
24791 if (Z_REFCOUNTED_P(value)) {
24792 Z_ADDREF_P(value);
24793 }
24794 zval_ptr_dtor_nogc(free_op_data);
24795 }
24796 } else if (IS_TMP_VAR == IS_CONST) {
24797 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24798 Z_ADDREF_P(value);
24799 }
24800 }
24801 } else {
24802 dim = RT_CONSTANT(opline, opline->op2);
24803 if (IS_CONST == IS_CONST) {
24804 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24805 } else {
24806 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24807 }
24808 if (UNEXPECTED(variable_ptr == NULL)) {
24809 goto assign_dim_error;
24810 }
24811 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24812 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
24813 }
24814 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24815 ZVAL_COPY(EX_VAR(opline->result.var), value);
24816 }
24817 if (garbage) {
24818 GC_DTOR_NO_REF(garbage);
24819 }
24820 } else {
24821 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24822 object_ptr = Z_REFVAL_P(object_ptr);
24823 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24824 goto try_assign_dim_array;
24825 }
24826 }
24827 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24828 zend_object *obj = Z_OBJ_P(object_ptr);
24829
24830 GC_ADDREF(obj);
24831 dim = RT_CONSTANT(opline, opline->op2);
24832 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24833 dim = ZVAL_UNDEFINED_OP2();
24834 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24835 dim++;
24836 }
24837
24838 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24839 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24840 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24841 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
24842 ZVAL_DEREF(value);
24843 }
24844
24845 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24846
24847 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24848 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24849 zend_objects_store_del(obj);
24850 }
24851 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24852 if (IS_CONST == IS_UNUSED) {
24853 zend_use_new_element_for_string();
24854 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24855 UNDEF_RESULT();
24856 } else {
24857 dim = RT_CONSTANT(opline, opline->op2);
24858 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24859 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24860 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24861 }
24862 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24863 if (Z_ISREF_P(orig_object_ptr)
24864 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24865 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24866 dim = RT_CONSTANT(opline, opline->op2);
24867 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24868 UNDEF_RESULT();
24869 } else {
24870 HashTable *ht = zend_new_array(8);
24871 uint8_t old_type = Z_TYPE_P(object_ptr);
24872
24873 ZVAL_ARR(object_ptr, ht);
24874 if (UNEXPECTED(old_type == IS_FALSE)) {
24875 GC_ADDREF(ht);
24876 zend_false_to_array_deprecated();
24877 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24878 zend_array_destroy(ht);
24879 goto assign_dim_error;
24880 }
24881 }
24882 goto try_assign_dim_array;
24883 }
24884 } else {
24885 zend_use_scalar_as_array();
24886 dim = RT_CONSTANT(opline, opline->op2);
24887 assign_dim_error:
24888 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24889 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24890 ZVAL_NULL(EX_VAR(opline->result.var));
24891 }
24892 }
24893 }
24894 if (IS_CONST != IS_UNUSED) {
24895
24896 }
24897 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24898 /* assign_dim has two opcodes! */
24899 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24900 }
24901
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24902 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24903 {
24904 USE_OPLINE
24905 zval *object_ptr, *orig_object_ptr;
24906 zval *value;
24907 zval *variable_ptr;
24908 zval *dim;
24909 zend_refcounted *garbage = NULL;
24910
24911 SAVE_OPLINE();
24912 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24913
24914 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24915 try_assign_dim_array:
24916 SEPARATE_ARRAY(object_ptr);
24917 if (IS_CONST == IS_UNUSED) {
24918 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24919 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24920 HashTable *ht = Z_ARRVAL_P(object_ptr);
24921 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24922 GC_ADDREF(ht);
24923 }
24924 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24925 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24926 zend_array_destroy(ht);
24927 goto assign_dim_error;
24928 }
24929 }
24930 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
24931 ZVAL_DEREF(value);
24932 }
24933 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24934 if (UNEXPECTED(value == NULL)) {
24935 zend_cannot_add_element();
24936 goto assign_dim_error;
24937 } else if (IS_VAR == IS_CV) {
24938 if (Z_REFCOUNTED_P(value)) {
24939 Z_ADDREF_P(value);
24940 }
24941 } else if (IS_VAR == IS_VAR) {
24942 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24943 if (Z_ISREF_P(free_op_data)) {
24944 if (Z_REFCOUNTED_P(value)) {
24945 Z_ADDREF_P(value);
24946 }
24947 zval_ptr_dtor_nogc(free_op_data);
24948 }
24949 } else if (IS_VAR == IS_CONST) {
24950 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24951 Z_ADDREF_P(value);
24952 }
24953 }
24954 } else {
24955 dim = RT_CONSTANT(opline, opline->op2);
24956 if (IS_CONST == IS_CONST) {
24957 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24958 } else {
24959 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24960 }
24961 if (UNEXPECTED(variable_ptr == NULL)) {
24962 goto assign_dim_error;
24963 }
24964 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24965 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
24966 }
24967 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24968 ZVAL_COPY(EX_VAR(opline->result.var), value);
24969 }
24970 if (garbage) {
24971 GC_DTOR_NO_REF(garbage);
24972 }
24973 } else {
24974 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24975 object_ptr = Z_REFVAL_P(object_ptr);
24976 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24977 goto try_assign_dim_array;
24978 }
24979 }
24980 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24981 zend_object *obj = Z_OBJ_P(object_ptr);
24982
24983 GC_ADDREF(obj);
24984 dim = RT_CONSTANT(opline, opline->op2);
24985 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24986 dim = ZVAL_UNDEFINED_OP2();
24987 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24988 dim++;
24989 }
24990
24991 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24992 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24993 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24994 } else if (IS_VAR & (IS_CV|IS_VAR)) {
24995 ZVAL_DEREF(value);
24996 }
24997
24998 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24999
25000 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25001 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
25002 zend_objects_store_del(obj);
25003 }
25004 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
25005 if (IS_CONST == IS_UNUSED) {
25006 zend_use_new_element_for_string();
25007 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25008 UNDEF_RESULT();
25009 } else {
25010 dim = RT_CONSTANT(opline, opline->op2);
25011 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25012 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
25013 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25014 }
25015 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
25016 if (Z_ISREF_P(orig_object_ptr)
25017 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
25018 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
25019 dim = RT_CONSTANT(opline, opline->op2);
25020 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25021 UNDEF_RESULT();
25022 } else {
25023 HashTable *ht = zend_new_array(8);
25024 uint8_t old_type = Z_TYPE_P(object_ptr);
25025
25026 ZVAL_ARR(object_ptr, ht);
25027 if (UNEXPECTED(old_type == IS_FALSE)) {
25028 GC_ADDREF(ht);
25029 zend_false_to_array_deprecated();
25030 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
25031 zend_array_destroy(ht);
25032 goto assign_dim_error;
25033 }
25034 }
25035 goto try_assign_dim_array;
25036 }
25037 } else {
25038 zend_use_scalar_as_array();
25039 dim = RT_CONSTANT(opline, opline->op2);
25040 assign_dim_error:
25041 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25042 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25043 ZVAL_NULL(EX_VAR(opline->result.var));
25044 }
25045 }
25046 }
25047 if (IS_CONST != IS_UNUSED) {
25048
25049 }
25050 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25051 /* assign_dim has two opcodes! */
25052 ZEND_VM_NEXT_OPCODE_EX(1, 2);
25053 }
25054
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25055 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25056 {
25057 USE_OPLINE
25058 zval *object_ptr, *orig_object_ptr;
25059 zval *value;
25060 zval *variable_ptr;
25061 zval *dim;
25062 zend_refcounted *garbage = NULL;
25063
25064 SAVE_OPLINE();
25065 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25066
25067 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25068 try_assign_dim_array:
25069 SEPARATE_ARRAY(object_ptr);
25070 if (IS_CONST == IS_UNUSED) {
25071 value = EX_VAR((opline+1)->op1.var);
25072 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
25073 HashTable *ht = Z_ARRVAL_P(object_ptr);
25074 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
25075 GC_ADDREF(ht);
25076 }
25077 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25078 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
25079 zend_array_destroy(ht);
25080 goto assign_dim_error;
25081 }
25082 }
25083 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
25084 ZVAL_DEREF(value);
25085 }
25086 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
25087 if (UNEXPECTED(value == NULL)) {
25088 zend_cannot_add_element();
25089 goto assign_dim_error;
25090 } else if (IS_CV == IS_CV) {
25091 if (Z_REFCOUNTED_P(value)) {
25092 Z_ADDREF_P(value);
25093 }
25094 } else if (IS_CV == IS_VAR) {
25095 zval *free_op_data = EX_VAR((opline+1)->op1.var);
25096 if (Z_ISREF_P(free_op_data)) {
25097 if (Z_REFCOUNTED_P(value)) {
25098 Z_ADDREF_P(value);
25099 }
25100 zval_ptr_dtor_nogc(free_op_data);
25101 }
25102 } else if (IS_CV == IS_CONST) {
25103 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
25104 Z_ADDREF_P(value);
25105 }
25106 }
25107 } else {
25108 dim = RT_CONSTANT(opline, opline->op2);
25109 if (IS_CONST == IS_CONST) {
25110 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25111 } else {
25112 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
25113 }
25114 if (UNEXPECTED(variable_ptr == NULL)) {
25115 goto assign_dim_error;
25116 }
25117 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
25118 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
25119 }
25120 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25121 ZVAL_COPY(EX_VAR(opline->result.var), value);
25122 }
25123 if (garbage) {
25124 GC_DTOR_NO_REF(garbage);
25125 }
25126 } else {
25127 if (EXPECTED(Z_ISREF_P(object_ptr))) {
25128 object_ptr = Z_REFVAL_P(object_ptr);
25129 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
25130 goto try_assign_dim_array;
25131 }
25132 }
25133 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
25134 zend_object *obj = Z_OBJ_P(object_ptr);
25135
25136 GC_ADDREF(obj);
25137 dim = RT_CONSTANT(opline, opline->op2);
25138 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
25139 dim = ZVAL_UNDEFINED_OP2();
25140 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
25141 dim++;
25142 }
25143
25144 value = EX_VAR((opline+1)->op1.var);
25145 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
25146 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
25147 } else if (IS_CV & (IS_CV|IS_VAR)) {
25148 ZVAL_DEREF(value);
25149 }
25150
25151 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
25152
25153 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
25154 zend_objects_store_del(obj);
25155 }
25156 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
25157 if (IS_CONST == IS_UNUSED) {
25158 zend_use_new_element_for_string();
25159
25160 UNDEF_RESULT();
25161 } else {
25162 dim = RT_CONSTANT(opline, opline->op2);
25163 value = EX_VAR((opline+1)->op1.var);
25164 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
25165
25166 }
25167 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
25168 if (Z_ISREF_P(orig_object_ptr)
25169 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
25170 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
25171 dim = RT_CONSTANT(opline, opline->op2);
25172
25173 UNDEF_RESULT();
25174 } else {
25175 HashTable *ht = zend_new_array(8);
25176 uint8_t old_type = Z_TYPE_P(object_ptr);
25177
25178 ZVAL_ARR(object_ptr, ht);
25179 if (UNEXPECTED(old_type == IS_FALSE)) {
25180 GC_ADDREF(ht);
25181 zend_false_to_array_deprecated();
25182 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
25183 zend_array_destroy(ht);
25184 goto assign_dim_error;
25185 }
25186 }
25187 goto try_assign_dim_array;
25188 }
25189 } else {
25190 zend_use_scalar_as_array();
25191 dim = RT_CONSTANT(opline, opline->op2);
25192 assign_dim_error:
25193
25194 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25195 ZVAL_NULL(EX_VAR(opline->result.var));
25196 }
25197 }
25198 }
25199 if (IS_CONST != IS_UNUSED) {
25200
25201 }
25202 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25203 /* assign_dim has two opcodes! */
25204 ZEND_VM_NEXT_OPCODE_EX(1, 2);
25205 }
25206
ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25207 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25208 {
25209 USE_OPLINE
25210 zval *value;
25211 zval *variable_ptr;
25212
25213 SAVE_OPLINE();
25214 value = RT_CONSTANT(opline, opline->op2);
25215 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25216
25217 if (0 || UNEXPECTED(0)) {
25218 zend_refcounted *garbage = NULL;
25219
25220 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
25221 if (UNEXPECTED(0)) {
25222 ZVAL_COPY(EX_VAR(opline->result.var), value);
25223 }
25224 if (garbage) {
25225 GC_DTOR_NO_REF(garbage);
25226 }
25227 } else {
25228 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
25229 }
25230 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25231 /* zend_assign_to_variable() always takes care of op2, never free it! */
25232
25233 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25234 }
25235
ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25236 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25237 {
25238 USE_OPLINE
25239 zval *value;
25240 zval *variable_ptr;
25241
25242 SAVE_OPLINE();
25243 value = RT_CONSTANT(opline, opline->op2);
25244 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25245
25246 if (0 || UNEXPECTED(1)) {
25247 zend_refcounted *garbage = NULL;
25248
25249 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
25250 if (UNEXPECTED(1)) {
25251 ZVAL_COPY(EX_VAR(opline->result.var), value);
25252 }
25253 if (garbage) {
25254 GC_DTOR_NO_REF(garbage);
25255 }
25256 } else {
25257 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
25258 }
25259 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25260 /* zend_assign_to_variable() always takes care of op2, never free it! */
25261
25262 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25263 }
25264
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25265 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25266 {
25267 USE_OPLINE
25268 zval *property, *container, *value_ptr;
25269
25270 SAVE_OPLINE();
25271
25272 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25273 property = RT_CONSTANT(opline, opline->op2);
25274
25275 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
25276
25277 if (1) {
25278 if (IS_VAR == IS_UNUSED) {
25279 if (IS_CONST == IS_CONST) {
25280 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25281 } else {
25282 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25283 }
25284 } else {
25285 if (IS_CONST == IS_CONST) {
25286 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25287 } else {
25288 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25289 }
25290 }
25291 } else {
25292 zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25293 }
25294
25295 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25296
25297 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
25298 ZEND_VM_NEXT_OPCODE_EX(1, 2);
25299 }
25300
25301 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25302 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25303 {
25304 USE_OPLINE
25305 zval *property, *container, *value_ptr;
25306
25307 SAVE_OPLINE();
25308
25309 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25310 property = RT_CONSTANT(opline, opline->op2);
25311
25312 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
25313
25314 if (1) {
25315 if (IS_VAR == IS_UNUSED) {
25316 if (IS_CONST == IS_CONST) {
25317 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25318 } else {
25319 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25320 }
25321 } else {
25322 if (IS_CONST == IS_CONST) {
25323 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25324 } else {
25325 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25326 }
25327 }
25328 } else {
25329 zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
25330 }
25331
25332 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25333
25334
25335 ZEND_VM_NEXT_OPCODE_EX(1, 2);
25336 }
25337
25338 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25339 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25340 {
25341 USE_OPLINE
25342 zval *function_name;
25343 zend_class_entry *ce;
25344 uint32_t call_info;
25345 zend_function *fbc;
25346 zend_execute_data *call;
25347
25348 SAVE_OPLINE();
25349
25350 if (IS_VAR == IS_CONST) {
25351 /* no function found. try a static method in class */
25352 ce = CACHED_PTR(opline->result.num);
25353 if (UNEXPECTED(ce == NULL)) {
25354 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);
25355 if (UNEXPECTED(ce == NULL)) {
25356
25357 HANDLE_EXCEPTION();
25358 }
25359 if (IS_CONST != IS_CONST) {
25360 CACHE_PTR(opline->result.num, ce);
25361 }
25362 }
25363 } else if (IS_VAR == IS_UNUSED) {
25364 ce = zend_fetch_class(NULL, opline->op1.num);
25365 if (UNEXPECTED(ce == NULL)) {
25366
25367 HANDLE_EXCEPTION();
25368 }
25369 } else {
25370 ce = Z_CE_P(EX_VAR(opline->op1.var));
25371 }
25372
25373 if (IS_VAR == IS_CONST &&
25374 IS_CONST == IS_CONST &&
25375 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
25376 /* nothing to do */
25377 } else if (IS_VAR != IS_CONST &&
25378 IS_CONST == IS_CONST &&
25379 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
25380 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
25381 } else if (IS_CONST != IS_UNUSED) {
25382 function_name = RT_CONSTANT(opline, opline->op2);
25383 if (IS_CONST != IS_CONST) {
25384 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
25385 do {
25386 if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
25387 function_name = Z_REFVAL_P(function_name);
25388 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
25389 break;
25390 }
25391 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
25392 ZVAL_UNDEFINED_OP2();
25393 if (UNEXPECTED(EG(exception) != NULL)) {
25394 HANDLE_EXCEPTION();
25395 }
25396 }
25397 zend_throw_error(NULL, "Method name must be a string");
25398
25399 HANDLE_EXCEPTION();
25400 } while (0);
25401 }
25402 }
25403
25404 if (ce->get_static_method) {
25405 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
25406 } else {
25407 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
25408 }
25409 if (UNEXPECTED(fbc == NULL)) {
25410 if (EXPECTED(!EG(exception))) {
25411 zend_undefined_method(ce, Z_STR_P(function_name));
25412 }
25413
25414 HANDLE_EXCEPTION();
25415 }
25416 if (IS_CONST == IS_CONST &&
25417 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
25418 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
25419 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
25420 }
25421 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
25422 init_func_run_time_cache(&fbc->op_array);
25423 }
25424 if (IS_CONST != IS_CONST) {
25425
25426 }
25427 } else {
25428 if (UNEXPECTED(ce->constructor == NULL)) {
25429 zend_throw_error(NULL, "Cannot call constructor");
25430 HANDLE_EXCEPTION();
25431 }
25432 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
25433 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
25434 HANDLE_EXCEPTION();
25435 }
25436 fbc = ce->constructor;
25437 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
25438 init_func_run_time_cache(&fbc->op_array);
25439 }
25440 }
25441
25442 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
25443 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
25444 ce = (zend_class_entry*)Z_OBJ(EX(This));
25445 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
25446 } else {
25447 zend_non_static_method_call(fbc);
25448 HANDLE_EXCEPTION();
25449 }
25450 } else {
25451 /* previous opcode is ZEND_FETCH_CLASS */
25452 if (IS_VAR == IS_UNUSED
25453 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
25454 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
25455 if (Z_TYPE(EX(This)) == IS_OBJECT) {
25456 ce = Z_OBJCE(EX(This));
25457 } else {
25458 ce = Z_CE(EX(This));
25459 }
25460 }
25461 call_info = ZEND_CALL_NESTED_FUNCTION;
25462 }
25463
25464 call = zend_vm_stack_push_call_frame(call_info,
25465 fbc, opline->extended_value, ce);
25466 call->prev_execute_data = EX(call);
25467 EX(call) = call;
25468
25469 ZEND_VM_NEXT_OPCODE();
25470 }
25471
ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25472 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25473 {
25474 USE_OPLINE
25475 zval *varptr, *arg;
25476
25477 if (IS_CONST == IS_CONST) {
25478 SAVE_OPLINE();
25479 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25480 uint32_t arg_num;
25481 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25482 if (UNEXPECTED(!arg)) {
25483 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25484 HANDLE_EXCEPTION();
25485 }
25486 } else {
25487 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25488 }
25489
25490 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25491 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
25492 SAVE_OPLINE();
25493 ZVAL_UNDEFINED_OP1();
25494 ZVAL_NULL(arg);
25495 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25496 }
25497
25498 if (IS_VAR == IS_CV) {
25499 ZVAL_COPY_DEREF(arg, varptr);
25500 } else /* if (IS_VAR == IS_VAR) */ {
25501 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25502 zend_refcounted *ref = Z_COUNTED_P(varptr);
25503
25504 varptr = Z_REFVAL_P(varptr);
25505 ZVAL_COPY_VALUE(arg, varptr);
25506 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25507 efree_size(ref, sizeof(zend_reference));
25508 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25509 Z_ADDREF_P(arg);
25510 }
25511 } else {
25512 ZVAL_COPY_VALUE(arg, varptr);
25513 }
25514 }
25515
25516 ZEND_VM_NEXT_OPCODE();
25517 }
25518
ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25519 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25520 {
25521 USE_OPLINE
25522 zval *varptr, *arg;
25523
25524 if (IS_CONST == IS_CONST) {
25525 SAVE_OPLINE();
25526 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25527 uint32_t arg_num;
25528 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25529 if (UNEXPECTED(!arg)) {
25530 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25531 HANDLE_EXCEPTION();
25532 }
25533 } else {
25534 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25535 }
25536
25537 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25538 ZVAL_COPY_VALUE(arg, varptr);
25539
25540 if (EXPECTED(Z_ISREF_P(varptr))) {
25541 ZEND_VM_NEXT_OPCODE();
25542 }
25543
25544 SAVE_OPLINE();
25545 ZVAL_NEW_REF(arg, arg);
25546 zend_error(E_NOTICE, "Only variables should be passed by reference");
25547 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25548 }
25549
ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25550 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25551 {
25552 USE_OPLINE
25553 zval *varptr, *arg;
25554 uint32_t arg_num;
25555
25556 if (IS_CONST == IS_CONST) {
25557 SAVE_OPLINE();
25558 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25559 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25560 if (UNEXPECTED(!arg)) {
25561 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25562 HANDLE_EXCEPTION();
25563 }
25564 } else {
25565 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25566 arg_num = opline->op2.num;
25567 }
25568
25569 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
25570 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25571 goto send_var;
25572 }
25573
25574 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25575 ZVAL_COPY_VALUE(arg, varptr);
25576
25577 if (EXPECTED(Z_ISREF_P(varptr) ||
25578 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
25579 ZEND_VM_NEXT_OPCODE();
25580 }
25581 } else {
25582 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25583 goto send_var;
25584 }
25585
25586 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25587 ZVAL_COPY_VALUE(arg, varptr);
25588
25589 if (EXPECTED(Z_ISREF_P(varptr) ||
25590 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
25591 ZEND_VM_NEXT_OPCODE();
25592 }
25593 }
25594
25595 SAVE_OPLINE();
25596 ZVAL_NEW_REF(arg, arg);
25597 zend_error(E_NOTICE, "Only variables should be passed by reference");
25598 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25599
25600 send_var:
25601 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25602 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25603 zend_refcounted *ref = Z_COUNTED_P(varptr);
25604
25605 varptr = Z_REFVAL_P(varptr);
25606 ZVAL_COPY_VALUE(arg, varptr);
25607 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25608 efree_size(ref, sizeof(zend_reference));
25609 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25610 Z_ADDREF_P(arg);
25611 }
25612 } else {
25613 ZVAL_COPY_VALUE(arg, varptr);
25614 }
25615 ZEND_VM_NEXT_OPCODE();
25616 }
25617
ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25618 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25619 {
25620 USE_OPLINE
25621 zval *varptr, *arg;
25622
25623 SAVE_OPLINE();
25624 if (IS_CONST == IS_CONST) {
25625 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25626 uint32_t arg_num;
25627 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25628 if (UNEXPECTED(!arg)) {
25629 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25630 HANDLE_EXCEPTION();
25631 }
25632 } else {
25633 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25634 }
25635
25636 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25637 if (Z_ISREF_P(varptr)) {
25638 Z_ADDREF_P(varptr);
25639 } else {
25640 ZVAL_MAKE_REF_EX(varptr, 2);
25641 }
25642 ZVAL_REF(arg, Z_REF_P(varptr));
25643
25644 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25645 ZEND_VM_NEXT_OPCODE();
25646 }
25647
ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25648 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25649 {
25650 USE_OPLINE
25651 zval *varptr, *arg;
25652 uint32_t arg_num;
25653
25654 if (IS_CONST == IS_CONST) {
25655 SAVE_OPLINE();
25656 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25657 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25658 if (UNEXPECTED(!arg)) {
25659 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25660 HANDLE_EXCEPTION();
25661 }
25662 } else {
25663 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25664 arg_num = opline->op2.num;
25665 }
25666
25667 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
25668 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25669 goto send_var_by_ref;
25670 }
25671 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25672 send_var_by_ref:
25673 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25674 if (Z_ISREF_P(varptr)) {
25675 Z_ADDREF_P(varptr);
25676 } else {
25677 ZVAL_MAKE_REF_EX(varptr, 2);
25678 }
25679 ZVAL_REF(arg, Z_REF_P(varptr));
25680
25681 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25682 ZEND_VM_NEXT_OPCODE();
25683 }
25684
25685 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25686 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
25687 SAVE_OPLINE();
25688 ZVAL_UNDEFINED_OP1();
25689 ZVAL_NULL(arg);
25690 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25691 }
25692
25693 if (IS_VAR == IS_CV) {
25694 ZVAL_COPY_DEREF(arg, varptr);
25695 } else /* if (IS_VAR == IS_VAR) */ {
25696 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25697 zend_refcounted *ref = Z_COUNTED_P(varptr);
25698
25699 varptr = Z_REFVAL_P(varptr);
25700 ZVAL_COPY_VALUE(arg, varptr);
25701 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25702 efree_size(ref, sizeof(zend_reference));
25703 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25704 Z_ADDREF_P(arg);
25705 }
25706 } else {
25707 ZVAL_COPY_VALUE(arg, varptr);
25708 }
25709 }
25710
25711 ZEND_VM_NEXT_OPCODE();
25712 }
25713
ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25714 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25715 {
25716 USE_OPLINE
25717 zval *varptr, *arg;
25718
25719 if (IS_CONST == IS_CONST) {
25720 // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
25721 SAVE_OPLINE();
25722 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25723 uint32_t arg_num;
25724 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25725 if (UNEXPECTED(!arg)) {
25726 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25727 HANDLE_EXCEPTION();
25728 }
25729 } else {
25730 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25731 }
25732
25733 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
25734 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25735 if (Z_ISREF_P(varptr)) {
25736 Z_ADDREF_P(varptr);
25737 } else {
25738 ZVAL_MAKE_REF_EX(varptr, 2);
25739 }
25740 ZVAL_REF(arg, Z_REF_P(varptr));
25741
25742 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25743 ZEND_VM_NEXT_OPCODE();
25744 }
25745
25746 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25747
25748 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25749 zend_refcounted *ref = Z_COUNTED_P(varptr);
25750
25751 varptr = Z_REFVAL_P(varptr);
25752 ZVAL_COPY_VALUE(arg, varptr);
25753 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25754 efree_size(ref, sizeof(zend_reference));
25755 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25756 Z_ADDREF_P(arg);
25757 }
25758 } else {
25759 ZVAL_COPY_VALUE(arg, varptr);
25760 }
25761
25762 ZEND_VM_NEXT_OPCODE();
25763 }
25764
ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25765 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25766 {
25767 zend_class_entry *ce, *scope;
25768 zend_class_constant *c;
25769 zval *value, *zv, *constant_zv;
25770 zend_string *constant_name;
25771 USE_OPLINE
25772
25773 SAVE_OPLINE();
25774
25775 do {
25776 if (IS_VAR == IS_CONST && IS_CONST == IS_CONST) {
25777 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
25778 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25779 break;
25780 }
25781 }
25782 if (IS_VAR == IS_CONST) {
25783 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
25784 ce = CACHED_PTR(opline->extended_value);
25785 } else {
25786 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);
25787 if (UNEXPECTED(ce == NULL)) {
25788 ZVAL_UNDEF(EX_VAR(opline->result.var));
25789
25790 HANDLE_EXCEPTION();
25791 }
25792 CACHE_PTR(opline->extended_value, ce);
25793 }
25794 } else if (IS_VAR == IS_UNUSED) {
25795 ce = zend_fetch_class(NULL, opline->op1.num);
25796 if (UNEXPECTED(ce == NULL)) {
25797 ZVAL_UNDEF(EX_VAR(opline->result.var));
25798
25799 HANDLE_EXCEPTION();
25800 }
25801 } else {
25802 ce = Z_CE_P(EX_VAR(opline->op1.var));
25803 }
25804 if (IS_VAR != IS_CONST
25805 && IS_CONST == IS_CONST
25806 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
25807 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25808 break;
25809 }
25810
25811 constant_zv = RT_CONSTANT(opline, opline->op2);
25812 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
25813 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
25814 ZVAL_UNDEF(EX_VAR(opline->result.var));
25815
25816 HANDLE_EXCEPTION();
25817 }
25818 constant_name = Z_STR_P(constant_zv);
25819 /* Magic 'class' for constant OP2 is caught at compile-time */
25820 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
25821 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
25822
25823 ZEND_VM_NEXT_OPCODE();
25824 }
25825 zv = IS_CONST == IS_CONST
25826 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
25827 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
25828
25829 if (EXPECTED(zv != NULL)) {
25830 c = Z_PTR_P(zv);
25831 scope = EX(func)->op_array.scope;
25832 if (!zend_verify_const_access(c, scope)) {
25833 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));
25834 ZVAL_UNDEF(EX_VAR(opline->result.var));
25835
25836 HANDLE_EXCEPTION();
25837 }
25838
25839 if (ce->ce_flags & ZEND_ACC_TRAIT) {
25840 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25841 ZVAL_UNDEF(EX_VAR(opline->result.var));
25842
25843 HANDLE_EXCEPTION();
25844 }
25845
25846 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
25847 if (UNEXPECTED(is_constant_deprecated)) {
25848 zend_deprecated_class_constant(c, constant_name);
25849
25850 if (EG(exception)) {
25851 ZVAL_UNDEF(EX_VAR(opline->result.var));
25852
25853 HANDLE_EXCEPTION();
25854 }
25855 }
25856
25857 value = &c->value;
25858 // Enums require loading of all class constants to build the backed enum table
25859 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)) {
25860 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
25861 ZVAL_UNDEF(EX_VAR(opline->result.var));
25862
25863 HANDLE_EXCEPTION();
25864 }
25865 }
25866 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
25867 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
25868 ZVAL_UNDEF(EX_VAR(opline->result.var));
25869
25870 HANDLE_EXCEPTION();
25871 }
25872 }
25873 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
25874 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
25875 }
25876 } else {
25877 zend_throw_error(NULL, "Undefined constant %s::%s",
25878 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25879 ZVAL_UNDEF(EX_VAR(opline->result.var));
25880
25881 HANDLE_EXCEPTION();
25882 }
25883 } while (0);
25884
25885 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
25886
25887 ZEND_VM_NEXT_OPCODE();
25888 }
25889
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25890 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25891 {
25892 USE_OPLINE
25893 zval *expr_ptr, new_expr;
25894
25895 SAVE_OPLINE();
25896 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
25897 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
25898 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25899 if (Z_ISREF_P(expr_ptr)) {
25900 Z_ADDREF_P(expr_ptr);
25901 } else {
25902 ZVAL_MAKE_REF_EX(expr_ptr, 2);
25903 }
25904 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25905 } else {
25906 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25907 if (IS_VAR == IS_TMP_VAR) {
25908 /* pass */
25909 } else if (IS_VAR == IS_CONST) {
25910 Z_TRY_ADDREF_P(expr_ptr);
25911 } else if (IS_VAR == IS_CV) {
25912 ZVAL_DEREF(expr_ptr);
25913 Z_TRY_ADDREF_P(expr_ptr);
25914 } else /* if (IS_VAR == IS_VAR) */ {
25915 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
25916 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
25917
25918 expr_ptr = Z_REFVAL_P(expr_ptr);
25919 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25920 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
25921 expr_ptr = &new_expr;
25922 efree_size(ref, sizeof(zend_reference));
25923 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
25924 Z_ADDREF_P(expr_ptr);
25925 }
25926 }
25927 }
25928 }
25929
25930 if (IS_CONST != IS_UNUSED) {
25931 zval *offset = RT_CONSTANT(opline, opline->op2);
25932 zend_string *str;
25933 zend_ulong hval;
25934
25935 add_again:
25936 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
25937 str = Z_STR_P(offset);
25938 if (IS_CONST != IS_CONST) {
25939 if (ZEND_HANDLE_NUMERIC(str, hval)) {
25940 goto num_index;
25941 }
25942 }
25943 str_index:
25944 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
25945 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
25946 hval = Z_LVAL_P(offset);
25947 num_index:
25948 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
25949 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
25950 offset = Z_REFVAL_P(offset);
25951 goto add_again;
25952 } else if (Z_TYPE_P(offset) == IS_NULL) {
25953 str = ZSTR_EMPTY_ALLOC();
25954 goto str_index;
25955 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
25956 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
25957 goto num_index;
25958 } else if (Z_TYPE_P(offset) == IS_FALSE) {
25959 hval = 0;
25960 goto num_index;
25961 } else if (Z_TYPE_P(offset) == IS_TRUE) {
25962 hval = 1;
25963 goto num_index;
25964 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
25965 zend_use_resource_as_offset(offset);
25966 hval = Z_RES_HANDLE_P(offset);
25967 goto num_index;
25968 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
25969 ZVAL_UNDEFINED_OP2();
25970 str = ZSTR_EMPTY_ALLOC();
25971 goto str_index;
25972 } else {
25973 zend_illegal_array_offset_access(offset);
25974 zval_ptr_dtor_nogc(expr_ptr);
25975 }
25976
25977 } else {
25978 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
25979 zend_cannot_add_element();
25980 zval_ptr_dtor_nogc(expr_ptr);
25981 }
25982 }
25983 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25984 }
25985
ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25986 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25987 {
25988 zval *array;
25989 uint32_t size;
25990 USE_OPLINE
25991
25992 array = EX_VAR(opline->result.var);
25993 if (IS_VAR != IS_UNUSED) {
25994 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
25995 ZVAL_ARR(array, zend_new_array(size));
25996 /* Explicitly initialize array as not-packed if flag is set */
25997 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
25998 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
25999 }
26000 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26001 } else {
26002 ZVAL_ARR(array, zend_new_array(0));
26003 ZEND_VM_NEXT_OPCODE();
26004 }
26005 }
26006
ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26007 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26008 {
26009 USE_OPLINE
26010 zval *container;
26011 zval *offset;
26012 zend_ulong hval;
26013 zend_string *key;
26014
26015 SAVE_OPLINE();
26016 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26017 offset = RT_CONSTANT(opline, opline->op2);
26018
26019 do {
26020 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26021 HashTable *ht;
26022
26023 unset_dim_array:
26024 SEPARATE_ARRAY(container);
26025 ht = Z_ARRVAL_P(container);
26026 offset_again:
26027 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
26028 key = Z_STR_P(offset);
26029 if (IS_CONST != IS_CONST) {
26030 if (ZEND_HANDLE_NUMERIC(key, hval)) {
26031 goto num_index_dim;
26032 }
26033 }
26034 str_index_dim:
26035 ZEND_ASSERT(ht != &EG(symbol_table));
26036 zend_hash_del(ht, key);
26037 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
26038 hval = Z_LVAL_P(offset);
26039 num_index_dim:
26040 zend_hash_index_del(ht, hval);
26041 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
26042 offset = Z_REFVAL_P(offset);
26043 goto offset_again;
26044 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
26045 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
26046 goto num_index_dim;
26047 } else if (Z_TYPE_P(offset) == IS_NULL) {
26048 key = ZSTR_EMPTY_ALLOC();
26049 goto str_index_dim;
26050 } else if (Z_TYPE_P(offset) == IS_FALSE) {
26051 hval = 0;
26052 goto num_index_dim;
26053 } else if (Z_TYPE_P(offset) == IS_TRUE) {
26054 hval = 1;
26055 goto num_index_dim;
26056 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
26057 zend_use_resource_as_offset(offset);
26058 hval = Z_RES_HANDLE_P(offset);
26059 goto num_index_dim;
26060 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
26061 ZVAL_UNDEFINED_OP2();
26062 key = ZSTR_EMPTY_ALLOC();
26063 goto str_index_dim;
26064 } else {
26065 zend_illegal_array_offset_unset(offset);
26066 }
26067 break;
26068 } else if (Z_ISREF_P(container)) {
26069 container = Z_REFVAL_P(container);
26070 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26071 goto unset_dim_array;
26072 }
26073 }
26074 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
26075 container = ZVAL_UNDEFINED_OP1();
26076 }
26077 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
26078 offset = ZVAL_UNDEFINED_OP2();
26079 }
26080 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
26081 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
26082 offset++;
26083 }
26084 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
26085 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
26086 zend_throw_error(NULL, "Cannot unset string offsets");
26087 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
26088 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
26089 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
26090 zend_false_to_array_deprecated();
26091 }
26092 } while (0);
26093
26094 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26095 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26096 }
26097
ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26098 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26099 {
26100 USE_OPLINE
26101 zval *container;
26102 zval *offset;
26103 zend_string *name, *tmp_name;
26104
26105 SAVE_OPLINE();
26106 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26107 offset = RT_CONSTANT(opline, opline->op2);
26108
26109 do {
26110 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
26111 if (Z_ISREF_P(container)) {
26112 container = Z_REFVAL_P(container);
26113 if (Z_TYPE_P(container) != IS_OBJECT) {
26114 if (IS_VAR == IS_CV
26115 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
26116 ZVAL_UNDEFINED_OP1();
26117 }
26118 break;
26119 }
26120 } else {
26121 break;
26122 }
26123 }
26124 if (IS_CONST == IS_CONST) {
26125 name = Z_STR_P(offset);
26126 } else {
26127 name = zval_try_get_tmp_string(offset, &tmp_name);
26128 if (UNEXPECTED(!name)) {
26129 break;
26130 }
26131 }
26132 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
26133 if (IS_CONST != IS_CONST) {
26134 zend_tmp_string_release(tmp_name);
26135 }
26136 } while (0);
26137
26138 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26139 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26140 }
26141
ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26142 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26143 {
26144 USE_OPLINE
26145
26146 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
26147
26148 SAVE_OPLINE();
26149 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
26150 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26151 }
26152
26153 /* Destroy the previously yielded value */
26154 zval_ptr_dtor(&generator->value);
26155
26156 /* Destroy the previously yielded key */
26157 zval_ptr_dtor(&generator->key);
26158
26159 /* Set the new yielded value */
26160 if (IS_VAR != IS_UNUSED) {
26161 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
26162 /* Constants and temporary variables aren't yieldable by reference,
26163 * but we still allow them with a notice. */
26164 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
26165 zval *value;
26166
26167 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
26168
26169 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26170 ZVAL_COPY_VALUE(&generator->value, value);
26171 if (IS_VAR == IS_CONST) {
26172 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
26173 Z_ADDREF(generator->value);
26174 }
26175 }
26176 } else {
26177 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26178
26179 /* If a function call result is yielded and the function did
26180 * not return by reference we throw a notice. */
26181 do {
26182 if (IS_VAR == IS_VAR) {
26183 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
26184 if (opline->extended_value == ZEND_RETURNS_FUNCTION
26185 && !Z_ISREF_P(value_ptr)) {
26186 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
26187 ZVAL_COPY(&generator->value, value_ptr);
26188 break;
26189 }
26190 }
26191 if (Z_ISREF_P(value_ptr)) {
26192 Z_ADDREF_P(value_ptr);
26193 } else {
26194 ZVAL_MAKE_REF_EX(value_ptr, 2);
26195 }
26196 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
26197 } while (0);
26198
26199 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26200 }
26201 } else {
26202 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26203
26204 /* Consts, temporary variables and references need copying */
26205 if (IS_VAR == IS_CONST) {
26206 ZVAL_COPY_VALUE(&generator->value, value);
26207 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
26208 Z_ADDREF(generator->value);
26209 }
26210 } else if (IS_VAR == IS_TMP_VAR) {
26211 ZVAL_COPY_VALUE(&generator->value, value);
26212 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
26213 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
26214 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26215 } else {
26216 ZVAL_COPY_VALUE(&generator->value, value);
26217 if (IS_VAR == IS_CV) {
26218 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
26219 }
26220 }
26221 }
26222 } else {
26223 /* If no value was specified yield null */
26224 ZVAL_NULL(&generator->value);
26225 }
26226
26227 /* Set the new yielded key */
26228 if (IS_CONST != IS_UNUSED) {
26229 zval *key = RT_CONSTANT(opline, opline->op2);
26230 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
26231 key = Z_REFVAL_P(key);
26232 }
26233 ZVAL_COPY(&generator->key, key);
26234
26235 if (Z_TYPE(generator->key) == IS_LONG
26236 && Z_LVAL(generator->key) > generator->largest_used_integer_key
26237 ) {
26238 generator->largest_used_integer_key = Z_LVAL(generator->key);
26239 }
26240 } else {
26241 /* If no key was specified we use auto-increment keys */
26242 generator->largest_used_integer_key++;
26243 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
26244 }
26245
26246 if (RETURN_VALUE_USED(opline)) {
26247 /* If the return value of yield is used set the send
26248 * target and initialize it to NULL */
26249 generator->send_target = EX_VAR(opline->result.var);
26250 ZVAL_NULL(generator->send_target);
26251 } else {
26252 generator->send_target = NULL;
26253 }
26254
26255 /* The GOTO VM uses a local opline variable. We need to set the opline
26256 * variable in execute_data so we don't resume at an old position. */
26257 SAVE_OPLINE();
26258
26259 ZEND_VM_RETURN();
26260 }
26261
ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26262 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26263 {
26264 USE_OPLINE
26265 zval *op1;
26266 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
26267 zval *result;
26268
26269 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26270 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26271 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_VAR == IS_CONST);
26272 if (IS_VAR & (IS_TMP_VAR|IS_VAR)) {
26273 zval_ptr_dtor_str(op1);
26274 }
26275 ZEND_VM_SMART_BRANCH(result, 0);
26276 }
26277
26278 if (opline->extended_value) {
26279 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
26280 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
26281 ZEND_VM_SMART_BRANCH(result, 0);
26282 }
26283 SAVE_OPLINE();
26284 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
26285 op1 = Z_REFVAL_P(op1);
26286 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26287 result = zend_hash_find(ht, Z_STR_P(op1));
26288 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26289 ZEND_VM_SMART_BRANCH(result, 0);
26290 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
26291 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
26292 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26293 ZEND_VM_SMART_BRANCH(result, 0);
26294 }
26295 } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
26296 ZVAL_UNDEFINED_OP1();
26297 }
26298 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
26299 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
26300 SAVE_OPLINE();
26301 ZVAL_UNDEFINED_OP1();
26302 if (UNEXPECTED(EG(exception) != NULL)) {
26303 HANDLE_EXCEPTION();
26304 }
26305 }
26306 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
26307 ZEND_VM_SMART_BRANCH(result, 0);
26308 } else {
26309 zend_string *key;
26310 zval key_tmp;
26311
26312 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
26313 op1 = Z_REFVAL_P(op1);
26314 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
26315 result = zend_hash_find(ht, Z_STR_P(op1));
26316 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26317 ZEND_VM_SMART_BRANCH(result, 0);
26318 }
26319 }
26320
26321 SAVE_OPLINE();
26322 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
26323 ZVAL_STR(&key_tmp, key);
26324 if (zend_compare(op1, &key_tmp) == 0) {
26325 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26326 ZEND_VM_SMART_BRANCH(1, 1);
26327 }
26328 } ZEND_HASH_FOREACH_END();
26329 }
26330 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26331 ZEND_VM_SMART_BRANCH(0, 1);
26332 }
26333
ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26334 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26335 {
26336 zend_class_entry *ce, *scope;
26337 zend_class_constant *c;
26338 zval *value, *zv, *constant_zv;
26339 zend_string *constant_name;
26340 USE_OPLINE
26341
26342 SAVE_OPLINE();
26343
26344 do {
26345 if (IS_VAR == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
26346 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
26347 value = CACHED_PTR(opline->extended_value + sizeof(void*));
26348 break;
26349 }
26350 }
26351 if (IS_VAR == IS_CONST) {
26352 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
26353 ce = CACHED_PTR(opline->extended_value);
26354 } else {
26355 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);
26356 if (UNEXPECTED(ce == NULL)) {
26357 ZVAL_UNDEF(EX_VAR(opline->result.var));
26358 FREE_OP(opline->op2_type, opline->op2.var);
26359 HANDLE_EXCEPTION();
26360 }
26361 CACHE_PTR(opline->extended_value, ce);
26362 }
26363 } else if (IS_VAR == IS_UNUSED) {
26364 ce = zend_fetch_class(NULL, opline->op1.num);
26365 if (UNEXPECTED(ce == NULL)) {
26366 ZVAL_UNDEF(EX_VAR(opline->result.var));
26367 FREE_OP(opline->op2_type, opline->op2.var);
26368 HANDLE_EXCEPTION();
26369 }
26370 } else {
26371 ce = Z_CE_P(EX_VAR(opline->op1.var));
26372 }
26373 if (IS_VAR != IS_CONST
26374 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
26375 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
26376 value = CACHED_PTR(opline->extended_value + sizeof(void*));
26377 break;
26378 }
26379
26380 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
26381 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
26382 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
26383 ZVAL_UNDEF(EX_VAR(opline->result.var));
26384 FREE_OP(opline->op2_type, opline->op2.var);
26385 HANDLE_EXCEPTION();
26386 }
26387 constant_name = Z_STR_P(constant_zv);
26388 /* Magic 'class' for constant OP2 is caught at compile-time */
26389 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
26390 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
26391 FREE_OP(opline->op2_type, opline->op2.var);
26392 ZEND_VM_NEXT_OPCODE();
26393 }
26394 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
26395 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
26396 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
26397
26398 if (EXPECTED(zv != NULL)) {
26399 c = Z_PTR_P(zv);
26400 scope = EX(func)->op_array.scope;
26401 if (!zend_verify_const_access(c, scope)) {
26402 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));
26403 ZVAL_UNDEF(EX_VAR(opline->result.var));
26404 FREE_OP(opline->op2_type, opline->op2.var);
26405 HANDLE_EXCEPTION();
26406 }
26407
26408 if (ce->ce_flags & ZEND_ACC_TRAIT) {
26409 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
26410 ZVAL_UNDEF(EX_VAR(opline->result.var));
26411 FREE_OP(opline->op2_type, opline->op2.var);
26412 HANDLE_EXCEPTION();
26413 }
26414
26415 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
26416 if (UNEXPECTED(is_constant_deprecated)) {
26417 zend_deprecated_class_constant(c, constant_name);
26418
26419 if (EG(exception)) {
26420 ZVAL_UNDEF(EX_VAR(opline->result.var));
26421 FREE_OP(opline->op2_type, opline->op2.var);
26422 HANDLE_EXCEPTION();
26423 }
26424 }
26425
26426 value = &c->value;
26427 // Enums require loading of all class constants to build the backed enum table
26428 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)) {
26429 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
26430 ZVAL_UNDEF(EX_VAR(opline->result.var));
26431 FREE_OP(opline->op2_type, opline->op2.var);
26432 HANDLE_EXCEPTION();
26433 }
26434 }
26435 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
26436 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
26437 ZVAL_UNDEF(EX_VAR(opline->result.var));
26438 FREE_OP(opline->op2_type, opline->op2.var);
26439 HANDLE_EXCEPTION();
26440 }
26441 }
26442 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
26443 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
26444 }
26445 } else {
26446 zend_throw_error(NULL, "Undefined constant %s::%s",
26447 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
26448 ZVAL_UNDEF(EX_VAR(opline->result.var));
26449 FREE_OP(opline->op2_type, opline->op2.var);
26450 HANDLE_EXCEPTION();
26451 }
26452 } while (0);
26453
26454 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
26455
26456 FREE_OP(opline->op2_type, opline->op2.var);
26457 ZEND_VM_NEXT_OPCODE();
26458 }
26459
ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26460 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26461 {
26462 USE_OPLINE
26463 zval *object;
26464 zval *property;
26465 zval *value;
26466 zval *zptr;
26467 void *_cache_slot[3] = {0};
26468 void **cache_slot;
26469 zend_property_info *prop_info;
26470 zend_object *zobj;
26471 zend_string *name, *tmp_name;
26472
26473 SAVE_OPLINE();
26474 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26475 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26476
26477 do {
26478 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
26479
26480 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26481 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26482 object = Z_REFVAL_P(object);
26483 goto assign_op_object;
26484 }
26485 if (IS_VAR == IS_CV
26486 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26487 ZVAL_UNDEFINED_OP1();
26488 }
26489 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26490 break;
26491 }
26492
26493 assign_op_object:
26494 /* here we are sure we are dealing with an object */
26495 zobj = Z_OBJ_P(object);
26496 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26497 name = Z_STR_P(property);
26498 } else {
26499 name = zval_try_get_tmp_string(property, &tmp_name);
26500 if (UNEXPECTED(!name)) {
26501 UNDEF_RESULT();
26502 break;
26503 }
26504 }
26505 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
26506 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26507 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26508 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26509 ZVAL_NULL(EX_VAR(opline->result.var));
26510 }
26511 } else {
26512 zend_reference *ref;
26513
26514 do {
26515 if (UNEXPECTED(Z_ISREF_P(zptr))) {
26516 ref = Z_REF_P(zptr);
26517 zptr = Z_REFVAL_P(zptr);
26518 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26519 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26520 break;
26521 }
26522 }
26523
26524 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
26525 if (prop_info) {
26526 /* special case for typed properties */
26527 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
26528 } else {
26529 zend_binary_op(zptr, zptr, value OPLINE_CC);
26530 }
26531 } while (0);
26532
26533 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26534 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
26535 }
26536 }
26537 } else {
26538 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
26539 }
26540 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26541 zend_tmp_string_release(tmp_name);
26542 }
26543 } while (0);
26544
26545 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26546 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26547 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26548 /* assign_obj has two opcodes! */
26549 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26550 }
26551
26552 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26553 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26554 {
26555 USE_OPLINE
26556 zval *var_ptr;
26557 zval *value, *container, *dim;
26558 HashTable *ht;
26559
26560 SAVE_OPLINE();
26561 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26562
26563 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26564 assign_dim_op_array:
26565 SEPARATE_ARRAY(container);
26566 ht = Z_ARRVAL_P(container);
26567 assign_dim_op_new_array:
26568 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26569 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
26570 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
26571 if (UNEXPECTED(!var_ptr)) {
26572 zend_cannot_add_element();
26573 goto assign_dim_op_ret_null;
26574 }
26575 } else {
26576 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26577 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
26578 } else {
26579 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
26580 }
26581 if (UNEXPECTED(!var_ptr)) {
26582 goto assign_dim_op_ret_null;
26583 }
26584 }
26585
26586 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
26587
26588 do {
26589 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
26590 zend_reference *ref = Z_REF_P(var_ptr);
26591 var_ptr = Z_REFVAL_P(var_ptr);
26592 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26593 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26594 break;
26595 }
26596 }
26597 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26598 } while (0);
26599
26600 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26601 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26602 }
26603 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26604 } else {
26605 if (EXPECTED(Z_ISREF_P(container))) {
26606 container = Z_REFVAL_P(container);
26607 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26608 goto assign_dim_op_array;
26609 }
26610 }
26611
26612 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
26613 zend_object *obj = Z_OBJ_P(container);
26614
26615 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26616 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
26617 dim++;
26618 }
26619 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
26620 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
26621 uint8_t old_type;
26622
26623 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
26624 ZVAL_UNDEFINED_OP1();
26625 }
26626 ht = zend_new_array(8);
26627 old_type = Z_TYPE_P(container);
26628 ZVAL_ARR(container, ht);
26629 if (UNEXPECTED(old_type == IS_FALSE)) {
26630 GC_ADDREF(ht);
26631 zend_false_to_array_deprecated();
26632 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
26633 zend_array_destroy(ht);
26634 goto assign_dim_op_ret_null;
26635 }
26636 }
26637 goto assign_dim_op_new_array;
26638 } else {
26639 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26640 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
26641 assign_dim_op_ret_null:
26642 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26643 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26644 ZVAL_NULL(EX_VAR(opline->result.var));
26645 }
26646 }
26647 }
26648
26649 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26650 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26651 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26652 }
26653
ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26654 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26655 {
26656 USE_OPLINE
26657 zval *var_ptr;
26658 zval *value;
26659
26660 SAVE_OPLINE();
26661 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26662 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26663
26664 do {
26665 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
26666 zend_reference *ref = Z_REF_P(var_ptr);
26667 var_ptr = Z_REFVAL_P(var_ptr);
26668 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26669 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26670 break;
26671 }
26672 }
26673 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26674 } while (0);
26675
26676 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26677 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26678 }
26679
26680 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26681 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26682 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26683 }
26684
ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26685 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26686 {
26687 USE_OPLINE
26688 zval *object;
26689 zval *property;
26690 zval *zptr;
26691 void *_cache_slot[3] = {0};
26692 void **cache_slot;
26693 zend_property_info *prop_info;
26694 zend_object *zobj;
26695 zend_string *name, *tmp_name;
26696
26697 SAVE_OPLINE();
26698 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26699 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26700
26701 do {
26702 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26703 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26704 object = Z_REFVAL_P(object);
26705 goto pre_incdec_object;
26706 }
26707 if (IS_VAR == IS_CV
26708 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26709 ZVAL_UNDEFINED_OP1();
26710 }
26711 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26712 break;
26713 }
26714
26715 pre_incdec_object:
26716 /* here we are sure we are dealing with an object */
26717 zobj = Z_OBJ_P(object);
26718 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26719 name = Z_STR_P(property);
26720 } else {
26721 name = zval_try_get_tmp_string(property, &tmp_name);
26722 if (UNEXPECTED(!name)) {
26723 UNDEF_RESULT();
26724 break;
26725 }
26726 }
26727 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
26728 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26729 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26730 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26731 ZVAL_NULL(EX_VAR(opline->result.var));
26732 }
26733 } else {
26734 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
26735 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26736 }
26737 } else {
26738 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26739 }
26740 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26741 zend_tmp_string_release(tmp_name);
26742 }
26743 } while (0);
26744
26745 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26746 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26747 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26748 }
26749
ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26750 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26751 {
26752 USE_OPLINE
26753 zval *object;
26754 zval *property;
26755 zval *zptr;
26756 void *_cache_slot[3] = {0};
26757 void **cache_slot;
26758 zend_property_info *prop_info;
26759 zend_object *zobj;
26760 zend_string *name, *tmp_name;
26761
26762 SAVE_OPLINE();
26763 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26764 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26765
26766 do {
26767 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26768 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26769 object = Z_REFVAL_P(object);
26770 goto post_incdec_object;
26771 }
26772 if (IS_VAR == IS_CV
26773 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26774 ZVAL_UNDEFINED_OP1();
26775 }
26776 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26777 break;
26778 }
26779
26780 post_incdec_object:
26781 /* here we are sure we are dealing with an object */
26782 zobj = Z_OBJ_P(object);
26783 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26784 name = Z_STR_P(property);
26785 } else {
26786 name = zval_try_get_tmp_string(property, &tmp_name);
26787 if (UNEXPECTED(!name)) {
26788 ZVAL_UNDEF(EX_VAR(opline->result.var));
26789 break;
26790 }
26791 }
26792 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
26793 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26794 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26795 ZVAL_NULL(EX_VAR(opline->result.var));
26796 } else {
26797 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
26798 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26799 }
26800 } else {
26801 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26802 }
26803 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26804 zend_tmp_string_release(tmp_name);
26805 }
26806 } while (0);
26807
26808 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26809 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26810 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26811 }
26812
ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26813 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26814 {
26815 USE_OPLINE
26816 zval *container;
26817
26818 SAVE_OPLINE();
26819 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26820 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);
26821 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26822 if (IS_VAR == IS_VAR) {
26823 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26824 }
26825 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26826 }
26827
ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26828 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26829 {
26830 USE_OPLINE
26831 zval *container;
26832
26833 SAVE_OPLINE();
26834 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26835 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);
26836 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26837 if (IS_VAR == IS_VAR) {
26838 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26839 }
26840 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26841 }
26842
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26843 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26844 {
26845 #if 0
26846 USE_OPLINE
26847 #endif
26848
26849 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
26850 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
26851 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26852 }
26853 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26854 } else {
26855 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
26856 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26857 }
26858 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26859 }
26860 }
26861
ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26862 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26863 {
26864 USE_OPLINE
26865 zval *container;
26866
26867 SAVE_OPLINE();
26868 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26869 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);
26870 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26871 if (IS_VAR == IS_VAR) {
26872 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26873 }
26874 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26875 }
26876
ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26877 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26878 {
26879 USE_OPLINE
26880 zval *property, *container, *result;
26881
26882 SAVE_OPLINE();
26883
26884 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26885 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26886 result = EX_VAR(opline->result.var);
26887 zend_fetch_property_address(
26888 result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR),
26889 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
26890 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
26891 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26892 if (IS_VAR == IS_VAR) {
26893 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26894 }
26895 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26896 }
26897
ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26898 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26899 {
26900 USE_OPLINE
26901 zval *property, *container, *result;
26902
26903 SAVE_OPLINE();
26904 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26905 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26906 result = EX_VAR(opline->result.var);
26907 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);
26908 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26909 if (IS_VAR == IS_VAR) {
26910 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26911 }
26912 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26913 }
26914
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26915 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26916 {
26917 #if 0
26918 USE_OPLINE
26919 #endif
26920
26921 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
26922 /* Behave like FETCH_OBJ_W */
26923 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
26924 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26925 }
26926 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26927 } else {
26928 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26929 }
26930 }
26931
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26932 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26933 {
26934 USE_OPLINE
26935 zval *container, *property, *result;
26936
26937 SAVE_OPLINE();
26938 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26939 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26940 result = EX_VAR(opline->result.var);
26941 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);
26942 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26943 if (IS_VAR == IS_VAR) {
26944 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26945 }
26946 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26947 }
26948
ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26949 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26950 {
26951 USE_OPLINE
26952 zval *container, *dim;
26953
26954 SAVE_OPLINE();
26955 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26956 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26957
26958 if (IS_VAR == IS_VAR
26959 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
26960 && UNEXPECTED(!Z_ISREF_P(container))
26961 ) {
26962 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
26963 zend_fetch_dimension_address_LIST_r(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
26964 } else {
26965 zend_fetch_dimension_address_W(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
26966 }
26967
26968 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26969 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26970 }
26971
ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26972 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26973 {
26974 USE_OPLINE
26975 zval *object, *value, tmp;
26976 zend_object *zobj;
26977 zend_string *name, *tmp_name;
26978 zend_refcounted *garbage = NULL;
26979
26980 SAVE_OPLINE();
26981 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26982 value = RT_CONSTANT((opline+1), (opline+1)->op1);
26983
26984 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26985 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26986 object = Z_REFVAL_P(object);
26987 goto assign_object;
26988 }
26989 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
26990 value = &EG(uninitialized_zval);
26991 goto free_and_exit_assign_obj;
26992 }
26993
26994 assign_object:
26995 zobj = Z_OBJ_P(object);
26996 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26997 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
26998 void **cache_slot = CACHE_ADDR(opline->extended_value);
26999 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27000 zval *property_val;
27001
27002 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27003 property_val = OBJ_PROP(zobj, prop_offset);
27004 if (Z_TYPE_P(property_val) != IS_UNDEF) {
27005 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27006
27007 if (prop_info != NULL) {
27008 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27009 goto free_and_exit_assign_obj;
27010 } else {
27011 fast_assign_obj:
27012 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
27013 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27014 ZVAL_COPY(EX_VAR(opline->result.var), value);
27015 }
27016 goto exit_assign_obj;
27017 }
27018 }
27019 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27020 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27021 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27022 zobj = zend_lazy_object_init(zobj);
27023 if (!zobj) {
27024 value = &EG(uninitialized_zval);
27025 goto free_and_exit_assign_obj;
27026 }
27027 }
27028 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27029 rebuild_object_properties_internal(zobj);
27030 }
27031 if (EXPECTED(zobj->properties != NULL)) {
27032 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27033 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27034 GC_DELREF(zobj->properties);
27035 }
27036 zobj->properties = zend_array_dup(zobj->properties);
27037 }
27038 property_val = zend_hash_find_known_hash(zobj->properties, name);
27039 if (property_val) {
27040 goto fast_assign_obj;
27041 }
27042 }
27043
27044 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27045 if (IS_CONST == IS_CONST) {
27046 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27047 Z_ADDREF_P(value);
27048 }
27049 } else if (IS_CONST != IS_TMP_VAR) {
27050 if (Z_ISREF_P(value)) {
27051 if (IS_CONST == IS_VAR) {
27052 zend_reference *ref = Z_REF_P(value);
27053 if (GC_DELREF(ref) == 0) {
27054 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27055 efree_size(ref, sizeof(zend_reference));
27056 value = &tmp;
27057 } else {
27058 value = Z_REFVAL_P(value);
27059 Z_TRY_ADDREF_P(value);
27060 }
27061 } else {
27062 value = Z_REFVAL_P(value);
27063 Z_TRY_ADDREF_P(value);
27064 }
27065 } else if (IS_CONST == IS_CV) {
27066 Z_TRY_ADDREF_P(value);
27067 }
27068 }
27069 zend_hash_add_new(zobj->properties, name, value);
27070 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27071 ZVAL_COPY(EX_VAR(opline->result.var), value);
27072 }
27073 goto exit_assign_obj;
27074 }
27075 } else {
27076 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27077 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27078 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
27079 property_val = OBJ_PROP(zobj, prop_info->offset);
27080 if (ZEND_TYPE_IS_SET(prop_info->type)) {
27081 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27082 goto free_and_exit_assign_obj;
27083 } else {
27084 goto fast_assign_obj;
27085 }
27086 }
27087 /* Fall through to write_property for hooks. */
27088 }
27089 }
27090 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27091 } else {
27092 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27093 if (UNEXPECTED(!name)) {
27094
27095 UNDEF_RESULT();
27096 goto exit_assign_obj;
27097 }
27098 }
27099
27100 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
27101 ZVAL_DEREF(value);
27102 }
27103
27104 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27105
27106 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27107 zend_tmp_string_release(tmp_name);
27108 }
27109
27110 free_and_exit_assign_obj:
27111 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27112 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27113 }
27114
27115 exit_assign_obj:
27116 if (garbage) {
27117 GC_DTOR_NO_REF(garbage);
27118 }
27119 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27120 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27121 /* assign_obj has two opcodes! */
27122 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27123 }
27124
27125 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27126 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27127 {
27128 USE_OPLINE
27129 zval *object, *value, tmp;
27130 zend_object *zobj;
27131 zend_string *name, *tmp_name;
27132 zend_refcounted *garbage = NULL;
27133
27134 SAVE_OPLINE();
27135 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27136 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27137
27138 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27139 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27140 object = Z_REFVAL_P(object);
27141 goto assign_object;
27142 }
27143 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27144 value = &EG(uninitialized_zval);
27145 goto free_and_exit_assign_obj;
27146 }
27147
27148 assign_object:
27149 zobj = Z_OBJ_P(object);
27150 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27151 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27152 void **cache_slot = CACHE_ADDR(opline->extended_value);
27153 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27154 zval *property_val;
27155
27156 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27157 property_val = OBJ_PROP(zobj, prop_offset);
27158 if (Z_TYPE_P(property_val) != IS_UNDEF) {
27159 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27160
27161 if (prop_info != NULL) {
27162 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27163 goto free_and_exit_assign_obj;
27164 } else {
27165 fast_assign_obj:
27166 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
27167 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27168 ZVAL_COPY(EX_VAR(opline->result.var), value);
27169 }
27170 goto exit_assign_obj;
27171 }
27172 }
27173 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27174 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27175 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27176 zobj = zend_lazy_object_init(zobj);
27177 if (!zobj) {
27178 value = &EG(uninitialized_zval);
27179 goto free_and_exit_assign_obj;
27180 }
27181 }
27182 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27183 rebuild_object_properties_internal(zobj);
27184 }
27185 if (EXPECTED(zobj->properties != NULL)) {
27186 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27187 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27188 GC_DELREF(zobj->properties);
27189 }
27190 zobj->properties = zend_array_dup(zobj->properties);
27191 }
27192 property_val = zend_hash_find_known_hash(zobj->properties, name);
27193 if (property_val) {
27194 goto fast_assign_obj;
27195 }
27196 }
27197
27198 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27199 if (IS_TMP_VAR == IS_CONST) {
27200 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27201 Z_ADDREF_P(value);
27202 }
27203 } else if (IS_TMP_VAR != IS_TMP_VAR) {
27204 if (Z_ISREF_P(value)) {
27205 if (IS_TMP_VAR == IS_VAR) {
27206 zend_reference *ref = Z_REF_P(value);
27207 if (GC_DELREF(ref) == 0) {
27208 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27209 efree_size(ref, sizeof(zend_reference));
27210 value = &tmp;
27211 } else {
27212 value = Z_REFVAL_P(value);
27213 Z_TRY_ADDREF_P(value);
27214 }
27215 } else {
27216 value = Z_REFVAL_P(value);
27217 Z_TRY_ADDREF_P(value);
27218 }
27219 } else if (IS_TMP_VAR == IS_CV) {
27220 Z_TRY_ADDREF_P(value);
27221 }
27222 }
27223 zend_hash_add_new(zobj->properties, name, value);
27224 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27225 ZVAL_COPY(EX_VAR(opline->result.var), value);
27226 }
27227 goto exit_assign_obj;
27228 }
27229 } else {
27230 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27231 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27232 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
27233 property_val = OBJ_PROP(zobj, prop_info->offset);
27234 if (ZEND_TYPE_IS_SET(prop_info->type)) {
27235 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27236 goto free_and_exit_assign_obj;
27237 } else {
27238 goto fast_assign_obj;
27239 }
27240 }
27241 /* Fall through to write_property for hooks. */
27242 }
27243 }
27244 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27245 } else {
27246 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27247 if (UNEXPECTED(!name)) {
27248 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27249 UNDEF_RESULT();
27250 goto exit_assign_obj;
27251 }
27252 }
27253
27254 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27255 ZVAL_DEREF(value);
27256 }
27257
27258 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27259
27260 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27261 zend_tmp_string_release(tmp_name);
27262 }
27263
27264 free_and_exit_assign_obj:
27265 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27266 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27267 }
27268 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27269 exit_assign_obj:
27270 if (garbage) {
27271 GC_DTOR_NO_REF(garbage);
27272 }
27273 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27274 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27275 /* assign_obj has two opcodes! */
27276 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27277 }
27278
27279 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27280 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27281 {
27282 USE_OPLINE
27283 zval *object, *value, tmp;
27284 zend_object *zobj;
27285 zend_string *name, *tmp_name;
27286 zend_refcounted *garbage = NULL;
27287
27288 SAVE_OPLINE();
27289 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27290 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27291
27292 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27293 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27294 object = Z_REFVAL_P(object);
27295 goto assign_object;
27296 }
27297 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27298 value = &EG(uninitialized_zval);
27299 goto free_and_exit_assign_obj;
27300 }
27301
27302 assign_object:
27303 zobj = Z_OBJ_P(object);
27304 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27305 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27306 void **cache_slot = CACHE_ADDR(opline->extended_value);
27307 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27308 zval *property_val;
27309
27310 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27311 property_val = OBJ_PROP(zobj, prop_offset);
27312 if (Z_TYPE_P(property_val) != IS_UNDEF) {
27313 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27314
27315 if (prop_info != NULL) {
27316 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27317 goto free_and_exit_assign_obj;
27318 } else {
27319 fast_assign_obj:
27320 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
27321 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27322 ZVAL_COPY(EX_VAR(opline->result.var), value);
27323 }
27324 goto exit_assign_obj;
27325 }
27326 }
27327 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27328 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27329 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27330 zobj = zend_lazy_object_init(zobj);
27331 if (!zobj) {
27332 value = &EG(uninitialized_zval);
27333 goto free_and_exit_assign_obj;
27334 }
27335 }
27336 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27337 rebuild_object_properties_internal(zobj);
27338 }
27339 if (EXPECTED(zobj->properties != NULL)) {
27340 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27341 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27342 GC_DELREF(zobj->properties);
27343 }
27344 zobj->properties = zend_array_dup(zobj->properties);
27345 }
27346 property_val = zend_hash_find_known_hash(zobj->properties, name);
27347 if (property_val) {
27348 goto fast_assign_obj;
27349 }
27350 }
27351
27352 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27353 if (IS_VAR == IS_CONST) {
27354 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27355 Z_ADDREF_P(value);
27356 }
27357 } else if (IS_VAR != IS_TMP_VAR) {
27358 if (Z_ISREF_P(value)) {
27359 if (IS_VAR == IS_VAR) {
27360 zend_reference *ref = Z_REF_P(value);
27361 if (GC_DELREF(ref) == 0) {
27362 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27363 efree_size(ref, sizeof(zend_reference));
27364 value = &tmp;
27365 } else {
27366 value = Z_REFVAL_P(value);
27367 Z_TRY_ADDREF_P(value);
27368 }
27369 } else {
27370 value = Z_REFVAL_P(value);
27371 Z_TRY_ADDREF_P(value);
27372 }
27373 } else if (IS_VAR == IS_CV) {
27374 Z_TRY_ADDREF_P(value);
27375 }
27376 }
27377 zend_hash_add_new(zobj->properties, name, value);
27378 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27379 ZVAL_COPY(EX_VAR(opline->result.var), value);
27380 }
27381 goto exit_assign_obj;
27382 }
27383 } else {
27384 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27385 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27386 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
27387 property_val = OBJ_PROP(zobj, prop_info->offset);
27388 if (ZEND_TYPE_IS_SET(prop_info->type)) {
27389 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27390 goto free_and_exit_assign_obj;
27391 } else {
27392 goto fast_assign_obj;
27393 }
27394 }
27395 /* Fall through to write_property for hooks. */
27396 }
27397 }
27398 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27399 } else {
27400 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27401 if (UNEXPECTED(!name)) {
27402 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27403 UNDEF_RESULT();
27404 goto exit_assign_obj;
27405 }
27406 }
27407
27408 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
27409 ZVAL_DEREF(value);
27410 }
27411
27412 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27413
27414 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27415 zend_tmp_string_release(tmp_name);
27416 }
27417
27418 free_and_exit_assign_obj:
27419 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27420 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27421 }
27422 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27423 exit_assign_obj:
27424 if (garbage) {
27425 GC_DTOR_NO_REF(garbage);
27426 }
27427 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27428 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27429 /* assign_obj has two opcodes! */
27430 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27431 }
27432
27433 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27434 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27435 {
27436 USE_OPLINE
27437 zval *object, *value, tmp;
27438 zend_object *zobj;
27439 zend_string *name, *tmp_name;
27440 zend_refcounted *garbage = NULL;
27441
27442 SAVE_OPLINE();
27443 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27444 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
27445
27446 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
27447 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
27448 object = Z_REFVAL_P(object);
27449 goto assign_object;
27450 }
27451 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
27452 value = &EG(uninitialized_zval);
27453 goto free_and_exit_assign_obj;
27454 }
27455
27456 assign_object:
27457 zobj = Z_OBJ_P(object);
27458 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27459 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
27460 void **cache_slot = CACHE_ADDR(opline->extended_value);
27461 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
27462 zval *property_val;
27463
27464 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
27465 property_val = OBJ_PROP(zobj, prop_offset);
27466 if (Z_TYPE_P(property_val) != IS_UNDEF) {
27467 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
27468
27469 if (prop_info != NULL) {
27470 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27471 goto free_and_exit_assign_obj;
27472 } else {
27473 fast_assign_obj:
27474 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
27475 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27476 ZVAL_COPY(EX_VAR(opline->result.var), value);
27477 }
27478 goto exit_assign_obj;
27479 }
27480 }
27481 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
27482 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27483 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
27484 zobj = zend_lazy_object_init(zobj);
27485 if (!zobj) {
27486 value = &EG(uninitialized_zval);
27487 goto free_and_exit_assign_obj;
27488 }
27489 }
27490 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27491 rebuild_object_properties_internal(zobj);
27492 }
27493 if (EXPECTED(zobj->properties != NULL)) {
27494 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
27495 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
27496 GC_DELREF(zobj->properties);
27497 }
27498 zobj->properties = zend_array_dup(zobj->properties);
27499 }
27500 property_val = zend_hash_find_known_hash(zobj->properties, name);
27501 if (property_val) {
27502 goto fast_assign_obj;
27503 }
27504 }
27505
27506 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
27507 if (IS_CV == IS_CONST) {
27508 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
27509 Z_ADDREF_P(value);
27510 }
27511 } else if (IS_CV != IS_TMP_VAR) {
27512 if (Z_ISREF_P(value)) {
27513 if (IS_CV == IS_VAR) {
27514 zend_reference *ref = Z_REF_P(value);
27515 if (GC_DELREF(ref) == 0) {
27516 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
27517 efree_size(ref, sizeof(zend_reference));
27518 value = &tmp;
27519 } else {
27520 value = Z_REFVAL_P(value);
27521 Z_TRY_ADDREF_P(value);
27522 }
27523 } else {
27524 value = Z_REFVAL_P(value);
27525 Z_TRY_ADDREF_P(value);
27526 }
27527 } else if (IS_CV == IS_CV) {
27528 Z_TRY_ADDREF_P(value);
27529 }
27530 }
27531 zend_hash_add_new(zobj->properties, name, value);
27532 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27533 ZVAL_COPY(EX_VAR(opline->result.var), value);
27534 }
27535 goto exit_assign_obj;
27536 }
27537 } else {
27538 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
27539 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
27540 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
27541 property_val = OBJ_PROP(zobj, prop_info->offset);
27542 if (ZEND_TYPE_IS_SET(prop_info->type)) {
27543 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
27544 goto free_and_exit_assign_obj;
27545 } else {
27546 goto fast_assign_obj;
27547 }
27548 }
27549 /* Fall through to write_property for hooks. */
27550 }
27551 }
27552 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
27553 } else {
27554 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
27555 if (UNEXPECTED(!name)) {
27556
27557 UNDEF_RESULT();
27558 goto exit_assign_obj;
27559 }
27560 }
27561
27562 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
27563 ZVAL_DEREF(value);
27564 }
27565
27566 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
27567
27568 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27569 zend_tmp_string_release(tmp_name);
27570 }
27571
27572 free_and_exit_assign_obj:
27573 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
27574 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
27575 }
27576
27577 exit_assign_obj:
27578 if (garbage) {
27579 GC_DTOR_NO_REF(garbage);
27580 }
27581 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27582 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27583 /* assign_obj has two opcodes! */
27584 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27585 }
27586
27587 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27588 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27589 {
27590 USE_OPLINE
27591 zval *object_ptr, *orig_object_ptr;
27592 zval *value;
27593 zval *variable_ptr;
27594 zval *dim;
27595 zend_refcounted *garbage = NULL;
27596
27597 SAVE_OPLINE();
27598 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27599
27600 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27601 try_assign_dim_array:
27602 SEPARATE_ARRAY(object_ptr);
27603 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27604 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27605 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27606 HashTable *ht = Z_ARRVAL_P(object_ptr);
27607 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27608 GC_ADDREF(ht);
27609 }
27610 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27611 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27612 zend_array_destroy(ht);
27613 goto assign_dim_error;
27614 }
27615 }
27616 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
27617 ZVAL_DEREF(value);
27618 }
27619 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27620 if (UNEXPECTED(value == NULL)) {
27621 zend_cannot_add_element();
27622 goto assign_dim_error;
27623 } else if (IS_CONST == IS_CV) {
27624 if (Z_REFCOUNTED_P(value)) {
27625 Z_ADDREF_P(value);
27626 }
27627 } else if (IS_CONST == IS_VAR) {
27628 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27629 if (Z_ISREF_P(free_op_data)) {
27630 if (Z_REFCOUNTED_P(value)) {
27631 Z_ADDREF_P(value);
27632 }
27633 zval_ptr_dtor_nogc(free_op_data);
27634 }
27635 } else if (IS_CONST == IS_CONST) {
27636 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27637 Z_ADDREF_P(value);
27638 }
27639 }
27640 } else {
27641 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27642 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27643 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27644 } else {
27645 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27646 }
27647 if (UNEXPECTED(variable_ptr == NULL)) {
27648 goto assign_dim_error;
27649 }
27650 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27651 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
27652 }
27653 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27654 ZVAL_COPY(EX_VAR(opline->result.var), value);
27655 }
27656 if (garbage) {
27657 GC_DTOR_NO_REF(garbage);
27658 }
27659 } else {
27660 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27661 object_ptr = Z_REFVAL_P(object_ptr);
27662 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27663 goto try_assign_dim_array;
27664 }
27665 }
27666 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27667 zend_object *obj = Z_OBJ_P(object_ptr);
27668
27669 GC_ADDREF(obj);
27670 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27671 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27672 dim = ZVAL_UNDEFINED_OP2();
27673 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27674 dim++;
27675 }
27676
27677 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27678 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27679 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27680 } else if (IS_CONST & (IS_CV|IS_VAR)) {
27681 ZVAL_DEREF(value);
27682 }
27683
27684 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27685
27686 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27687 zend_objects_store_del(obj);
27688 }
27689 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27690 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27691 zend_use_new_element_for_string();
27692
27693 UNDEF_RESULT();
27694 } else {
27695 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27696 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27697 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27698
27699 }
27700 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27701 if (Z_ISREF_P(orig_object_ptr)
27702 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27703 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27704 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27705
27706 UNDEF_RESULT();
27707 } else {
27708 HashTable *ht = zend_new_array(8);
27709 uint8_t old_type = Z_TYPE_P(object_ptr);
27710
27711 ZVAL_ARR(object_ptr, ht);
27712 if (UNEXPECTED(old_type == IS_FALSE)) {
27713 GC_ADDREF(ht);
27714 zend_false_to_array_deprecated();
27715 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27716 zend_array_destroy(ht);
27717 goto assign_dim_error;
27718 }
27719 }
27720 goto try_assign_dim_array;
27721 }
27722 } else {
27723 zend_use_scalar_as_array();
27724 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27725 assign_dim_error:
27726
27727 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27728 ZVAL_NULL(EX_VAR(opline->result.var));
27729 }
27730 }
27731 }
27732 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27733 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27734 }
27735 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27736 /* assign_dim has two opcodes! */
27737 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27738 }
27739
ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27740 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27741 {
27742 USE_OPLINE
27743 zval *object_ptr, *orig_object_ptr;
27744 zval *value;
27745 zval *variable_ptr;
27746 zval *dim;
27747 zend_refcounted *garbage = NULL;
27748
27749 SAVE_OPLINE();
27750 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27751
27752 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27753 try_assign_dim_array:
27754 SEPARATE_ARRAY(object_ptr);
27755 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27756 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27757 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27758 HashTable *ht = Z_ARRVAL_P(object_ptr);
27759 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27760 GC_ADDREF(ht);
27761 }
27762 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27763 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27764 zend_array_destroy(ht);
27765 goto assign_dim_error;
27766 }
27767 }
27768 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27769 ZVAL_DEREF(value);
27770 }
27771 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27772 if (UNEXPECTED(value == NULL)) {
27773 zend_cannot_add_element();
27774 goto assign_dim_error;
27775 } else if (IS_TMP_VAR == IS_CV) {
27776 if (Z_REFCOUNTED_P(value)) {
27777 Z_ADDREF_P(value);
27778 }
27779 } else if (IS_TMP_VAR == IS_VAR) {
27780 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27781 if (Z_ISREF_P(free_op_data)) {
27782 if (Z_REFCOUNTED_P(value)) {
27783 Z_ADDREF_P(value);
27784 }
27785 zval_ptr_dtor_nogc(free_op_data);
27786 }
27787 } else if (IS_TMP_VAR == IS_CONST) {
27788 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27789 Z_ADDREF_P(value);
27790 }
27791 }
27792 } else {
27793 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27794 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27795 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27796 } else {
27797 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27798 }
27799 if (UNEXPECTED(variable_ptr == NULL)) {
27800 goto assign_dim_error;
27801 }
27802 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27803 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
27804 }
27805 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27806 ZVAL_COPY(EX_VAR(opline->result.var), value);
27807 }
27808 if (garbage) {
27809 GC_DTOR_NO_REF(garbage);
27810 }
27811 } else {
27812 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27813 object_ptr = Z_REFVAL_P(object_ptr);
27814 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27815 goto try_assign_dim_array;
27816 }
27817 }
27818 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27819 zend_object *obj = Z_OBJ_P(object_ptr);
27820
27821 GC_ADDREF(obj);
27822 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27823 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27824 dim = ZVAL_UNDEFINED_OP2();
27825 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27826 dim++;
27827 }
27828
27829 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27830 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27831 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27832 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
27833 ZVAL_DEREF(value);
27834 }
27835
27836 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27837
27838 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27839 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27840 zend_objects_store_del(obj);
27841 }
27842 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27843 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27844 zend_use_new_element_for_string();
27845 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27846 UNDEF_RESULT();
27847 } else {
27848 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27849 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27850 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27851 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27852 }
27853 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27854 if (Z_ISREF_P(orig_object_ptr)
27855 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27856 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27857 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27858 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27859 UNDEF_RESULT();
27860 } else {
27861 HashTable *ht = zend_new_array(8);
27862 uint8_t old_type = Z_TYPE_P(object_ptr);
27863
27864 ZVAL_ARR(object_ptr, ht);
27865 if (UNEXPECTED(old_type == IS_FALSE)) {
27866 GC_ADDREF(ht);
27867 zend_false_to_array_deprecated();
27868 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27869 zend_array_destroy(ht);
27870 goto assign_dim_error;
27871 }
27872 }
27873 goto try_assign_dim_array;
27874 }
27875 } else {
27876 zend_use_scalar_as_array();
27877 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27878 assign_dim_error:
27879 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27880 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27881 ZVAL_NULL(EX_VAR(opline->result.var));
27882 }
27883 }
27884 }
27885 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27886 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27887 }
27888 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27889 /* assign_dim has two opcodes! */
27890 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27891 }
27892
ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27893 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27894 {
27895 USE_OPLINE
27896 zval *object_ptr, *orig_object_ptr;
27897 zval *value;
27898 zval *variable_ptr;
27899 zval *dim;
27900 zend_refcounted *garbage = NULL;
27901
27902 SAVE_OPLINE();
27903 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27904
27905 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27906 try_assign_dim_array:
27907 SEPARATE_ARRAY(object_ptr);
27908 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27909 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27910 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27911 HashTable *ht = Z_ARRVAL_P(object_ptr);
27912 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27913 GC_ADDREF(ht);
27914 }
27915 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27916 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27917 zend_array_destroy(ht);
27918 goto assign_dim_error;
27919 }
27920 }
27921 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
27922 ZVAL_DEREF(value);
27923 }
27924 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27925 if (UNEXPECTED(value == NULL)) {
27926 zend_cannot_add_element();
27927 goto assign_dim_error;
27928 } else if (IS_VAR == IS_CV) {
27929 if (Z_REFCOUNTED_P(value)) {
27930 Z_ADDREF_P(value);
27931 }
27932 } else if (IS_VAR == IS_VAR) {
27933 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27934 if (Z_ISREF_P(free_op_data)) {
27935 if (Z_REFCOUNTED_P(value)) {
27936 Z_ADDREF_P(value);
27937 }
27938 zval_ptr_dtor_nogc(free_op_data);
27939 }
27940 } else if (IS_VAR == IS_CONST) {
27941 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27942 Z_ADDREF_P(value);
27943 }
27944 }
27945 } else {
27946 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27947 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27948 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27949 } else {
27950 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27951 }
27952 if (UNEXPECTED(variable_ptr == NULL)) {
27953 goto assign_dim_error;
27954 }
27955 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27956 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
27957 }
27958 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27959 ZVAL_COPY(EX_VAR(opline->result.var), value);
27960 }
27961 if (garbage) {
27962 GC_DTOR_NO_REF(garbage);
27963 }
27964 } else {
27965 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27966 object_ptr = Z_REFVAL_P(object_ptr);
27967 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27968 goto try_assign_dim_array;
27969 }
27970 }
27971 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27972 zend_object *obj = Z_OBJ_P(object_ptr);
27973
27974 GC_ADDREF(obj);
27975 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27976 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27977 dim = ZVAL_UNDEFINED_OP2();
27978 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27979 dim++;
27980 }
27981
27982 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27983 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27984 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27985 } else if (IS_VAR & (IS_CV|IS_VAR)) {
27986 ZVAL_DEREF(value);
27987 }
27988
27989 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27990
27991 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27992 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27993 zend_objects_store_del(obj);
27994 }
27995 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27996 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27997 zend_use_new_element_for_string();
27998 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27999 UNDEF_RESULT();
28000 } else {
28001 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28002 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28003 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28004 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28005 }
28006 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28007 if (Z_ISREF_P(orig_object_ptr)
28008 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28009 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28010 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28011 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28012 UNDEF_RESULT();
28013 } else {
28014 HashTable *ht = zend_new_array(8);
28015 uint8_t old_type = Z_TYPE_P(object_ptr);
28016
28017 ZVAL_ARR(object_ptr, ht);
28018 if (UNEXPECTED(old_type == IS_FALSE)) {
28019 GC_ADDREF(ht);
28020 zend_false_to_array_deprecated();
28021 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28022 zend_array_destroy(ht);
28023 goto assign_dim_error;
28024 }
28025 }
28026 goto try_assign_dim_array;
28027 }
28028 } else {
28029 zend_use_scalar_as_array();
28030 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28031 assign_dim_error:
28032 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28033 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28034 ZVAL_NULL(EX_VAR(opline->result.var));
28035 }
28036 }
28037 }
28038 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28039 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28040 }
28041 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28042 /* assign_dim has two opcodes! */
28043 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28044 }
28045
ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28046 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28047 {
28048 USE_OPLINE
28049 zval *object_ptr, *orig_object_ptr;
28050 zval *value;
28051 zval *variable_ptr;
28052 zval *dim;
28053 zend_refcounted *garbage = NULL;
28054
28055 SAVE_OPLINE();
28056 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28057
28058 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28059 try_assign_dim_array:
28060 SEPARATE_ARRAY(object_ptr);
28061 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28062 value = EX_VAR((opline+1)->op1.var);
28063 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28064 HashTable *ht = Z_ARRVAL_P(object_ptr);
28065 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28066 GC_ADDREF(ht);
28067 }
28068 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28069 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28070 zend_array_destroy(ht);
28071 goto assign_dim_error;
28072 }
28073 }
28074 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
28075 ZVAL_DEREF(value);
28076 }
28077 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28078 if (UNEXPECTED(value == NULL)) {
28079 zend_cannot_add_element();
28080 goto assign_dim_error;
28081 } else if (IS_CV == IS_CV) {
28082 if (Z_REFCOUNTED_P(value)) {
28083 Z_ADDREF_P(value);
28084 }
28085 } else if (IS_CV == IS_VAR) {
28086 zval *free_op_data = EX_VAR((opline+1)->op1.var);
28087 if (Z_ISREF_P(free_op_data)) {
28088 if (Z_REFCOUNTED_P(value)) {
28089 Z_ADDREF_P(value);
28090 }
28091 zval_ptr_dtor_nogc(free_op_data);
28092 }
28093 } else if (IS_CV == IS_CONST) {
28094 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28095 Z_ADDREF_P(value);
28096 }
28097 }
28098 } else {
28099 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28100 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28101 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28102 } else {
28103 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28104 }
28105 if (UNEXPECTED(variable_ptr == NULL)) {
28106 goto assign_dim_error;
28107 }
28108 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
28109 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
28110 }
28111 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28112 ZVAL_COPY(EX_VAR(opline->result.var), value);
28113 }
28114 if (garbage) {
28115 GC_DTOR_NO_REF(garbage);
28116 }
28117 } else {
28118 if (EXPECTED(Z_ISREF_P(object_ptr))) {
28119 object_ptr = Z_REFVAL_P(object_ptr);
28120 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28121 goto try_assign_dim_array;
28122 }
28123 }
28124 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28125 zend_object *obj = Z_OBJ_P(object_ptr);
28126
28127 GC_ADDREF(obj);
28128 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28129 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28130 dim = ZVAL_UNDEFINED_OP2();
28131 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28132 dim++;
28133 }
28134
28135 value = EX_VAR((opline+1)->op1.var);
28136 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28137 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28138 } else if (IS_CV & (IS_CV|IS_VAR)) {
28139 ZVAL_DEREF(value);
28140 }
28141
28142 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28143
28144 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28145 zend_objects_store_del(obj);
28146 }
28147 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28148 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
28149 zend_use_new_element_for_string();
28150
28151 UNDEF_RESULT();
28152 } else {
28153 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28154 value = EX_VAR((opline+1)->op1.var);
28155 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28156
28157 }
28158 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28159 if (Z_ISREF_P(orig_object_ptr)
28160 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28161 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28162 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28163
28164 UNDEF_RESULT();
28165 } else {
28166 HashTable *ht = zend_new_array(8);
28167 uint8_t old_type = Z_TYPE_P(object_ptr);
28168
28169 ZVAL_ARR(object_ptr, ht);
28170 if (UNEXPECTED(old_type == IS_FALSE)) {
28171 GC_ADDREF(ht);
28172 zend_false_to_array_deprecated();
28173 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28174 zend_array_destroy(ht);
28175 goto assign_dim_error;
28176 }
28177 }
28178 goto try_assign_dim_array;
28179 }
28180 } else {
28181 zend_use_scalar_as_array();
28182 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28183 assign_dim_error:
28184
28185 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28186 ZVAL_NULL(EX_VAR(opline->result.var));
28187 }
28188 }
28189 }
28190 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28191 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28192 }
28193 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28194 /* assign_dim has two opcodes! */
28195 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28196 }
28197
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28198 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28199 {
28200 USE_OPLINE
28201 zval *property, *container, *value_ptr;
28202
28203 SAVE_OPLINE();
28204
28205 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28206 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28207
28208 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28209
28210 if (1) {
28211 if (IS_VAR == IS_UNUSED) {
28212 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28213 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28214 } else {
28215 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28216 }
28217 } else {
28218 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28219 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28220 } else {
28221 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28222 }
28223 }
28224 } else {
28225 zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
28226 }
28227
28228 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28229 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28230 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28231 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28232 }
28233
28234 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28235 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28236 {
28237 USE_OPLINE
28238 zval *property, *container, *value_ptr;
28239
28240 SAVE_OPLINE();
28241
28242 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28243 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28244
28245 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
28246
28247 if (1) {
28248 if (IS_VAR == IS_UNUSED) {
28249 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28250 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28251 } else {
28252 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28253 }
28254 } else {
28255 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28256 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28257 } else {
28258 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
28259 }
28260 }
28261 } else {
28262 zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
28263 }
28264
28265 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28266 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28267
28268 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28269 }
28270
28271 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28272 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28273 {
28274 USE_OPLINE
28275 zval *function_name;
28276 zend_class_entry *ce;
28277 uint32_t call_info;
28278 zend_function *fbc;
28279 zend_execute_data *call;
28280
28281 SAVE_OPLINE();
28282
28283 if (IS_VAR == IS_CONST) {
28284 /* no function found. try a static method in class */
28285 ce = CACHED_PTR(opline->result.num);
28286 if (UNEXPECTED(ce == NULL)) {
28287 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);
28288 if (UNEXPECTED(ce == NULL)) {
28289 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28290 HANDLE_EXCEPTION();
28291 }
28292 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28293 CACHE_PTR(opline->result.num, ce);
28294 }
28295 }
28296 } else if (IS_VAR == IS_UNUSED) {
28297 ce = zend_fetch_class(NULL, opline->op1.num);
28298 if (UNEXPECTED(ce == NULL)) {
28299 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28300 HANDLE_EXCEPTION();
28301 }
28302 } else {
28303 ce = Z_CE_P(EX_VAR(opline->op1.var));
28304 }
28305
28306 if (IS_VAR == IS_CONST &&
28307 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
28308 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
28309 /* nothing to do */
28310 } else if (IS_VAR != IS_CONST &&
28311 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
28312 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
28313 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
28314 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28315 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28316 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28317 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
28318 do {
28319 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
28320 function_name = Z_REFVAL_P(function_name);
28321 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
28322 break;
28323 }
28324 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
28325 ZVAL_UNDEFINED_OP2();
28326 if (UNEXPECTED(EG(exception) != NULL)) {
28327 HANDLE_EXCEPTION();
28328 }
28329 }
28330 zend_throw_error(NULL, "Method name must be a string");
28331 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28332 HANDLE_EXCEPTION();
28333 } while (0);
28334 }
28335 }
28336
28337 if (ce->get_static_method) {
28338 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
28339 } else {
28340 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));
28341 }
28342 if (UNEXPECTED(fbc == NULL)) {
28343 if (EXPECTED(!EG(exception))) {
28344 zend_undefined_method(ce, Z_STR_P(function_name));
28345 }
28346 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28347 HANDLE_EXCEPTION();
28348 }
28349 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
28350 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
28351 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
28352 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
28353 }
28354 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
28355 init_func_run_time_cache(&fbc->op_array);
28356 }
28357 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28358 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28359 }
28360 } else {
28361 if (UNEXPECTED(ce->constructor == NULL)) {
28362 zend_throw_error(NULL, "Cannot call constructor");
28363 HANDLE_EXCEPTION();
28364 }
28365 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
28366 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
28367 HANDLE_EXCEPTION();
28368 }
28369 fbc = ce->constructor;
28370 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
28371 init_func_run_time_cache(&fbc->op_array);
28372 }
28373 }
28374
28375 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
28376 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
28377 ce = (zend_class_entry*)Z_OBJ(EX(This));
28378 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
28379 } else {
28380 zend_non_static_method_call(fbc);
28381 HANDLE_EXCEPTION();
28382 }
28383 } else {
28384 /* previous opcode is ZEND_FETCH_CLASS */
28385 if (IS_VAR == IS_UNUSED
28386 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
28387 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
28388 if (Z_TYPE(EX(This)) == IS_OBJECT) {
28389 ce = Z_OBJCE(EX(This));
28390 } else {
28391 ce = Z_CE(EX(This));
28392 }
28393 }
28394 call_info = ZEND_CALL_NESTED_FUNCTION;
28395 }
28396
28397 call = zend_vm_stack_push_call_frame(call_info,
28398 fbc, opline->extended_value, ce);
28399 call->prev_execute_data = EX(call);
28400 EX(call) = call;
28401
28402 ZEND_VM_NEXT_OPCODE();
28403 }
28404
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28405 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28406 {
28407 USE_OPLINE
28408 zval *expr_ptr, new_expr;
28409
28410 SAVE_OPLINE();
28411 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
28412 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
28413 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28414 if (Z_ISREF_P(expr_ptr)) {
28415 Z_ADDREF_P(expr_ptr);
28416 } else {
28417 ZVAL_MAKE_REF_EX(expr_ptr, 2);
28418 }
28419 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28420 } else {
28421 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28422 if (IS_VAR == IS_TMP_VAR) {
28423 /* pass */
28424 } else if (IS_VAR == IS_CONST) {
28425 Z_TRY_ADDREF_P(expr_ptr);
28426 } else if (IS_VAR == IS_CV) {
28427 ZVAL_DEREF(expr_ptr);
28428 Z_TRY_ADDREF_P(expr_ptr);
28429 } else /* if (IS_VAR == IS_VAR) */ {
28430 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
28431 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
28432
28433 expr_ptr = Z_REFVAL_P(expr_ptr);
28434 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
28435 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
28436 expr_ptr = &new_expr;
28437 efree_size(ref, sizeof(zend_reference));
28438 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
28439 Z_ADDREF_P(expr_ptr);
28440 }
28441 }
28442 }
28443 }
28444
28445 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28446 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28447 zend_string *str;
28448 zend_ulong hval;
28449
28450 add_again:
28451 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
28452 str = Z_STR_P(offset);
28453 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28454 if (ZEND_HANDLE_NUMERIC(str, hval)) {
28455 goto num_index;
28456 }
28457 }
28458 str_index:
28459 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
28460 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
28461 hval = Z_LVAL_P(offset);
28462 num_index:
28463 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
28464 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
28465 offset = Z_REFVAL_P(offset);
28466 goto add_again;
28467 } else if (Z_TYPE_P(offset) == IS_NULL) {
28468 str = ZSTR_EMPTY_ALLOC();
28469 goto str_index;
28470 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
28471 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
28472 goto num_index;
28473 } else if (Z_TYPE_P(offset) == IS_FALSE) {
28474 hval = 0;
28475 goto num_index;
28476 } else if (Z_TYPE_P(offset) == IS_TRUE) {
28477 hval = 1;
28478 goto num_index;
28479 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
28480 zend_use_resource_as_offset(offset);
28481 hval = Z_RES_HANDLE_P(offset);
28482 goto num_index;
28483 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
28484 ZVAL_UNDEFINED_OP2();
28485 str = ZSTR_EMPTY_ALLOC();
28486 goto str_index;
28487 } else {
28488 zend_illegal_array_offset_access(offset);
28489 zval_ptr_dtor_nogc(expr_ptr);
28490 }
28491 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28492 } else {
28493 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
28494 zend_cannot_add_element();
28495 zval_ptr_dtor_nogc(expr_ptr);
28496 }
28497 }
28498 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28499 }
28500
ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28501 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28502 {
28503 zval *array;
28504 uint32_t size;
28505 USE_OPLINE
28506
28507 array = EX_VAR(opline->result.var);
28508 if (IS_VAR != IS_UNUSED) {
28509 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
28510 ZVAL_ARR(array, zend_new_array(size));
28511 /* Explicitly initialize array as not-packed if flag is set */
28512 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
28513 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
28514 }
28515 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28516 } else {
28517 ZVAL_ARR(array, zend_new_array(0));
28518 ZEND_VM_NEXT_OPCODE();
28519 }
28520 }
28521
ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28522 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28523 {
28524 USE_OPLINE
28525 zval *container;
28526 zval *offset;
28527 zend_ulong hval;
28528 zend_string *key;
28529
28530 SAVE_OPLINE();
28531 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28532 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28533
28534 do {
28535 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28536 HashTable *ht;
28537
28538 unset_dim_array:
28539 SEPARATE_ARRAY(container);
28540 ht = Z_ARRVAL_P(container);
28541 offset_again:
28542 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
28543 key = Z_STR_P(offset);
28544 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28545 if (ZEND_HANDLE_NUMERIC(key, hval)) {
28546 goto num_index_dim;
28547 }
28548 }
28549 str_index_dim:
28550 ZEND_ASSERT(ht != &EG(symbol_table));
28551 zend_hash_del(ht, key);
28552 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
28553 hval = Z_LVAL_P(offset);
28554 num_index_dim:
28555 zend_hash_index_del(ht, hval);
28556 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
28557 offset = Z_REFVAL_P(offset);
28558 goto offset_again;
28559 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
28560 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
28561 goto num_index_dim;
28562 } else if (Z_TYPE_P(offset) == IS_NULL) {
28563 key = ZSTR_EMPTY_ALLOC();
28564 goto str_index_dim;
28565 } else if (Z_TYPE_P(offset) == IS_FALSE) {
28566 hval = 0;
28567 goto num_index_dim;
28568 } else if (Z_TYPE_P(offset) == IS_TRUE) {
28569 hval = 1;
28570 goto num_index_dim;
28571 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
28572 zend_use_resource_as_offset(offset);
28573 hval = Z_RES_HANDLE_P(offset);
28574 goto num_index_dim;
28575 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
28576 ZVAL_UNDEFINED_OP2();
28577 key = ZSTR_EMPTY_ALLOC();
28578 goto str_index_dim;
28579 } else {
28580 zend_illegal_array_offset_unset(offset);
28581 }
28582 break;
28583 } else if (Z_ISREF_P(container)) {
28584 container = Z_REFVAL_P(container);
28585 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28586 goto unset_dim_array;
28587 }
28588 }
28589 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
28590 container = ZVAL_UNDEFINED_OP1();
28591 }
28592 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
28593 offset = ZVAL_UNDEFINED_OP2();
28594 }
28595 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
28596 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
28597 offset++;
28598 }
28599 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
28600 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
28601 zend_throw_error(NULL, "Cannot unset string offsets");
28602 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
28603 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
28604 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
28605 zend_false_to_array_deprecated();
28606 }
28607 } while (0);
28608
28609 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28610 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28611 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28612 }
28613
ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28614 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28615 {
28616 USE_OPLINE
28617 zval *container;
28618 zval *offset;
28619 zend_string *name, *tmp_name;
28620
28621 SAVE_OPLINE();
28622 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28623 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28624
28625 do {
28626 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
28627 if (Z_ISREF_P(container)) {
28628 container = Z_REFVAL_P(container);
28629 if (Z_TYPE_P(container) != IS_OBJECT) {
28630 if (IS_VAR == IS_CV
28631 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
28632 ZVAL_UNDEFINED_OP1();
28633 }
28634 break;
28635 }
28636 } else {
28637 break;
28638 }
28639 }
28640 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
28641 name = Z_STR_P(offset);
28642 } else {
28643 name = zval_try_get_tmp_string(offset, &tmp_name);
28644 if (UNEXPECTED(!name)) {
28645 break;
28646 }
28647 }
28648 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));
28649 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
28650 zend_tmp_string_release(tmp_name);
28651 }
28652 } while (0);
28653
28654 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28655 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28656 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28657 }
28658
ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28659 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28660 {
28661 USE_OPLINE
28662
28663 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
28664
28665 SAVE_OPLINE();
28666 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
28667 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28668 }
28669
28670 /* Destroy the previously yielded value */
28671 zval_ptr_dtor(&generator->value);
28672
28673 /* Destroy the previously yielded key */
28674 zval_ptr_dtor(&generator->key);
28675
28676 /* Set the new yielded value */
28677 if (IS_VAR != IS_UNUSED) {
28678 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
28679 /* Constants and temporary variables aren't yieldable by reference,
28680 * but we still allow them with a notice. */
28681 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
28682 zval *value;
28683
28684 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28685
28686 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28687 ZVAL_COPY_VALUE(&generator->value, value);
28688 if (IS_VAR == IS_CONST) {
28689 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28690 Z_ADDREF(generator->value);
28691 }
28692 }
28693 } else {
28694 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28695
28696 /* If a function call result is yielded and the function did
28697 * not return by reference we throw a notice. */
28698 do {
28699 if (IS_VAR == IS_VAR) {
28700 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
28701 if (opline->extended_value == ZEND_RETURNS_FUNCTION
28702 && !Z_ISREF_P(value_ptr)) {
28703 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28704 ZVAL_COPY(&generator->value, value_ptr);
28705 break;
28706 }
28707 }
28708 if (Z_ISREF_P(value_ptr)) {
28709 Z_ADDREF_P(value_ptr);
28710 } else {
28711 ZVAL_MAKE_REF_EX(value_ptr, 2);
28712 }
28713 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
28714 } while (0);
28715
28716 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28717 }
28718 } else {
28719 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28720
28721 /* Consts, temporary variables and references need copying */
28722 if (IS_VAR == IS_CONST) {
28723 ZVAL_COPY_VALUE(&generator->value, value);
28724 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28725 Z_ADDREF(generator->value);
28726 }
28727 } else if (IS_VAR == IS_TMP_VAR) {
28728 ZVAL_COPY_VALUE(&generator->value, value);
28729 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
28730 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
28731 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28732 } else {
28733 ZVAL_COPY_VALUE(&generator->value, value);
28734 if (IS_VAR == IS_CV) {
28735 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
28736 }
28737 }
28738 }
28739 } else {
28740 /* If no value was specified yield null */
28741 ZVAL_NULL(&generator->value);
28742 }
28743
28744 /* Set the new yielded key */
28745 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28746 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28747 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
28748 key = Z_REFVAL_P(key);
28749 }
28750 ZVAL_COPY(&generator->key, key);
28751 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28752
28753 if (Z_TYPE(generator->key) == IS_LONG
28754 && Z_LVAL(generator->key) > generator->largest_used_integer_key
28755 ) {
28756 generator->largest_used_integer_key = Z_LVAL(generator->key);
28757 }
28758 } else {
28759 /* If no key was specified we use auto-increment keys */
28760 generator->largest_used_integer_key++;
28761 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
28762 }
28763
28764 if (RETURN_VALUE_USED(opline)) {
28765 /* If the return value of yield is used set the send
28766 * target and initialize it to NULL */
28767 generator->send_target = EX_VAR(opline->result.var);
28768 ZVAL_NULL(generator->send_target);
28769 } else {
28770 generator->send_target = NULL;
28771 }
28772
28773 /* The GOTO VM uses a local opline variable. We need to set the opline
28774 * variable in execute_data so we don't resume at an old position. */
28775 SAVE_OPLINE();
28776
28777 ZEND_VM_RETURN();
28778 }
28779
ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28780 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28781 {
28782 USE_OPLINE
28783 zval *op1, *op2;
28784 bool result;
28785
28786 SAVE_OPLINE();
28787 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28788 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28789 result = fast_is_identical_function(op1, op2);
28790 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28791 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28792 ZEND_VM_SMART_BRANCH(result, 1);
28793 }
28794
ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28795 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28796 {
28797 USE_OPLINE
28798 zval *op1, *op2;
28799 bool result;
28800
28801 SAVE_OPLINE();
28802 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28803 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28804 result = fast_is_identical_function(op1, op2);
28805 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28806 ZEND_VM_SMART_BRANCH(result, 1);
28807 }
28808
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28809 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28810 {
28811 USE_OPLINE
28812 zval *op1, *op2;
28813 bool result;
28814
28815 SAVE_OPLINE();
28816 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28817 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28818 result = fast_is_not_identical_function(op1, op2);
28819 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28820 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28821 ZEND_VM_SMART_BRANCH(result, 1);
28822 }
28823
ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28824 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28825 {
28826 USE_OPLINE
28827 zval *value;
28828 zval *variable_ptr;
28829
28830 SAVE_OPLINE();
28831 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28832 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28833
28834 if (0 || UNEXPECTED(0)) {
28835 zend_refcounted *garbage = NULL;
28836
28837 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28838 if (UNEXPECTED(0)) {
28839 ZVAL_COPY(EX_VAR(opline->result.var), value);
28840 }
28841 if (garbage) {
28842 GC_DTOR_NO_REF(garbage);
28843 }
28844 } else {
28845 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
28846 }
28847 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28848 /* zend_assign_to_variable() always takes care of op2, never free it! */
28849
28850 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28851 }
28852
ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28853 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28854 {
28855 USE_OPLINE
28856 zval *value;
28857 zval *variable_ptr;
28858
28859 SAVE_OPLINE();
28860 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28861 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28862
28863 if (0 || UNEXPECTED(1)) {
28864 zend_refcounted *garbage = NULL;
28865
28866 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28867 if (UNEXPECTED(1)) {
28868 ZVAL_COPY(EX_VAR(opline->result.var), value);
28869 }
28870 if (garbage) {
28871 GC_DTOR_NO_REF(garbage);
28872 }
28873 } else {
28874 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
28875 }
28876 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28877 /* zend_assign_to_variable() always takes care of op2, never free it! */
28878
28879 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28880 }
28881
ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28882 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28883 {
28884 USE_OPLINE
28885 zval *op1, *op2;
28886 bool result;
28887
28888 SAVE_OPLINE();
28889 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28890 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28891 result = fast_is_identical_function(op1, op2);
28892 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28893 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28894 ZEND_VM_SMART_BRANCH(result, 1);
28895 }
28896
ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28897 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28898 {
28899 USE_OPLINE
28900 zval *op1, *op2;
28901 bool result;
28902
28903 SAVE_OPLINE();
28904 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28905 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28906 result = fast_is_identical_function(op1, op2);
28907 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28908 ZEND_VM_SMART_BRANCH(result, 1);
28909 }
28910
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28911 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28912 {
28913 USE_OPLINE
28914 zval *op1, *op2;
28915 bool result;
28916
28917 SAVE_OPLINE();
28918 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28919 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28920 result = fast_is_not_identical_function(op1, op2);
28921 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28922 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28923 ZEND_VM_SMART_BRANCH(result, 1);
28924 }
28925
ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28926 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28927 {
28928 USE_OPLINE
28929 zval *value;
28930 zval *variable_ptr;
28931
28932 SAVE_OPLINE();
28933 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28934 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28935
28936 if (0 || UNEXPECTED(0)) {
28937 zend_refcounted *garbage = NULL;
28938
28939 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
28940 if (UNEXPECTED(0)) {
28941 ZVAL_COPY(EX_VAR(opline->result.var), value);
28942 }
28943 if (garbage) {
28944 GC_DTOR_NO_REF(garbage);
28945 }
28946 } else {
28947 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
28948 }
28949 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28950 /* zend_assign_to_variable() always takes care of op2, never free it! */
28951
28952 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28953 }
28954
ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28955 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28956 {
28957 USE_OPLINE
28958 zval *value;
28959 zval *variable_ptr;
28960
28961 SAVE_OPLINE();
28962 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28963 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28964
28965 if (0 || UNEXPECTED(1)) {
28966 zend_refcounted *garbage = NULL;
28967
28968 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
28969 if (UNEXPECTED(1)) {
28970 ZVAL_COPY(EX_VAR(opline->result.var), value);
28971 }
28972 if (garbage) {
28973 GC_DTOR_NO_REF(garbage);
28974 }
28975 } else {
28976 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
28977 }
28978 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28979 /* zend_assign_to_variable() always takes care of op2, never free it! */
28980
28981 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28982 }
28983
ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28984 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28985 {
28986 USE_OPLINE
28987 zval *variable_ptr;
28988 zval *value_ptr;
28989 zend_refcounted *garbage = NULL;
28990
28991 SAVE_OPLINE();
28992 value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28993 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28994
28995 if (IS_VAR == IS_VAR &&
28996 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
28997
28998 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
28999 variable_ptr = &EG(uninitialized_zval);
29000 } else if (IS_VAR == IS_VAR &&
29001 opline->extended_value == ZEND_RETURNS_FUNCTION &&
29002 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
29003
29004 variable_ptr = zend_wrong_assign_to_variable_reference(
29005 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
29006 } else {
29007 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
29008 }
29009
29010 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29011 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
29012 }
29013
29014 if (garbage) {
29015 GC_DTOR(garbage);
29016 }
29017
29018 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
29019 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29020 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29021 }
29022
ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29023 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29024 {
29025 USE_OPLINE
29026 zval *var_ptr;
29027 zval *value, *container, *dim;
29028 HashTable *ht;
29029
29030 SAVE_OPLINE();
29031 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29032
29033 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
29034 assign_dim_op_array:
29035 SEPARATE_ARRAY(container);
29036 ht = Z_ARRVAL_P(container);
29037 assign_dim_op_new_array:
29038 dim = NULL;
29039 if (IS_UNUSED == IS_UNUSED) {
29040 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
29041 if (UNEXPECTED(!var_ptr)) {
29042 zend_cannot_add_element();
29043 goto assign_dim_op_ret_null;
29044 }
29045 } else {
29046 if (IS_UNUSED == IS_CONST) {
29047 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
29048 } else {
29049 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
29050 }
29051 if (UNEXPECTED(!var_ptr)) {
29052 goto assign_dim_op_ret_null;
29053 }
29054 }
29055
29056 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
29057
29058 do {
29059 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
29060 zend_reference *ref = Z_REF_P(var_ptr);
29061 var_ptr = Z_REFVAL_P(var_ptr);
29062 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
29063 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
29064 break;
29065 }
29066 }
29067 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
29068 } while (0);
29069
29070 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29071 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
29072 }
29073 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
29074 } else {
29075 if (EXPECTED(Z_ISREF_P(container))) {
29076 container = Z_REFVAL_P(container);
29077 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
29078 goto assign_dim_op_array;
29079 }
29080 }
29081
29082 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
29083 zend_object *obj = Z_OBJ_P(container);
29084
29085 dim = NULL;
29086 if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29087 dim++;
29088 }
29089 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
29090 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
29091 uint8_t old_type;
29092
29093 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
29094 ZVAL_UNDEFINED_OP1();
29095 }
29096 ht = zend_new_array(8);
29097 old_type = Z_TYPE_P(container);
29098 ZVAL_ARR(container, ht);
29099 if (UNEXPECTED(old_type == IS_FALSE)) {
29100 GC_ADDREF(ht);
29101 zend_false_to_array_deprecated();
29102 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29103 zend_array_destroy(ht);
29104 goto assign_dim_op_ret_null;
29105 }
29106 }
29107 goto assign_dim_op_new_array;
29108 } else {
29109 dim = NULL;
29110 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
29111 assign_dim_op_ret_null:
29112 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
29113 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29114 ZVAL_NULL(EX_VAR(opline->result.var));
29115 }
29116 }
29117 }
29118
29119 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29120 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29121 }
29122
ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29123 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29124 {
29125 USE_OPLINE
29126 zval *container;
29127
29128 SAVE_OPLINE();
29129 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29130 zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
29131
29132 if (IS_VAR == IS_VAR) {
29133 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
29134 }
29135 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29136 }
29137
ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29138 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29139 {
29140 USE_OPLINE
29141 zval *container;
29142
29143 SAVE_OPLINE();
29144 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29145 zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
29146
29147 if (IS_VAR == IS_VAR) {
29148 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
29149 }
29150 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29151 }
29152
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29153 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29154 {
29155 #if 0
29156 USE_OPLINE
29157 #endif
29158
29159 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
29160 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
29161 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29162 }
29163 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29164 } else {
29165 if (IS_UNUSED == IS_UNUSED) {
29166 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29167 }
29168 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29169 }
29170 }
29171
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29172 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29173 {
29174 USE_OPLINE
29175 zval *object_ptr, *orig_object_ptr;
29176 zval *value;
29177 zval *variable_ptr;
29178 zval *dim;
29179 zend_refcounted *garbage = NULL;
29180
29181 SAVE_OPLINE();
29182 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29183
29184 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29185 try_assign_dim_array:
29186 SEPARATE_ARRAY(object_ptr);
29187 if (IS_UNUSED == IS_UNUSED) {
29188 value = RT_CONSTANT((opline+1), (opline+1)->op1);
29189 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29190 HashTable *ht = Z_ARRVAL_P(object_ptr);
29191 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29192 GC_ADDREF(ht);
29193 }
29194 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29195 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29196 zend_array_destroy(ht);
29197 goto assign_dim_error;
29198 }
29199 }
29200 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
29201 ZVAL_DEREF(value);
29202 }
29203 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29204 if (UNEXPECTED(value == NULL)) {
29205 zend_cannot_add_element();
29206 goto assign_dim_error;
29207 } else if (IS_CONST == IS_CV) {
29208 if (Z_REFCOUNTED_P(value)) {
29209 Z_ADDREF_P(value);
29210 }
29211 } else if (IS_CONST == IS_VAR) {
29212 zval *free_op_data = EX_VAR((opline+1)->op1.var);
29213 if (Z_ISREF_P(free_op_data)) {
29214 if (Z_REFCOUNTED_P(value)) {
29215 Z_ADDREF_P(value);
29216 }
29217 zval_ptr_dtor_nogc(free_op_data);
29218 }
29219 } else if (IS_CONST == IS_CONST) {
29220 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29221 Z_ADDREF_P(value);
29222 }
29223 }
29224 } else {
29225 dim = NULL;
29226 if (IS_UNUSED == IS_CONST) {
29227 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29228 } else {
29229 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29230 }
29231 if (UNEXPECTED(variable_ptr == NULL)) {
29232 goto assign_dim_error;
29233 }
29234 value = RT_CONSTANT((opline+1), (opline+1)->op1);
29235 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
29236 }
29237 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29238 ZVAL_COPY(EX_VAR(opline->result.var), value);
29239 }
29240 if (garbage) {
29241 GC_DTOR_NO_REF(garbage);
29242 }
29243 } else {
29244 if (EXPECTED(Z_ISREF_P(object_ptr))) {
29245 object_ptr = Z_REFVAL_P(object_ptr);
29246 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29247 goto try_assign_dim_array;
29248 }
29249 }
29250 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29251 zend_object *obj = Z_OBJ_P(object_ptr);
29252
29253 GC_ADDREF(obj);
29254 dim = NULL;
29255 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29256 dim = ZVAL_UNDEFINED_OP2();
29257 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29258 dim++;
29259 }
29260
29261 value = RT_CONSTANT((opline+1), (opline+1)->op1);
29262 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29263 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29264 } else if (IS_CONST & (IS_CV|IS_VAR)) {
29265 ZVAL_DEREF(value);
29266 }
29267
29268 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29269
29270 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29271 zend_objects_store_del(obj);
29272 }
29273 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29274 if (IS_UNUSED == IS_UNUSED) {
29275 zend_use_new_element_for_string();
29276
29277 UNDEF_RESULT();
29278 } else {
29279 dim = NULL;
29280 value = RT_CONSTANT((opline+1), (opline+1)->op1);
29281 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29282
29283 }
29284 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29285 if (Z_ISREF_P(orig_object_ptr)
29286 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29287 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29288 dim = NULL;
29289
29290 UNDEF_RESULT();
29291 } else {
29292 HashTable *ht = zend_new_array(8);
29293 uint8_t old_type = Z_TYPE_P(object_ptr);
29294
29295 ZVAL_ARR(object_ptr, ht);
29296 if (UNEXPECTED(old_type == IS_FALSE)) {
29297 GC_ADDREF(ht);
29298 zend_false_to_array_deprecated();
29299 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29300 zend_array_destroy(ht);
29301 goto assign_dim_error;
29302 }
29303 }
29304 goto try_assign_dim_array;
29305 }
29306 } else {
29307 zend_use_scalar_as_array();
29308 dim = NULL;
29309 assign_dim_error:
29310
29311 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29312 ZVAL_NULL(EX_VAR(opline->result.var));
29313 }
29314 }
29315 }
29316 if (IS_UNUSED != IS_UNUSED) {
29317
29318 }
29319 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29320 /* assign_dim has two opcodes! */
29321 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29322 }
29323
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29324 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29325 {
29326 USE_OPLINE
29327 zval *object_ptr, *orig_object_ptr;
29328 zval *value;
29329 zval *variable_ptr;
29330 zval *dim;
29331 zend_refcounted *garbage = NULL;
29332
29333 SAVE_OPLINE();
29334 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29335
29336 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29337 try_assign_dim_array:
29338 SEPARATE_ARRAY(object_ptr);
29339 if (IS_UNUSED == IS_UNUSED) {
29340 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29341 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29342 HashTable *ht = Z_ARRVAL_P(object_ptr);
29343 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29344 GC_ADDREF(ht);
29345 }
29346 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29347 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29348 zend_array_destroy(ht);
29349 goto assign_dim_error;
29350 }
29351 }
29352 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
29353 ZVAL_DEREF(value);
29354 }
29355 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29356 if (UNEXPECTED(value == NULL)) {
29357 zend_cannot_add_element();
29358 goto assign_dim_error;
29359 } else if (IS_TMP_VAR == IS_CV) {
29360 if (Z_REFCOUNTED_P(value)) {
29361 Z_ADDREF_P(value);
29362 }
29363 } else if (IS_TMP_VAR == IS_VAR) {
29364 zval *free_op_data = EX_VAR((opline+1)->op1.var);
29365 if (Z_ISREF_P(free_op_data)) {
29366 if (Z_REFCOUNTED_P(value)) {
29367 Z_ADDREF_P(value);
29368 }
29369 zval_ptr_dtor_nogc(free_op_data);
29370 }
29371 } else if (IS_TMP_VAR == IS_CONST) {
29372 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29373 Z_ADDREF_P(value);
29374 }
29375 }
29376 } else {
29377 dim = NULL;
29378 if (IS_UNUSED == IS_CONST) {
29379 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29380 } else {
29381 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29382 }
29383 if (UNEXPECTED(variable_ptr == NULL)) {
29384 goto assign_dim_error;
29385 }
29386 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29387 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
29388 }
29389 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29390 ZVAL_COPY(EX_VAR(opline->result.var), value);
29391 }
29392 if (garbage) {
29393 GC_DTOR_NO_REF(garbage);
29394 }
29395 } else {
29396 if (EXPECTED(Z_ISREF_P(object_ptr))) {
29397 object_ptr = Z_REFVAL_P(object_ptr);
29398 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29399 goto try_assign_dim_array;
29400 }
29401 }
29402 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29403 zend_object *obj = Z_OBJ_P(object_ptr);
29404
29405 GC_ADDREF(obj);
29406 dim = NULL;
29407 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29408 dim = ZVAL_UNDEFINED_OP2();
29409 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29410 dim++;
29411 }
29412
29413 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29414 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29415 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29416 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
29417 ZVAL_DEREF(value);
29418 }
29419
29420 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29421
29422 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29423 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29424 zend_objects_store_del(obj);
29425 }
29426 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29427 if (IS_UNUSED == IS_UNUSED) {
29428 zend_use_new_element_for_string();
29429 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29430 UNDEF_RESULT();
29431 } else {
29432 dim = NULL;
29433 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
29434 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29435 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29436 }
29437 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29438 if (Z_ISREF_P(orig_object_ptr)
29439 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29440 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29441 dim = NULL;
29442 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29443 UNDEF_RESULT();
29444 } else {
29445 HashTable *ht = zend_new_array(8);
29446 uint8_t old_type = Z_TYPE_P(object_ptr);
29447
29448 ZVAL_ARR(object_ptr, ht);
29449 if (UNEXPECTED(old_type == IS_FALSE)) {
29450 GC_ADDREF(ht);
29451 zend_false_to_array_deprecated();
29452 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29453 zend_array_destroy(ht);
29454 goto assign_dim_error;
29455 }
29456 }
29457 goto try_assign_dim_array;
29458 }
29459 } else {
29460 zend_use_scalar_as_array();
29461 dim = NULL;
29462 assign_dim_error:
29463 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29464 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29465 ZVAL_NULL(EX_VAR(opline->result.var));
29466 }
29467 }
29468 }
29469 if (IS_UNUSED != IS_UNUSED) {
29470
29471 }
29472 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29473 /* assign_dim has two opcodes! */
29474 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29475 }
29476
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29477 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29478 {
29479 USE_OPLINE
29480 zval *object_ptr, *orig_object_ptr;
29481 zval *value;
29482 zval *variable_ptr;
29483 zval *dim;
29484 zend_refcounted *garbage = NULL;
29485
29486 SAVE_OPLINE();
29487 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29488
29489 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29490 try_assign_dim_array:
29491 SEPARATE_ARRAY(object_ptr);
29492 if (IS_UNUSED == IS_UNUSED) {
29493 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29494 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29495 HashTable *ht = Z_ARRVAL_P(object_ptr);
29496 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29497 GC_ADDREF(ht);
29498 }
29499 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29500 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29501 zend_array_destroy(ht);
29502 goto assign_dim_error;
29503 }
29504 }
29505 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
29506 ZVAL_DEREF(value);
29507 }
29508 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29509 if (UNEXPECTED(value == NULL)) {
29510 zend_cannot_add_element();
29511 goto assign_dim_error;
29512 } else if (IS_VAR == IS_CV) {
29513 if (Z_REFCOUNTED_P(value)) {
29514 Z_ADDREF_P(value);
29515 }
29516 } else if (IS_VAR == IS_VAR) {
29517 zval *free_op_data = EX_VAR((opline+1)->op1.var);
29518 if (Z_ISREF_P(free_op_data)) {
29519 if (Z_REFCOUNTED_P(value)) {
29520 Z_ADDREF_P(value);
29521 }
29522 zval_ptr_dtor_nogc(free_op_data);
29523 }
29524 } else if (IS_VAR == IS_CONST) {
29525 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29526 Z_ADDREF_P(value);
29527 }
29528 }
29529 } else {
29530 dim = NULL;
29531 if (IS_UNUSED == IS_CONST) {
29532 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29533 } else {
29534 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29535 }
29536 if (UNEXPECTED(variable_ptr == NULL)) {
29537 goto assign_dim_error;
29538 }
29539 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29540 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
29541 }
29542 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29543 ZVAL_COPY(EX_VAR(opline->result.var), value);
29544 }
29545 if (garbage) {
29546 GC_DTOR_NO_REF(garbage);
29547 }
29548 } else {
29549 if (EXPECTED(Z_ISREF_P(object_ptr))) {
29550 object_ptr = Z_REFVAL_P(object_ptr);
29551 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29552 goto try_assign_dim_array;
29553 }
29554 }
29555 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29556 zend_object *obj = Z_OBJ_P(object_ptr);
29557
29558 GC_ADDREF(obj);
29559 dim = NULL;
29560 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29561 dim = ZVAL_UNDEFINED_OP2();
29562 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29563 dim++;
29564 }
29565
29566 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29567 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29568 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29569 } else if (IS_VAR & (IS_CV|IS_VAR)) {
29570 ZVAL_DEREF(value);
29571 }
29572
29573 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29574
29575 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29576 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29577 zend_objects_store_del(obj);
29578 }
29579 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29580 if (IS_UNUSED == IS_UNUSED) {
29581 zend_use_new_element_for_string();
29582 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29583 UNDEF_RESULT();
29584 } else {
29585 dim = NULL;
29586 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
29587 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29588 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29589 }
29590 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29591 if (Z_ISREF_P(orig_object_ptr)
29592 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29593 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29594 dim = NULL;
29595 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29596 UNDEF_RESULT();
29597 } else {
29598 HashTable *ht = zend_new_array(8);
29599 uint8_t old_type = Z_TYPE_P(object_ptr);
29600
29601 ZVAL_ARR(object_ptr, ht);
29602 if (UNEXPECTED(old_type == IS_FALSE)) {
29603 GC_ADDREF(ht);
29604 zend_false_to_array_deprecated();
29605 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29606 zend_array_destroy(ht);
29607 goto assign_dim_error;
29608 }
29609 }
29610 goto try_assign_dim_array;
29611 }
29612 } else {
29613 zend_use_scalar_as_array();
29614 dim = NULL;
29615 assign_dim_error:
29616 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
29617 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29618 ZVAL_NULL(EX_VAR(opline->result.var));
29619 }
29620 }
29621 }
29622 if (IS_UNUSED != IS_UNUSED) {
29623
29624 }
29625 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29626 /* assign_dim has two opcodes! */
29627 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29628 }
29629
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29630 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29631 {
29632 USE_OPLINE
29633 zval *object_ptr, *orig_object_ptr;
29634 zval *value;
29635 zval *variable_ptr;
29636 zval *dim;
29637 zend_refcounted *garbage = NULL;
29638
29639 SAVE_OPLINE();
29640 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29641
29642 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29643 try_assign_dim_array:
29644 SEPARATE_ARRAY(object_ptr);
29645 if (IS_UNUSED == IS_UNUSED) {
29646 value = EX_VAR((opline+1)->op1.var);
29647 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
29648 HashTable *ht = Z_ARRVAL_P(object_ptr);
29649 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29650 GC_ADDREF(ht);
29651 }
29652 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29653 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29654 zend_array_destroy(ht);
29655 goto assign_dim_error;
29656 }
29657 }
29658 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
29659 ZVAL_DEREF(value);
29660 }
29661 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29662 if (UNEXPECTED(value == NULL)) {
29663 zend_cannot_add_element();
29664 goto assign_dim_error;
29665 } else if (IS_CV == IS_CV) {
29666 if (Z_REFCOUNTED_P(value)) {
29667 Z_ADDREF_P(value);
29668 }
29669 } else if (IS_CV == IS_VAR) {
29670 zval *free_op_data = EX_VAR((opline+1)->op1.var);
29671 if (Z_ISREF_P(free_op_data)) {
29672 if (Z_REFCOUNTED_P(value)) {
29673 Z_ADDREF_P(value);
29674 }
29675 zval_ptr_dtor_nogc(free_op_data);
29676 }
29677 } else if (IS_CV == IS_CONST) {
29678 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29679 Z_ADDREF_P(value);
29680 }
29681 }
29682 } else {
29683 dim = NULL;
29684 if (IS_UNUSED == IS_CONST) {
29685 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29686 } else {
29687 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29688 }
29689 if (UNEXPECTED(variable_ptr == NULL)) {
29690 goto assign_dim_error;
29691 }
29692 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
29693 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
29694 }
29695 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29696 ZVAL_COPY(EX_VAR(opline->result.var), value);
29697 }
29698 if (garbage) {
29699 GC_DTOR_NO_REF(garbage);
29700 }
29701 } else {
29702 if (EXPECTED(Z_ISREF_P(object_ptr))) {
29703 object_ptr = Z_REFVAL_P(object_ptr);
29704 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29705 goto try_assign_dim_array;
29706 }
29707 }
29708 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29709 zend_object *obj = Z_OBJ_P(object_ptr);
29710
29711 GC_ADDREF(obj);
29712 dim = NULL;
29713 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29714 dim = ZVAL_UNDEFINED_OP2();
29715 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29716 dim++;
29717 }
29718
29719 value = EX_VAR((opline+1)->op1.var);
29720 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29721 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29722 } else if (IS_CV & (IS_CV|IS_VAR)) {
29723 ZVAL_DEREF(value);
29724 }
29725
29726 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29727
29728 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29729 zend_objects_store_del(obj);
29730 }
29731 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29732 if (IS_UNUSED == IS_UNUSED) {
29733 zend_use_new_element_for_string();
29734
29735 UNDEF_RESULT();
29736 } else {
29737 dim = NULL;
29738 value = EX_VAR((opline+1)->op1.var);
29739 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29740
29741 }
29742 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29743 if (Z_ISREF_P(orig_object_ptr)
29744 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29745 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29746 dim = NULL;
29747
29748 UNDEF_RESULT();
29749 } else {
29750 HashTable *ht = zend_new_array(8);
29751 uint8_t old_type = Z_TYPE_P(object_ptr);
29752
29753 ZVAL_ARR(object_ptr, ht);
29754 if (UNEXPECTED(old_type == IS_FALSE)) {
29755 GC_ADDREF(ht);
29756 zend_false_to_array_deprecated();
29757 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29758 zend_array_destroy(ht);
29759 goto assign_dim_error;
29760 }
29761 }
29762 goto try_assign_dim_array;
29763 }
29764 } else {
29765 zend_use_scalar_as_array();
29766 dim = NULL;
29767 assign_dim_error:
29768
29769 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29770 ZVAL_NULL(EX_VAR(opline->result.var));
29771 }
29772 }
29773 }
29774 if (IS_UNUSED != IS_UNUSED) {
29775
29776 }
29777 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29778 /* assign_dim has two opcodes! */
29779 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29780 }
29781
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29782 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29783 {
29784 USE_OPLINE
29785 zval *function_name;
29786 zend_class_entry *ce;
29787 uint32_t call_info;
29788 zend_function *fbc;
29789 zend_execute_data *call;
29790
29791 SAVE_OPLINE();
29792
29793 if (IS_VAR == IS_CONST) {
29794 /* no function found. try a static method in class */
29795 ce = CACHED_PTR(opline->result.num);
29796 if (UNEXPECTED(ce == NULL)) {
29797 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);
29798 if (UNEXPECTED(ce == NULL)) {
29799
29800 HANDLE_EXCEPTION();
29801 }
29802 if (IS_UNUSED != IS_CONST) {
29803 CACHE_PTR(opline->result.num, ce);
29804 }
29805 }
29806 } else if (IS_VAR == IS_UNUSED) {
29807 ce = zend_fetch_class(NULL, opline->op1.num);
29808 if (UNEXPECTED(ce == NULL)) {
29809
29810 HANDLE_EXCEPTION();
29811 }
29812 } else {
29813 ce = Z_CE_P(EX_VAR(opline->op1.var));
29814 }
29815
29816 if (IS_VAR == IS_CONST &&
29817 IS_UNUSED == IS_CONST &&
29818 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
29819 /* nothing to do */
29820 } else if (IS_VAR != IS_CONST &&
29821 IS_UNUSED == IS_CONST &&
29822 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
29823 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
29824 } else if (IS_UNUSED != IS_UNUSED) {
29825 function_name = NULL;
29826 if (IS_UNUSED != IS_CONST) {
29827 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
29828 do {
29829 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
29830 function_name = Z_REFVAL_P(function_name);
29831 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
29832 break;
29833 }
29834 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
29835 ZVAL_UNDEFINED_OP2();
29836 if (UNEXPECTED(EG(exception) != NULL)) {
29837 HANDLE_EXCEPTION();
29838 }
29839 }
29840 zend_throw_error(NULL, "Method name must be a string");
29841
29842 HANDLE_EXCEPTION();
29843 } while (0);
29844 }
29845 }
29846
29847 if (ce->get_static_method) {
29848 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
29849 } else {
29850 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
29851 }
29852 if (UNEXPECTED(fbc == NULL)) {
29853 if (EXPECTED(!EG(exception))) {
29854 zend_undefined_method(ce, Z_STR_P(function_name));
29855 }
29856
29857 HANDLE_EXCEPTION();
29858 }
29859 if (IS_UNUSED == IS_CONST &&
29860 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
29861 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
29862 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
29863 }
29864 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
29865 init_func_run_time_cache(&fbc->op_array);
29866 }
29867 if (IS_UNUSED != IS_CONST) {
29868
29869 }
29870 } else {
29871 if (UNEXPECTED(ce->constructor == NULL)) {
29872 zend_throw_error(NULL, "Cannot call constructor");
29873 HANDLE_EXCEPTION();
29874 }
29875 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
29876 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
29877 HANDLE_EXCEPTION();
29878 }
29879 fbc = ce->constructor;
29880 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
29881 init_func_run_time_cache(&fbc->op_array);
29882 }
29883 }
29884
29885 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
29886 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
29887 ce = (zend_class_entry*)Z_OBJ(EX(This));
29888 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
29889 } else {
29890 zend_non_static_method_call(fbc);
29891 HANDLE_EXCEPTION();
29892 }
29893 } else {
29894 /* previous opcode is ZEND_FETCH_CLASS */
29895 if (IS_VAR == IS_UNUSED
29896 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
29897 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
29898 if (Z_TYPE(EX(This)) == IS_OBJECT) {
29899 ce = Z_OBJCE(EX(This));
29900 } else {
29901 ce = Z_CE(EX(This));
29902 }
29903 }
29904 call_info = ZEND_CALL_NESTED_FUNCTION;
29905 }
29906
29907 call = zend_vm_stack_push_call_frame(call_info,
29908 fbc, opline->extended_value, ce);
29909 call->prev_execute_data = EX(call);
29910 EX(call) = call;
29911
29912 ZEND_VM_NEXT_OPCODE();
29913 }
29914
ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29915 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29916 {
29917 if (IS_VAR == IS_UNUSED) {
29918 SAVE_OPLINE();
29919 zend_verify_missing_return_type(EX(func));
29920 HANDLE_EXCEPTION();
29921 } else {
29922 /* prevents "undefined variable opline" errors */
29923 #if 0 || (IS_VAR != IS_UNUSED)
29924 USE_OPLINE
29925 zval *retval_ref, *retval_ptr;
29926 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
29927 retval_ref = retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29928
29929 if (IS_VAR == IS_CONST) {
29930 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
29931 retval_ref = retval_ptr = EX_VAR(opline->result.var);
29932 } else if (IS_VAR == IS_VAR) {
29933 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
29934 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
29935 }
29936 ZVAL_DEREF(retval_ptr);
29937 } else if (IS_VAR == IS_CV) {
29938 ZVAL_DEREF(retval_ptr);
29939 }
29940
29941 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
29942 ZEND_VM_NEXT_OPCODE();
29943 }
29944
29945 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
29946 SAVE_OPLINE();
29947 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
29948 if (UNEXPECTED(EG(exception))) {
29949 HANDLE_EXCEPTION();
29950 }
29951 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
29952 ZEND_VM_NEXT_OPCODE();
29953 }
29954 }
29955
29956 zend_reference *ref = NULL;
29957 void *cache_slot = CACHE_ADDR(opline->op2.num);
29958 if (UNEXPECTED(retval_ref != retval_ptr)) {
29959 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
29960 ref = Z_REF_P(retval_ref);
29961 } else {
29962 /* A cast might happen - unwrap the reference if this is a by-value return */
29963 if (Z_REFCOUNT_P(retval_ref) == 1) {
29964 ZVAL_UNREF(retval_ref);
29965 } else {
29966 Z_DELREF_P(retval_ref);
29967 ZVAL_COPY(retval_ref, retval_ptr);
29968 }
29969 retval_ptr = retval_ref;
29970 }
29971 }
29972
29973 SAVE_OPLINE();
29974 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
29975 zend_verify_return_error(EX(func), retval_ptr);
29976 HANDLE_EXCEPTION();
29977 }
29978 ZEND_VM_NEXT_OPCODE();
29979 #endif
29980 }
29981 }
29982
ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29983 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29984 {
29985 USE_OPLINE
29986 zval *varptr, *arg;
29987
29988 if (IS_UNUSED == IS_CONST) {
29989 SAVE_OPLINE();
29990 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29991 uint32_t arg_num;
29992 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29993 if (UNEXPECTED(!arg)) {
29994 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29995 HANDLE_EXCEPTION();
29996 }
29997 } else {
29998 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29999 }
30000
30001 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30002 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30003 SAVE_OPLINE();
30004 ZVAL_UNDEFINED_OP1();
30005 ZVAL_NULL(arg);
30006 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30007 }
30008
30009 if (IS_VAR == IS_CV) {
30010 ZVAL_COPY_DEREF(arg, varptr);
30011 } else /* if (IS_VAR == IS_VAR) */ {
30012 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30013 zend_refcounted *ref = Z_COUNTED_P(varptr);
30014
30015 varptr = Z_REFVAL_P(varptr);
30016 ZVAL_COPY_VALUE(arg, varptr);
30017 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30018 efree_size(ref, sizeof(zend_reference));
30019 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30020 Z_ADDREF_P(arg);
30021 }
30022 } else {
30023 ZVAL_COPY_VALUE(arg, varptr);
30024 }
30025 }
30026
30027 ZEND_VM_NEXT_OPCODE();
30028 }
30029
ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30030 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30031 {
30032 USE_OPLINE
30033 zval *varptr, *arg;
30034
30035 if (IS_UNUSED == IS_CONST) {
30036 SAVE_OPLINE();
30037 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30038 uint32_t arg_num;
30039 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30040 if (UNEXPECTED(!arg)) {
30041 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30042 HANDLE_EXCEPTION();
30043 }
30044 } else {
30045 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30046 }
30047
30048 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30049 ZVAL_COPY_VALUE(arg, varptr);
30050
30051 if (EXPECTED(Z_ISREF_P(varptr))) {
30052 ZEND_VM_NEXT_OPCODE();
30053 }
30054
30055 SAVE_OPLINE();
30056 ZVAL_NEW_REF(arg, arg);
30057 zend_error(E_NOTICE, "Only variables should be passed by reference");
30058 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30059 }
30060
ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30061 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30062 {
30063 USE_OPLINE
30064 zval *varptr, *arg;
30065 uint32_t arg_num;
30066
30067 if (IS_UNUSED == IS_CONST) {
30068 SAVE_OPLINE();
30069 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30070 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30071 if (UNEXPECTED(!arg)) {
30072 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30073 HANDLE_EXCEPTION();
30074 }
30075 } else {
30076 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30077 arg_num = opline->op2.num;
30078 }
30079
30080 if (EXPECTED(0)) {
30081 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30082 goto send_var;
30083 }
30084
30085 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30086 ZVAL_COPY_VALUE(arg, varptr);
30087
30088 if (EXPECTED(Z_ISREF_P(varptr) ||
30089 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30090 ZEND_VM_NEXT_OPCODE();
30091 }
30092 } else {
30093 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30094 goto send_var;
30095 }
30096
30097 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30098 ZVAL_COPY_VALUE(arg, varptr);
30099
30100 if (EXPECTED(Z_ISREF_P(varptr) ||
30101 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30102 ZEND_VM_NEXT_OPCODE();
30103 }
30104 }
30105
30106 SAVE_OPLINE();
30107 ZVAL_NEW_REF(arg, arg);
30108 zend_error(E_NOTICE, "Only variables should be passed by reference");
30109 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30110
30111 send_var:
30112 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30113 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30114 zend_refcounted *ref = Z_COUNTED_P(varptr);
30115
30116 varptr = Z_REFVAL_P(varptr);
30117 ZVAL_COPY_VALUE(arg, varptr);
30118 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30119 efree_size(ref, sizeof(zend_reference));
30120 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30121 Z_ADDREF_P(arg);
30122 }
30123 } else {
30124 ZVAL_COPY_VALUE(arg, varptr);
30125 }
30126 ZEND_VM_NEXT_OPCODE();
30127 }
30128
ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30129 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30130 {
30131 USE_OPLINE
30132 zval *varptr, *arg;
30133 uint32_t arg_num;
30134
30135 if (IS_UNUSED == IS_CONST) {
30136 SAVE_OPLINE();
30137 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30138 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30139 if (UNEXPECTED(!arg)) {
30140 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30141 HANDLE_EXCEPTION();
30142 }
30143 } else {
30144 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30145 arg_num = opline->op2.num;
30146 }
30147
30148 if (EXPECTED(1)) {
30149 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30150 goto send_var;
30151 }
30152
30153 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30154 ZVAL_COPY_VALUE(arg, varptr);
30155
30156 if (EXPECTED(Z_ISREF_P(varptr) ||
30157 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30158 ZEND_VM_NEXT_OPCODE();
30159 }
30160 } else {
30161 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30162 goto send_var;
30163 }
30164
30165 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30166 ZVAL_COPY_VALUE(arg, varptr);
30167
30168 if (EXPECTED(Z_ISREF_P(varptr) ||
30169 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
30170 ZEND_VM_NEXT_OPCODE();
30171 }
30172 }
30173
30174 SAVE_OPLINE();
30175 ZVAL_NEW_REF(arg, arg);
30176 zend_error(E_NOTICE, "Only variables should be passed by reference");
30177 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30178
30179 send_var:
30180 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30181 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30182 zend_refcounted *ref = Z_COUNTED_P(varptr);
30183
30184 varptr = Z_REFVAL_P(varptr);
30185 ZVAL_COPY_VALUE(arg, varptr);
30186 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30187 efree_size(ref, sizeof(zend_reference));
30188 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30189 Z_ADDREF_P(arg);
30190 }
30191 } else {
30192 ZVAL_COPY_VALUE(arg, varptr);
30193 }
30194 ZEND_VM_NEXT_OPCODE();
30195 }
30196
ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30197 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30198 {
30199 USE_OPLINE
30200 zval *varptr, *arg;
30201
30202 SAVE_OPLINE();
30203 if (IS_UNUSED == IS_CONST) {
30204 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30205 uint32_t arg_num;
30206 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30207 if (UNEXPECTED(!arg)) {
30208 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30209 HANDLE_EXCEPTION();
30210 }
30211 } else {
30212 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30213 }
30214
30215 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30216 if (Z_ISREF_P(varptr)) {
30217 Z_ADDREF_P(varptr);
30218 } else {
30219 ZVAL_MAKE_REF_EX(varptr, 2);
30220 }
30221 ZVAL_REF(arg, Z_REF_P(varptr));
30222
30223 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30224 ZEND_VM_NEXT_OPCODE();
30225 }
30226
ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30227 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30228 {
30229 USE_OPLINE
30230 zval *varptr, *arg;
30231 uint32_t arg_num;
30232
30233 if (IS_UNUSED == IS_CONST) {
30234 SAVE_OPLINE();
30235 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30236 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30237 if (UNEXPECTED(!arg)) {
30238 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30239 HANDLE_EXCEPTION();
30240 }
30241 } else {
30242 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30243 arg_num = opline->op2.num;
30244 }
30245
30246 if (EXPECTED(0)) {
30247 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30248 goto send_var_by_ref;
30249 }
30250 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30251 send_var_by_ref:
30252 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30253 if (Z_ISREF_P(varptr)) {
30254 Z_ADDREF_P(varptr);
30255 } else {
30256 ZVAL_MAKE_REF_EX(varptr, 2);
30257 }
30258 ZVAL_REF(arg, Z_REF_P(varptr));
30259
30260 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30261 ZEND_VM_NEXT_OPCODE();
30262 }
30263
30264 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30265 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30266 SAVE_OPLINE();
30267 ZVAL_UNDEFINED_OP1();
30268 ZVAL_NULL(arg);
30269 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30270 }
30271
30272 if (IS_VAR == IS_CV) {
30273 ZVAL_COPY_DEREF(arg, varptr);
30274 } else /* if (IS_VAR == IS_VAR) */ {
30275 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30276 zend_refcounted *ref = Z_COUNTED_P(varptr);
30277
30278 varptr = Z_REFVAL_P(varptr);
30279 ZVAL_COPY_VALUE(arg, varptr);
30280 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30281 efree_size(ref, sizeof(zend_reference));
30282 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30283 Z_ADDREF_P(arg);
30284 }
30285 } else {
30286 ZVAL_COPY_VALUE(arg, varptr);
30287 }
30288 }
30289
30290 ZEND_VM_NEXT_OPCODE();
30291 }
30292
ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30293 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30294 {
30295 USE_OPLINE
30296 zval *varptr, *arg;
30297 uint32_t arg_num;
30298
30299 if (IS_UNUSED == IS_CONST) {
30300 SAVE_OPLINE();
30301 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30302 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30303 if (UNEXPECTED(!arg)) {
30304 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30305 HANDLE_EXCEPTION();
30306 }
30307 } else {
30308 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30309 arg_num = opline->op2.num;
30310 }
30311
30312 if (EXPECTED(1)) {
30313 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30314 goto send_var_by_ref;
30315 }
30316 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30317 send_var_by_ref:
30318 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30319 if (Z_ISREF_P(varptr)) {
30320 Z_ADDREF_P(varptr);
30321 } else {
30322 ZVAL_MAKE_REF_EX(varptr, 2);
30323 }
30324 ZVAL_REF(arg, Z_REF_P(varptr));
30325
30326 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30327 ZEND_VM_NEXT_OPCODE();
30328 }
30329
30330 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30331 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
30332 SAVE_OPLINE();
30333 ZVAL_UNDEFINED_OP1();
30334 ZVAL_NULL(arg);
30335 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30336 }
30337
30338 if (IS_VAR == IS_CV) {
30339 ZVAL_COPY_DEREF(arg, varptr);
30340 } else /* if (IS_VAR == IS_VAR) */ {
30341 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30342 zend_refcounted *ref = Z_COUNTED_P(varptr);
30343
30344 varptr = Z_REFVAL_P(varptr);
30345 ZVAL_COPY_VALUE(arg, varptr);
30346 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30347 efree_size(ref, sizeof(zend_reference));
30348 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30349 Z_ADDREF_P(arg);
30350 }
30351 } else {
30352 ZVAL_COPY_VALUE(arg, varptr);
30353 }
30354 }
30355
30356 ZEND_VM_NEXT_OPCODE();
30357 }
30358
ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30359 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30360 {
30361 USE_OPLINE
30362 zval *varptr, *arg;
30363
30364 if (IS_UNUSED == IS_CONST) {
30365 // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
30366 SAVE_OPLINE();
30367 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
30368 uint32_t arg_num;
30369 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
30370 if (UNEXPECTED(!arg)) {
30371 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30372 HANDLE_EXCEPTION();
30373 }
30374 } else {
30375 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30376 }
30377
30378 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
30379 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30380 if (Z_ISREF_P(varptr)) {
30381 Z_ADDREF_P(varptr);
30382 } else {
30383 ZVAL_MAKE_REF_EX(varptr, 2);
30384 }
30385 ZVAL_REF(arg, Z_REF_P(varptr));
30386
30387 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30388 ZEND_VM_NEXT_OPCODE();
30389 }
30390
30391 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30392
30393 if (UNEXPECTED(Z_ISREF_P(varptr))) {
30394 zend_refcounted *ref = Z_COUNTED_P(varptr);
30395
30396 varptr = Z_REFVAL_P(varptr);
30397 ZVAL_COPY_VALUE(arg, varptr);
30398 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30399 efree_size(ref, sizeof(zend_reference));
30400 } else if (Z_OPT_REFCOUNTED_P(arg)) {
30401 Z_ADDREF_P(arg);
30402 }
30403 } else {
30404 ZVAL_COPY_VALUE(arg, varptr);
30405 }
30406
30407 ZEND_VM_NEXT_OPCODE();
30408 }
30409
ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30410 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30411 {
30412 USE_OPLINE
30413 zval *result;
30414 zend_function *constructor;
30415 zend_class_entry *ce;
30416 zend_execute_data *call;
30417
30418 SAVE_OPLINE();
30419 if (IS_VAR == IS_CONST) {
30420 ce = CACHED_PTR(opline->op2.num);
30421 if (UNEXPECTED(ce == NULL)) {
30422 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);
30423 if (UNEXPECTED(ce == NULL)) {
30424 ZVAL_UNDEF(EX_VAR(opline->result.var));
30425 HANDLE_EXCEPTION();
30426 }
30427 CACHE_PTR(opline->op2.num, ce);
30428 }
30429 } else if (IS_VAR == IS_UNUSED) {
30430 ce = zend_fetch_class(NULL, opline->op1.num);
30431 if (UNEXPECTED(ce == NULL)) {
30432 ZVAL_UNDEF(EX_VAR(opline->result.var));
30433 HANDLE_EXCEPTION();
30434 }
30435 } else {
30436 ce = Z_CE_P(EX_VAR(opline->op1.var));
30437 }
30438
30439 result = EX_VAR(opline->result.var);
30440 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
30441 ZVAL_UNDEF(result);
30442 HANDLE_EXCEPTION();
30443 }
30444
30445 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
30446 if (constructor == NULL) {
30447 if (UNEXPECTED(EG(exception))) {
30448 HANDLE_EXCEPTION();
30449 }
30450
30451 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
30452 * opcode is DO_FCALL in case EXT instructions are used. */
30453 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
30454 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30455 }
30456
30457 /* Perform a dummy function call */
30458 call = zend_vm_stack_push_call_frame(
30459 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
30460 opline->extended_value, NULL);
30461 } else {
30462 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
30463 init_func_run_time_cache(&constructor->op_array);
30464 }
30465 /* We are not handling overloaded classes right now */
30466 call = zend_vm_stack_push_call_frame(
30467 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
30468 constructor,
30469 opline->extended_value,
30470 Z_OBJ_P(result));
30471 Z_ADDREF_P(result);
30472 }
30473
30474 call->prev_execute_data = EX(call);
30475 EX(call) = call;
30476 ZEND_VM_NEXT_OPCODE();
30477 }
30478
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30479 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30480 {
30481 USE_OPLINE
30482 zval *expr_ptr, new_expr;
30483
30484 SAVE_OPLINE();
30485 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
30486 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
30487 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30488 if (Z_ISREF_P(expr_ptr)) {
30489 Z_ADDREF_P(expr_ptr);
30490 } else {
30491 ZVAL_MAKE_REF_EX(expr_ptr, 2);
30492 }
30493 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30494 } else {
30495 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30496 if (IS_VAR == IS_TMP_VAR) {
30497 /* pass */
30498 } else if (IS_VAR == IS_CONST) {
30499 Z_TRY_ADDREF_P(expr_ptr);
30500 } else if (IS_VAR == IS_CV) {
30501 ZVAL_DEREF(expr_ptr);
30502 Z_TRY_ADDREF_P(expr_ptr);
30503 } else /* if (IS_VAR == IS_VAR) */ {
30504 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
30505 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
30506
30507 expr_ptr = Z_REFVAL_P(expr_ptr);
30508 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
30509 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
30510 expr_ptr = &new_expr;
30511 efree_size(ref, sizeof(zend_reference));
30512 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
30513 Z_ADDREF_P(expr_ptr);
30514 }
30515 }
30516 }
30517 }
30518
30519 if (IS_UNUSED != IS_UNUSED) {
30520 zval *offset = NULL;
30521 zend_string *str;
30522 zend_ulong hval;
30523
30524 add_again:
30525 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
30526 str = Z_STR_P(offset);
30527 if (IS_UNUSED != IS_CONST) {
30528 if (ZEND_HANDLE_NUMERIC(str, hval)) {
30529 goto num_index;
30530 }
30531 }
30532 str_index:
30533 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
30534 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
30535 hval = Z_LVAL_P(offset);
30536 num_index:
30537 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
30538 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
30539 offset = Z_REFVAL_P(offset);
30540 goto add_again;
30541 } else if (Z_TYPE_P(offset) == IS_NULL) {
30542 str = ZSTR_EMPTY_ALLOC();
30543 goto str_index;
30544 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
30545 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
30546 goto num_index;
30547 } else if (Z_TYPE_P(offset) == IS_FALSE) {
30548 hval = 0;
30549 goto num_index;
30550 } else if (Z_TYPE_P(offset) == IS_TRUE) {
30551 hval = 1;
30552 goto num_index;
30553 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
30554 zend_use_resource_as_offset(offset);
30555 hval = Z_RES_HANDLE_P(offset);
30556 goto num_index;
30557 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
30558 ZVAL_UNDEFINED_OP2();
30559 str = ZSTR_EMPTY_ALLOC();
30560 goto str_index;
30561 } else {
30562 zend_illegal_array_offset_access(offset);
30563 zval_ptr_dtor_nogc(expr_ptr);
30564 }
30565
30566 } else {
30567 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
30568 zend_cannot_add_element();
30569 zval_ptr_dtor_nogc(expr_ptr);
30570 }
30571 }
30572 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30573 }
30574
ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30575 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30576 {
30577 zval *array;
30578 uint32_t size;
30579 USE_OPLINE
30580
30581 array = EX_VAR(opline->result.var);
30582 if (IS_VAR != IS_UNUSED) {
30583 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
30584 ZVAL_ARR(array, zend_new_array(size));
30585 /* Explicitly initialize array as not-packed if flag is set */
30586 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
30587 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
30588 }
30589 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30590 } else {
30591 ZVAL_ARR(array, zend_new_array(0));
30592 ZEND_VM_NEXT_OPCODE();
30593 }
30594 }
30595
ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30596 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30597 {
30598 USE_OPLINE
30599 zval *var_ptr;
30600
30601 var_ptr = EX_VAR(opline->op1.var);
30602 if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
30603 if (UNEXPECTED(Z_REFCOUNT_P(var_ptr) == 1)) {
30604 ZVAL_UNREF(var_ptr);
30605 }
30606 }
30607
30608 ZEND_VM_NEXT_OPCODE();
30609 }
30610
ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30611 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30612 {
30613 USE_OPLINE
30614
30615 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
30616
30617 SAVE_OPLINE();
30618 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
30619 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30620 }
30621
30622 /* Destroy the previously yielded value */
30623 zval_ptr_dtor(&generator->value);
30624
30625 /* Destroy the previously yielded key */
30626 zval_ptr_dtor(&generator->key);
30627
30628 /* Set the new yielded value */
30629 if (IS_VAR != IS_UNUSED) {
30630 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
30631 /* Constants and temporary variables aren't yieldable by reference,
30632 * but we still allow them with a notice. */
30633 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
30634 zval *value;
30635
30636 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30637
30638 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30639 ZVAL_COPY_VALUE(&generator->value, value);
30640 if (IS_VAR == IS_CONST) {
30641 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
30642 Z_ADDREF(generator->value);
30643 }
30644 }
30645 } else {
30646 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30647
30648 /* If a function call result is yielded and the function did
30649 * not return by reference we throw a notice. */
30650 do {
30651 if (IS_VAR == IS_VAR) {
30652 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
30653 if (opline->extended_value == ZEND_RETURNS_FUNCTION
30654 && !Z_ISREF_P(value_ptr)) {
30655 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30656 ZVAL_COPY(&generator->value, value_ptr);
30657 break;
30658 }
30659 }
30660 if (Z_ISREF_P(value_ptr)) {
30661 Z_ADDREF_P(value_ptr);
30662 } else {
30663 ZVAL_MAKE_REF_EX(value_ptr, 2);
30664 }
30665 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
30666 } while (0);
30667
30668 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30669 }
30670 } else {
30671 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30672
30673 /* Consts, temporary variables and references need copying */
30674 if (IS_VAR == IS_CONST) {
30675 ZVAL_COPY_VALUE(&generator->value, value);
30676 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
30677 Z_ADDREF(generator->value);
30678 }
30679 } else if (IS_VAR == IS_TMP_VAR) {
30680 ZVAL_COPY_VALUE(&generator->value, value);
30681 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
30682 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
30683 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30684 } else {
30685 ZVAL_COPY_VALUE(&generator->value, value);
30686 if (IS_VAR == IS_CV) {
30687 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
30688 }
30689 }
30690 }
30691 } else {
30692 /* If no value was specified yield null */
30693 ZVAL_NULL(&generator->value);
30694 }
30695
30696 /* Set the new yielded key */
30697 if (IS_UNUSED != IS_UNUSED) {
30698 zval *key = NULL;
30699 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
30700 key = Z_REFVAL_P(key);
30701 }
30702 ZVAL_COPY(&generator->key, key);
30703
30704 if (Z_TYPE(generator->key) == IS_LONG
30705 && Z_LVAL(generator->key) > generator->largest_used_integer_key
30706 ) {
30707 generator->largest_used_integer_key = Z_LVAL(generator->key);
30708 }
30709 } else {
30710 /* If no key was specified we use auto-increment keys */
30711 generator->largest_used_integer_key++;
30712 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
30713 }
30714
30715 if (RETURN_VALUE_USED(opline)) {
30716 /* If the return value of yield is used set the send
30717 * target and initialize it to NULL */
30718 generator->send_target = EX_VAR(opline->result.var);
30719 ZVAL_NULL(generator->send_target);
30720 } else {
30721 generator->send_target = NULL;
30722 }
30723
30724 /* The GOTO VM uses a local opline variable. We need to set the opline
30725 * variable in execute_data so we don't resume at an old position. */
30726 SAVE_OPLINE();
30727
30728 ZEND_VM_RETURN();
30729 }
30730
ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30731 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30732 {
30733 USE_OPLINE
30734 zval *op1 = EX_VAR(opline->op1.var);
30735
30736 if (IS_VAR == IS_CV) {
30737 if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
30738 ZVAL_NEW_EMPTY_REF(op1);
30739 Z_SET_REFCOUNT_P(op1, 2);
30740 ZVAL_NULL(Z_REFVAL_P(op1));
30741 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30742 } else {
30743 if (Z_ISREF_P(op1)) {
30744 Z_ADDREF_P(op1);
30745 } else {
30746 ZVAL_MAKE_REF_EX(op1, 2);
30747 }
30748 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30749 }
30750 } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
30751 op1 = Z_INDIRECT_P(op1);
30752 if (EXPECTED(!Z_ISREF_P(op1))) {
30753 ZVAL_MAKE_REF_EX(op1, 2);
30754 } else {
30755 GC_ADDREF(Z_REF_P(op1));
30756 }
30757 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30758 } else {
30759 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
30760 }
30761 ZEND_VM_NEXT_OPCODE();
30762 }
30763
ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30764 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30765 {
30766 USE_OPLINE
30767 zval *op1;
30768 zend_string *type;
30769
30770 SAVE_OPLINE();
30771 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30772 type = zend_zval_get_legacy_type(op1);
30773 if (EXPECTED(type)) {
30774 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
30775 } else {
30776 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
30777 }
30778 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30779 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30780 }
30781
ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30782 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30783 {
30784 USE_OPLINE
30785 zval *varptr, *arg;
30786 uint32_t arg_num = opline->op2.num;
30787
30788 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30789 ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30790 }
30791
30792 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30793 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30794
30795 if (IS_VAR == IS_CV) {
30796 ZVAL_COPY(arg, varptr);
30797 } else /* if (IS_VAR == IS_VAR) */ {
30798 ZVAL_COPY_VALUE(arg, varptr);
30799 }
30800
30801 ZEND_VM_NEXT_OPCODE();
30802 }
30803
ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30804 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30805 {
30806 USE_OPLINE
30807 zval *op1, *op2;
30808 bool result;
30809
30810 SAVE_OPLINE();
30811 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30812 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30813 result = fast_is_identical_function(op1, op2);
30814
30815 ZEND_VM_SMART_BRANCH(result, 1);
30816 }
30817
ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30818 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30819 {
30820 USE_OPLINE
30821 zval *object;
30822 zval *property;
30823 zval *value;
30824 zval *zptr;
30825 void *_cache_slot[3] = {0};
30826 void **cache_slot;
30827 zend_property_info *prop_info;
30828 zend_object *zobj;
30829 zend_string *name, *tmp_name;
30830
30831 SAVE_OPLINE();
30832 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30833 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30834
30835 do {
30836 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
30837
30838 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30839 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30840 object = Z_REFVAL_P(object);
30841 goto assign_op_object;
30842 }
30843 if (IS_VAR == IS_CV
30844 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
30845 ZVAL_UNDEFINED_OP1();
30846 }
30847 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
30848 break;
30849 }
30850
30851 assign_op_object:
30852 /* here we are sure we are dealing with an object */
30853 zobj = Z_OBJ_P(object);
30854 if (IS_CV == IS_CONST) {
30855 name = Z_STR_P(property);
30856 } else {
30857 name = zval_try_get_tmp_string(property, &tmp_name);
30858 if (UNEXPECTED(!name)) {
30859 UNDEF_RESULT();
30860 break;
30861 }
30862 }
30863 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
30864 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
30865 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
30866 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30867 ZVAL_NULL(EX_VAR(opline->result.var));
30868 }
30869 } else {
30870 zend_reference *ref;
30871
30872 do {
30873 if (UNEXPECTED(Z_ISREF_P(zptr))) {
30874 ref = Z_REF_P(zptr);
30875 zptr = Z_REFVAL_P(zptr);
30876 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
30877 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
30878 break;
30879 }
30880 }
30881
30882 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
30883 if (prop_info) {
30884 /* special case for typed properties */
30885 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
30886 } else {
30887 zend_binary_op(zptr, zptr, value OPLINE_CC);
30888 }
30889 } while (0);
30890
30891 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30892 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
30893 }
30894 }
30895 } else {
30896 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
30897 }
30898 if (IS_CV != IS_CONST) {
30899 zend_tmp_string_release(tmp_name);
30900 }
30901 } while (0);
30902
30903 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
30904
30905 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30906 /* assign_obj has two opcodes! */
30907 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30908 }
30909
30910 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30911 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30912 {
30913 USE_OPLINE
30914 zval *var_ptr;
30915 zval *value, *container, *dim;
30916 HashTable *ht;
30917
30918 SAVE_OPLINE();
30919 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30920
30921 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
30922 assign_dim_op_array:
30923 SEPARATE_ARRAY(container);
30924 ht = Z_ARRVAL_P(container);
30925 assign_dim_op_new_array:
30926 dim = EX_VAR(opline->op2.var);
30927 if (IS_CV == IS_UNUSED) {
30928 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
30929 if (UNEXPECTED(!var_ptr)) {
30930 zend_cannot_add_element();
30931 goto assign_dim_op_ret_null;
30932 }
30933 } else {
30934 if (IS_CV == IS_CONST) {
30935 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
30936 } else {
30937 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
30938 }
30939 if (UNEXPECTED(!var_ptr)) {
30940 goto assign_dim_op_ret_null;
30941 }
30942 }
30943
30944 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
30945
30946 do {
30947 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
30948 zend_reference *ref = Z_REF_P(var_ptr);
30949 var_ptr = Z_REFVAL_P(var_ptr);
30950 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
30951 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
30952 break;
30953 }
30954 }
30955 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
30956 } while (0);
30957
30958 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30959 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
30960 }
30961 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
30962 } else {
30963 if (EXPECTED(Z_ISREF_P(container))) {
30964 container = Z_REFVAL_P(container);
30965 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
30966 goto assign_dim_op_array;
30967 }
30968 }
30969
30970 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
30971 zend_object *obj = Z_OBJ_P(container);
30972
30973 dim = EX_VAR(opline->op2.var);
30974 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
30975 dim++;
30976 }
30977 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
30978 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
30979 uint8_t old_type;
30980
30981 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
30982 ZVAL_UNDEFINED_OP1();
30983 }
30984 ht = zend_new_array(8);
30985 old_type = Z_TYPE_P(container);
30986 ZVAL_ARR(container, ht);
30987 if (UNEXPECTED(old_type == IS_FALSE)) {
30988 GC_ADDREF(ht);
30989 zend_false_to_array_deprecated();
30990 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
30991 zend_array_destroy(ht);
30992 goto assign_dim_op_ret_null;
30993 }
30994 }
30995 goto assign_dim_op_new_array;
30996 } else {
30997 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30998 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
30999 assign_dim_op_ret_null:
31000 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
31001 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31002 ZVAL_NULL(EX_VAR(opline->result.var));
31003 }
31004 }
31005 }
31006
31007 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31008 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31009 }
31010
ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31011 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31012 {
31013 USE_OPLINE
31014 zval *var_ptr;
31015 zval *value;
31016
31017 SAVE_OPLINE();
31018 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31019 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31020
31021 do {
31022 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
31023 zend_reference *ref = Z_REF_P(var_ptr);
31024 var_ptr = Z_REFVAL_P(var_ptr);
31025 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
31026 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
31027 break;
31028 }
31029 }
31030 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
31031 } while (0);
31032
31033 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31034 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
31035 }
31036
31037 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31038 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31039 }
31040
ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31041 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31042 {
31043 USE_OPLINE
31044 zval *object;
31045 zval *property;
31046 zval *zptr;
31047 void *_cache_slot[3] = {0};
31048 void **cache_slot;
31049 zend_property_info *prop_info;
31050 zend_object *zobj;
31051 zend_string *name, *tmp_name;
31052
31053 SAVE_OPLINE();
31054 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31055 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31056
31057 do {
31058 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31059 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31060 object = Z_REFVAL_P(object);
31061 goto pre_incdec_object;
31062 }
31063 if (IS_VAR == IS_CV
31064 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
31065 ZVAL_UNDEFINED_OP1();
31066 }
31067 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
31068 break;
31069 }
31070
31071 pre_incdec_object:
31072 /* here we are sure we are dealing with an object */
31073 zobj = Z_OBJ_P(object);
31074 if (IS_CV == IS_CONST) {
31075 name = Z_STR_P(property);
31076 } else {
31077 name = zval_try_get_tmp_string(property, &tmp_name);
31078 if (UNEXPECTED(!name)) {
31079 UNDEF_RESULT();
31080 break;
31081 }
31082 }
31083 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
31084 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
31085 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
31086 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31087 ZVAL_NULL(EX_VAR(opline->result.var));
31088 }
31089 } else {
31090 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
31091 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
31092 }
31093 } else {
31094 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
31095 }
31096 if (IS_CV != IS_CONST) {
31097 zend_tmp_string_release(tmp_name);
31098 }
31099 } while (0);
31100
31101 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31102 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31103 }
31104
ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31105 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31106 {
31107 USE_OPLINE
31108 zval *object;
31109 zval *property;
31110 zval *zptr;
31111 void *_cache_slot[3] = {0};
31112 void **cache_slot;
31113 zend_property_info *prop_info;
31114 zend_object *zobj;
31115 zend_string *name, *tmp_name;
31116
31117 SAVE_OPLINE();
31118 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31119 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31120
31121 do {
31122 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31123 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31124 object = Z_REFVAL_P(object);
31125 goto post_incdec_object;
31126 }
31127 if (IS_VAR == IS_CV
31128 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
31129 ZVAL_UNDEFINED_OP1();
31130 }
31131 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
31132 break;
31133 }
31134
31135 post_incdec_object:
31136 /* here we are sure we are dealing with an object */
31137 zobj = Z_OBJ_P(object);
31138 if (IS_CV == IS_CONST) {
31139 name = Z_STR_P(property);
31140 } else {
31141 name = zval_try_get_tmp_string(property, &tmp_name);
31142 if (UNEXPECTED(!name)) {
31143 ZVAL_UNDEF(EX_VAR(opline->result.var));
31144 break;
31145 }
31146 }
31147 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
31148 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
31149 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
31150 ZVAL_NULL(EX_VAR(opline->result.var));
31151 } else {
31152 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
31153 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
31154 }
31155 } else {
31156 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
31157 }
31158 if (IS_CV != IS_CONST) {
31159 zend_tmp_string_release(tmp_name);
31160 }
31161 } while (0);
31162
31163 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31164 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31165 }
31166
ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31167 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31168 {
31169 USE_OPLINE
31170 zval *container;
31171
31172 SAVE_OPLINE();
31173 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31174 zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31175
31176 if (IS_VAR == IS_VAR) {
31177 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31178 }
31179 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31180 }
31181
ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31182 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31183 {
31184 USE_OPLINE
31185 zval *container;
31186
31187 SAVE_OPLINE();
31188 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31189 zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31190
31191 if (IS_VAR == IS_VAR) {
31192 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31193 }
31194 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31195 }
31196
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31197 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31198 {
31199 #if 0
31200 USE_OPLINE
31201 #endif
31202
31203 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
31204 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
31205 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31206 }
31207 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31208 } else {
31209 if (IS_CV == IS_UNUSED) {
31210 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31211 }
31212 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31213 }
31214 }
31215
ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31216 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31217 {
31218 USE_OPLINE
31219 zval *container;
31220
31221 SAVE_OPLINE();
31222 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31223 zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
31224
31225 if (IS_VAR == IS_VAR) {
31226 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31227 }
31228 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31229 }
31230
ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31231 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31232 {
31233 USE_OPLINE
31234 zval *property, *container, *result;
31235
31236 SAVE_OPLINE();
31237
31238 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31239 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31240 result = EX_VAR(opline->result.var);
31241 zend_fetch_property_address(
31242 result, container, IS_VAR, property, IS_CV,
31243 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
31244 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
31245
31246 if (IS_VAR == IS_VAR) {
31247 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31248 }
31249 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31250 }
31251
ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31252 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31253 {
31254 USE_OPLINE
31255 zval *property, *container, *result;
31256
31257 SAVE_OPLINE();
31258 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31259 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31260 result = EX_VAR(opline->result.var);
31261 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);
31262
31263 if (IS_VAR == IS_VAR) {
31264 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31265 }
31266 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31267 }
31268
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31269 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31270 {
31271 #if 0
31272 USE_OPLINE
31273 #endif
31274
31275 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
31276 /* Behave like FETCH_OBJ_W */
31277 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
31278 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31279 }
31280 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31281 } else {
31282 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
31283 }
31284 }
31285
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31286 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31287 {
31288 USE_OPLINE
31289 zval *container, *property, *result;
31290
31291 SAVE_OPLINE();
31292 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31293 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31294 result = EX_VAR(opline->result.var);
31295 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);
31296
31297 if (IS_VAR == IS_VAR) {
31298 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
31299 }
31300 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31301 }
31302
ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31303 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31304 {
31305 USE_OPLINE
31306 zval *container, *dim;
31307
31308 SAVE_OPLINE();
31309 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31310 dim = EX_VAR(opline->op2.var);
31311
31312 if (IS_VAR == IS_VAR
31313 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
31314 && UNEXPECTED(!Z_ISREF_P(container))
31315 ) {
31316 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
31317 zend_fetch_dimension_address_LIST_r(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
31318 } else {
31319 zend_fetch_dimension_address_W(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
31320 }
31321
31322 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31323 }
31324
ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31325 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31326 {
31327 USE_OPLINE
31328 zval *object, *value, tmp;
31329 zend_object *zobj;
31330 zend_string *name, *tmp_name;
31331 zend_refcounted *garbage = NULL;
31332
31333 SAVE_OPLINE();
31334 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31335 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31336
31337 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31338 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31339 object = Z_REFVAL_P(object);
31340 goto assign_object;
31341 }
31342 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31343 value = &EG(uninitialized_zval);
31344 goto free_and_exit_assign_obj;
31345 }
31346
31347 assign_object:
31348 zobj = Z_OBJ_P(object);
31349 if (IS_CV == IS_CONST) {
31350 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31351 void **cache_slot = CACHE_ADDR(opline->extended_value);
31352 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31353 zval *property_val;
31354
31355 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31356 property_val = OBJ_PROP(zobj, prop_offset);
31357 if (Z_TYPE_P(property_val) != IS_UNDEF) {
31358 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31359
31360 if (prop_info != NULL) {
31361 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31362 goto free_and_exit_assign_obj;
31363 } else {
31364 fast_assign_obj:
31365 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
31366 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31367 ZVAL_COPY(EX_VAR(opline->result.var), value);
31368 }
31369 goto exit_assign_obj;
31370 }
31371 }
31372 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31373 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31374 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31375 zobj = zend_lazy_object_init(zobj);
31376 if (!zobj) {
31377 value = &EG(uninitialized_zval);
31378 goto free_and_exit_assign_obj;
31379 }
31380 }
31381 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31382 rebuild_object_properties_internal(zobj);
31383 }
31384 if (EXPECTED(zobj->properties != NULL)) {
31385 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31386 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31387 GC_DELREF(zobj->properties);
31388 }
31389 zobj->properties = zend_array_dup(zobj->properties);
31390 }
31391 property_val = zend_hash_find_known_hash(zobj->properties, name);
31392 if (property_val) {
31393 goto fast_assign_obj;
31394 }
31395 }
31396
31397 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31398 if (IS_CONST == IS_CONST) {
31399 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31400 Z_ADDREF_P(value);
31401 }
31402 } else if (IS_CONST != IS_TMP_VAR) {
31403 if (Z_ISREF_P(value)) {
31404 if (IS_CONST == IS_VAR) {
31405 zend_reference *ref = Z_REF_P(value);
31406 if (GC_DELREF(ref) == 0) {
31407 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31408 efree_size(ref, sizeof(zend_reference));
31409 value = &tmp;
31410 } else {
31411 value = Z_REFVAL_P(value);
31412 Z_TRY_ADDREF_P(value);
31413 }
31414 } else {
31415 value = Z_REFVAL_P(value);
31416 Z_TRY_ADDREF_P(value);
31417 }
31418 } else if (IS_CONST == IS_CV) {
31419 Z_TRY_ADDREF_P(value);
31420 }
31421 }
31422 zend_hash_add_new(zobj->properties, name, value);
31423 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31424 ZVAL_COPY(EX_VAR(opline->result.var), value);
31425 }
31426 goto exit_assign_obj;
31427 }
31428 } else {
31429 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31430 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31431 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
31432 property_val = OBJ_PROP(zobj, prop_info->offset);
31433 if (ZEND_TYPE_IS_SET(prop_info->type)) {
31434 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31435 goto free_and_exit_assign_obj;
31436 } else {
31437 goto fast_assign_obj;
31438 }
31439 }
31440 /* Fall through to write_property for hooks. */
31441 }
31442 }
31443 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31444 } else {
31445 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31446 if (UNEXPECTED(!name)) {
31447
31448 UNDEF_RESULT();
31449 goto exit_assign_obj;
31450 }
31451 }
31452
31453 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
31454 ZVAL_DEREF(value);
31455 }
31456
31457 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31458
31459 if (IS_CV != IS_CONST) {
31460 zend_tmp_string_release(tmp_name);
31461 }
31462
31463 free_and_exit_assign_obj:
31464 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31465 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31466 }
31467
31468 exit_assign_obj:
31469 if (garbage) {
31470 GC_DTOR_NO_REF(garbage);
31471 }
31472
31473 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31474 /* assign_obj has two opcodes! */
31475 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31476 }
31477
31478 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31479 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31480 {
31481 USE_OPLINE
31482 zval *object, *value, tmp;
31483 zend_object *zobj;
31484 zend_string *name, *tmp_name;
31485 zend_refcounted *garbage = NULL;
31486
31487 SAVE_OPLINE();
31488 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31489 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31490
31491 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31492 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31493 object = Z_REFVAL_P(object);
31494 goto assign_object;
31495 }
31496 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31497 value = &EG(uninitialized_zval);
31498 goto free_and_exit_assign_obj;
31499 }
31500
31501 assign_object:
31502 zobj = Z_OBJ_P(object);
31503 if (IS_CV == IS_CONST) {
31504 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31505 void **cache_slot = CACHE_ADDR(opline->extended_value);
31506 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31507 zval *property_val;
31508
31509 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31510 property_val = OBJ_PROP(zobj, prop_offset);
31511 if (Z_TYPE_P(property_val) != IS_UNDEF) {
31512 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31513
31514 if (prop_info != NULL) {
31515 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31516 goto free_and_exit_assign_obj;
31517 } else {
31518 fast_assign_obj:
31519 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
31520 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31521 ZVAL_COPY(EX_VAR(opline->result.var), value);
31522 }
31523 goto exit_assign_obj;
31524 }
31525 }
31526 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31527 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31528 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31529 zobj = zend_lazy_object_init(zobj);
31530 if (!zobj) {
31531 value = &EG(uninitialized_zval);
31532 goto free_and_exit_assign_obj;
31533 }
31534 }
31535 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31536 rebuild_object_properties_internal(zobj);
31537 }
31538 if (EXPECTED(zobj->properties != NULL)) {
31539 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31540 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31541 GC_DELREF(zobj->properties);
31542 }
31543 zobj->properties = zend_array_dup(zobj->properties);
31544 }
31545 property_val = zend_hash_find_known_hash(zobj->properties, name);
31546 if (property_val) {
31547 goto fast_assign_obj;
31548 }
31549 }
31550
31551 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31552 if (IS_TMP_VAR == IS_CONST) {
31553 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31554 Z_ADDREF_P(value);
31555 }
31556 } else if (IS_TMP_VAR != IS_TMP_VAR) {
31557 if (Z_ISREF_P(value)) {
31558 if (IS_TMP_VAR == IS_VAR) {
31559 zend_reference *ref = Z_REF_P(value);
31560 if (GC_DELREF(ref) == 0) {
31561 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31562 efree_size(ref, sizeof(zend_reference));
31563 value = &tmp;
31564 } else {
31565 value = Z_REFVAL_P(value);
31566 Z_TRY_ADDREF_P(value);
31567 }
31568 } else {
31569 value = Z_REFVAL_P(value);
31570 Z_TRY_ADDREF_P(value);
31571 }
31572 } else if (IS_TMP_VAR == IS_CV) {
31573 Z_TRY_ADDREF_P(value);
31574 }
31575 }
31576 zend_hash_add_new(zobj->properties, name, value);
31577 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31578 ZVAL_COPY(EX_VAR(opline->result.var), value);
31579 }
31580 goto exit_assign_obj;
31581 }
31582 } else {
31583 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31584 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31585 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
31586 property_val = OBJ_PROP(zobj, prop_info->offset);
31587 if (ZEND_TYPE_IS_SET(prop_info->type)) {
31588 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31589 goto free_and_exit_assign_obj;
31590 } else {
31591 goto fast_assign_obj;
31592 }
31593 }
31594 /* Fall through to write_property for hooks. */
31595 }
31596 }
31597 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31598 } else {
31599 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31600 if (UNEXPECTED(!name)) {
31601 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31602 UNDEF_RESULT();
31603 goto exit_assign_obj;
31604 }
31605 }
31606
31607 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
31608 ZVAL_DEREF(value);
31609 }
31610
31611 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31612
31613 if (IS_CV != IS_CONST) {
31614 zend_tmp_string_release(tmp_name);
31615 }
31616
31617 free_and_exit_assign_obj:
31618 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31619 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31620 }
31621 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31622 exit_assign_obj:
31623 if (garbage) {
31624 GC_DTOR_NO_REF(garbage);
31625 }
31626
31627 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31628 /* assign_obj has two opcodes! */
31629 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31630 }
31631
31632 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31633 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31634 {
31635 USE_OPLINE
31636 zval *object, *value, tmp;
31637 zend_object *zobj;
31638 zend_string *name, *tmp_name;
31639 zend_refcounted *garbage = NULL;
31640
31641 SAVE_OPLINE();
31642 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31643 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31644
31645 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31646 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31647 object = Z_REFVAL_P(object);
31648 goto assign_object;
31649 }
31650 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31651 value = &EG(uninitialized_zval);
31652 goto free_and_exit_assign_obj;
31653 }
31654
31655 assign_object:
31656 zobj = Z_OBJ_P(object);
31657 if (IS_CV == IS_CONST) {
31658 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31659 void **cache_slot = CACHE_ADDR(opline->extended_value);
31660 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31661 zval *property_val;
31662
31663 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31664 property_val = OBJ_PROP(zobj, prop_offset);
31665 if (Z_TYPE_P(property_val) != IS_UNDEF) {
31666 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31667
31668 if (prop_info != NULL) {
31669 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31670 goto free_and_exit_assign_obj;
31671 } else {
31672 fast_assign_obj:
31673 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
31674 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31675 ZVAL_COPY(EX_VAR(opline->result.var), value);
31676 }
31677 goto exit_assign_obj;
31678 }
31679 }
31680 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31681 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31682 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31683 zobj = zend_lazy_object_init(zobj);
31684 if (!zobj) {
31685 value = &EG(uninitialized_zval);
31686 goto free_and_exit_assign_obj;
31687 }
31688 }
31689 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31690 rebuild_object_properties_internal(zobj);
31691 }
31692 if (EXPECTED(zobj->properties != NULL)) {
31693 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31694 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31695 GC_DELREF(zobj->properties);
31696 }
31697 zobj->properties = zend_array_dup(zobj->properties);
31698 }
31699 property_val = zend_hash_find_known_hash(zobj->properties, name);
31700 if (property_val) {
31701 goto fast_assign_obj;
31702 }
31703 }
31704
31705 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31706 if (IS_VAR == IS_CONST) {
31707 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31708 Z_ADDREF_P(value);
31709 }
31710 } else if (IS_VAR != IS_TMP_VAR) {
31711 if (Z_ISREF_P(value)) {
31712 if (IS_VAR == IS_VAR) {
31713 zend_reference *ref = Z_REF_P(value);
31714 if (GC_DELREF(ref) == 0) {
31715 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31716 efree_size(ref, sizeof(zend_reference));
31717 value = &tmp;
31718 } else {
31719 value = Z_REFVAL_P(value);
31720 Z_TRY_ADDREF_P(value);
31721 }
31722 } else {
31723 value = Z_REFVAL_P(value);
31724 Z_TRY_ADDREF_P(value);
31725 }
31726 } else if (IS_VAR == IS_CV) {
31727 Z_TRY_ADDREF_P(value);
31728 }
31729 }
31730 zend_hash_add_new(zobj->properties, name, value);
31731 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31732 ZVAL_COPY(EX_VAR(opline->result.var), value);
31733 }
31734 goto exit_assign_obj;
31735 }
31736 } else {
31737 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31738 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31739 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
31740 property_val = OBJ_PROP(zobj, prop_info->offset);
31741 if (ZEND_TYPE_IS_SET(prop_info->type)) {
31742 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31743 goto free_and_exit_assign_obj;
31744 } else {
31745 goto fast_assign_obj;
31746 }
31747 }
31748 /* Fall through to write_property for hooks. */
31749 }
31750 }
31751 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31752 } else {
31753 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31754 if (UNEXPECTED(!name)) {
31755 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31756 UNDEF_RESULT();
31757 goto exit_assign_obj;
31758 }
31759 }
31760
31761 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
31762 ZVAL_DEREF(value);
31763 }
31764
31765 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31766
31767 if (IS_CV != IS_CONST) {
31768 zend_tmp_string_release(tmp_name);
31769 }
31770
31771 free_and_exit_assign_obj:
31772 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31773 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31774 }
31775 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31776 exit_assign_obj:
31777 if (garbage) {
31778 GC_DTOR_NO_REF(garbage);
31779 }
31780
31781 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31782 /* assign_obj has two opcodes! */
31783 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31784 }
31785
31786 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31787 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31788 {
31789 USE_OPLINE
31790 zval *object, *value, tmp;
31791 zend_object *zobj;
31792 zend_string *name, *tmp_name;
31793 zend_refcounted *garbage = NULL;
31794
31795 SAVE_OPLINE();
31796 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31797 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
31798
31799 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31800 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31801 object = Z_REFVAL_P(object);
31802 goto assign_object;
31803 }
31804 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31805 value = &EG(uninitialized_zval);
31806 goto free_and_exit_assign_obj;
31807 }
31808
31809 assign_object:
31810 zobj = Z_OBJ_P(object);
31811 if (IS_CV == IS_CONST) {
31812 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31813 void **cache_slot = CACHE_ADDR(opline->extended_value);
31814 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31815 zval *property_val;
31816
31817 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31818 property_val = OBJ_PROP(zobj, prop_offset);
31819 if (Z_TYPE_P(property_val) != IS_UNDEF) {
31820 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31821
31822 if (prop_info != NULL) {
31823 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31824 goto free_and_exit_assign_obj;
31825 } else {
31826 fast_assign_obj:
31827 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31828 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31829 ZVAL_COPY(EX_VAR(opline->result.var), value);
31830 }
31831 goto exit_assign_obj;
31832 }
31833 }
31834 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
31835 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31836 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
31837 zobj = zend_lazy_object_init(zobj);
31838 if (!zobj) {
31839 value = &EG(uninitialized_zval);
31840 goto free_and_exit_assign_obj;
31841 }
31842 }
31843 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31844 rebuild_object_properties_internal(zobj);
31845 }
31846 if (EXPECTED(zobj->properties != NULL)) {
31847 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31848 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31849 GC_DELREF(zobj->properties);
31850 }
31851 zobj->properties = zend_array_dup(zobj->properties);
31852 }
31853 property_val = zend_hash_find_known_hash(zobj->properties, name);
31854 if (property_val) {
31855 goto fast_assign_obj;
31856 }
31857 }
31858
31859 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31860 if (IS_CV == IS_CONST) {
31861 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31862 Z_ADDREF_P(value);
31863 }
31864 } else if (IS_CV != IS_TMP_VAR) {
31865 if (Z_ISREF_P(value)) {
31866 if (IS_CV == IS_VAR) {
31867 zend_reference *ref = Z_REF_P(value);
31868 if (GC_DELREF(ref) == 0) {
31869 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31870 efree_size(ref, sizeof(zend_reference));
31871 value = &tmp;
31872 } else {
31873 value = Z_REFVAL_P(value);
31874 Z_TRY_ADDREF_P(value);
31875 }
31876 } else {
31877 value = Z_REFVAL_P(value);
31878 Z_TRY_ADDREF_P(value);
31879 }
31880 } else if (IS_CV == IS_CV) {
31881 Z_TRY_ADDREF_P(value);
31882 }
31883 }
31884 zend_hash_add_new(zobj->properties, name, value);
31885 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31886 ZVAL_COPY(EX_VAR(opline->result.var), value);
31887 }
31888 goto exit_assign_obj;
31889 }
31890 } else {
31891 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
31892 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
31893 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
31894 property_val = OBJ_PROP(zobj, prop_info->offset);
31895 if (ZEND_TYPE_IS_SET(prop_info->type)) {
31896 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31897 goto free_and_exit_assign_obj;
31898 } else {
31899 goto fast_assign_obj;
31900 }
31901 }
31902 /* Fall through to write_property for hooks. */
31903 }
31904 }
31905 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31906 } else {
31907 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31908 if (UNEXPECTED(!name)) {
31909
31910 UNDEF_RESULT();
31911 goto exit_assign_obj;
31912 }
31913 }
31914
31915 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
31916 ZVAL_DEREF(value);
31917 }
31918
31919 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31920
31921 if (IS_CV != IS_CONST) {
31922 zend_tmp_string_release(tmp_name);
31923 }
31924
31925 free_and_exit_assign_obj:
31926 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31927 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31928 }
31929
31930 exit_assign_obj:
31931 if (garbage) {
31932 GC_DTOR_NO_REF(garbage);
31933 }
31934
31935 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31936 /* assign_obj has two opcodes! */
31937 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31938 }
31939
31940 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31941 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31942 {
31943 USE_OPLINE
31944 zval *object_ptr, *orig_object_ptr;
31945 zval *value;
31946 zval *variable_ptr;
31947 zval *dim;
31948 zend_refcounted *garbage = NULL;
31949
31950 SAVE_OPLINE();
31951 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31952
31953 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31954 try_assign_dim_array:
31955 SEPARATE_ARRAY(object_ptr);
31956 if (IS_CV == IS_UNUSED) {
31957 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31958 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
31959 HashTable *ht = Z_ARRVAL_P(object_ptr);
31960 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
31961 GC_ADDREF(ht);
31962 }
31963 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31964 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
31965 zend_array_destroy(ht);
31966 goto assign_dim_error;
31967 }
31968 }
31969 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
31970 ZVAL_DEREF(value);
31971 }
31972 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
31973 if (UNEXPECTED(value == NULL)) {
31974 zend_cannot_add_element();
31975 goto assign_dim_error;
31976 } else if (IS_CONST == IS_CV) {
31977 if (Z_REFCOUNTED_P(value)) {
31978 Z_ADDREF_P(value);
31979 }
31980 } else if (IS_CONST == IS_VAR) {
31981 zval *free_op_data = EX_VAR((opline+1)->op1.var);
31982 if (Z_ISREF_P(free_op_data)) {
31983 if (Z_REFCOUNTED_P(value)) {
31984 Z_ADDREF_P(value);
31985 }
31986 zval_ptr_dtor_nogc(free_op_data);
31987 }
31988 } else if (IS_CONST == IS_CONST) {
31989 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
31990 Z_ADDREF_P(value);
31991 }
31992 }
31993 } else {
31994 dim = EX_VAR(opline->op2.var);
31995 if (IS_CV == IS_CONST) {
31996 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31997 } else {
31998 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31999 }
32000 if (UNEXPECTED(variable_ptr == NULL)) {
32001 goto assign_dim_error;
32002 }
32003 value = RT_CONSTANT((opline+1), (opline+1)->op1);
32004 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
32005 }
32006 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32007 ZVAL_COPY(EX_VAR(opline->result.var), value);
32008 }
32009 if (garbage) {
32010 GC_DTOR_NO_REF(garbage);
32011 }
32012 } else {
32013 if (EXPECTED(Z_ISREF_P(object_ptr))) {
32014 object_ptr = Z_REFVAL_P(object_ptr);
32015 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32016 goto try_assign_dim_array;
32017 }
32018 }
32019 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32020 zend_object *obj = Z_OBJ_P(object_ptr);
32021
32022 GC_ADDREF(obj);
32023 dim = EX_VAR(opline->op2.var);
32024 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32025 dim = ZVAL_UNDEFINED_OP2();
32026 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32027 dim++;
32028 }
32029
32030 value = RT_CONSTANT((opline+1), (opline+1)->op1);
32031 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32032 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32033 } else if (IS_CONST & (IS_CV|IS_VAR)) {
32034 ZVAL_DEREF(value);
32035 }
32036
32037 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32038
32039 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32040 zend_objects_store_del(obj);
32041 }
32042 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32043 if (IS_CV == IS_UNUSED) {
32044 zend_use_new_element_for_string();
32045
32046 UNDEF_RESULT();
32047 } else {
32048 dim = EX_VAR(opline->op2.var);
32049 value = RT_CONSTANT((opline+1), (opline+1)->op1);
32050 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32051
32052 }
32053 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32054 if (Z_ISREF_P(orig_object_ptr)
32055 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32056 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32057 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32058
32059 UNDEF_RESULT();
32060 } else {
32061 HashTable *ht = zend_new_array(8);
32062 uint8_t old_type = Z_TYPE_P(object_ptr);
32063
32064 ZVAL_ARR(object_ptr, ht);
32065 if (UNEXPECTED(old_type == IS_FALSE)) {
32066 GC_ADDREF(ht);
32067 zend_false_to_array_deprecated();
32068 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32069 zend_array_destroy(ht);
32070 goto assign_dim_error;
32071 }
32072 }
32073 goto try_assign_dim_array;
32074 }
32075 } else {
32076 zend_use_scalar_as_array();
32077 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32078 assign_dim_error:
32079
32080 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32081 ZVAL_NULL(EX_VAR(opline->result.var));
32082 }
32083 }
32084 }
32085 if (IS_CV != IS_UNUSED) {
32086
32087 }
32088 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32089 /* assign_dim has two opcodes! */
32090 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32091 }
32092
ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32093 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32094 {
32095 USE_OPLINE
32096 zval *object_ptr, *orig_object_ptr;
32097 zval *value;
32098 zval *variable_ptr;
32099 zval *dim;
32100 zend_refcounted *garbage = NULL;
32101
32102 SAVE_OPLINE();
32103 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32104
32105 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32106 try_assign_dim_array:
32107 SEPARATE_ARRAY(object_ptr);
32108 if (IS_CV == IS_UNUSED) {
32109 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32110 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32111 HashTable *ht = Z_ARRVAL_P(object_ptr);
32112 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32113 GC_ADDREF(ht);
32114 }
32115 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32116 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32117 zend_array_destroy(ht);
32118 goto assign_dim_error;
32119 }
32120 }
32121 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
32122 ZVAL_DEREF(value);
32123 }
32124 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32125 if (UNEXPECTED(value == NULL)) {
32126 zend_cannot_add_element();
32127 goto assign_dim_error;
32128 } else if (IS_TMP_VAR == IS_CV) {
32129 if (Z_REFCOUNTED_P(value)) {
32130 Z_ADDREF_P(value);
32131 }
32132 } else if (IS_TMP_VAR == IS_VAR) {
32133 zval *free_op_data = EX_VAR((opline+1)->op1.var);
32134 if (Z_ISREF_P(free_op_data)) {
32135 if (Z_REFCOUNTED_P(value)) {
32136 Z_ADDREF_P(value);
32137 }
32138 zval_ptr_dtor_nogc(free_op_data);
32139 }
32140 } else if (IS_TMP_VAR == IS_CONST) {
32141 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32142 Z_ADDREF_P(value);
32143 }
32144 }
32145 } else {
32146 dim = EX_VAR(opline->op2.var);
32147 if (IS_CV == IS_CONST) {
32148 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32149 } else {
32150 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32151 }
32152 if (UNEXPECTED(variable_ptr == NULL)) {
32153 goto assign_dim_error;
32154 }
32155 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32156 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
32157 }
32158 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32159 ZVAL_COPY(EX_VAR(opline->result.var), value);
32160 }
32161 if (garbage) {
32162 GC_DTOR_NO_REF(garbage);
32163 }
32164 } else {
32165 if (EXPECTED(Z_ISREF_P(object_ptr))) {
32166 object_ptr = Z_REFVAL_P(object_ptr);
32167 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32168 goto try_assign_dim_array;
32169 }
32170 }
32171 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32172 zend_object *obj = Z_OBJ_P(object_ptr);
32173
32174 GC_ADDREF(obj);
32175 dim = EX_VAR(opline->op2.var);
32176 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32177 dim = ZVAL_UNDEFINED_OP2();
32178 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32179 dim++;
32180 }
32181
32182 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32183 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32184 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32185 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
32186 ZVAL_DEREF(value);
32187 }
32188
32189 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32190
32191 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32192 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32193 zend_objects_store_del(obj);
32194 }
32195 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32196 if (IS_CV == IS_UNUSED) {
32197 zend_use_new_element_for_string();
32198 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32199 UNDEF_RESULT();
32200 } else {
32201 dim = EX_VAR(opline->op2.var);
32202 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
32203 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32204 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32205 }
32206 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32207 if (Z_ISREF_P(orig_object_ptr)
32208 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32209 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32210 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32211 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32212 UNDEF_RESULT();
32213 } else {
32214 HashTable *ht = zend_new_array(8);
32215 uint8_t old_type = Z_TYPE_P(object_ptr);
32216
32217 ZVAL_ARR(object_ptr, ht);
32218 if (UNEXPECTED(old_type == IS_FALSE)) {
32219 GC_ADDREF(ht);
32220 zend_false_to_array_deprecated();
32221 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32222 zend_array_destroy(ht);
32223 goto assign_dim_error;
32224 }
32225 }
32226 goto try_assign_dim_array;
32227 }
32228 } else {
32229 zend_use_scalar_as_array();
32230 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32231 assign_dim_error:
32232 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32233 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32234 ZVAL_NULL(EX_VAR(opline->result.var));
32235 }
32236 }
32237 }
32238 if (IS_CV != IS_UNUSED) {
32239
32240 }
32241 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32242 /* assign_dim has two opcodes! */
32243 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32244 }
32245
ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32246 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32247 {
32248 USE_OPLINE
32249 zval *object_ptr, *orig_object_ptr;
32250 zval *value;
32251 zval *variable_ptr;
32252 zval *dim;
32253 zend_refcounted *garbage = NULL;
32254
32255 SAVE_OPLINE();
32256 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32257
32258 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32259 try_assign_dim_array:
32260 SEPARATE_ARRAY(object_ptr);
32261 if (IS_CV == IS_UNUSED) {
32262 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32263 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32264 HashTable *ht = Z_ARRVAL_P(object_ptr);
32265 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32266 GC_ADDREF(ht);
32267 }
32268 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32269 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32270 zend_array_destroy(ht);
32271 goto assign_dim_error;
32272 }
32273 }
32274 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
32275 ZVAL_DEREF(value);
32276 }
32277 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32278 if (UNEXPECTED(value == NULL)) {
32279 zend_cannot_add_element();
32280 goto assign_dim_error;
32281 } else if (IS_VAR == IS_CV) {
32282 if (Z_REFCOUNTED_P(value)) {
32283 Z_ADDREF_P(value);
32284 }
32285 } else if (IS_VAR == IS_VAR) {
32286 zval *free_op_data = EX_VAR((opline+1)->op1.var);
32287 if (Z_ISREF_P(free_op_data)) {
32288 if (Z_REFCOUNTED_P(value)) {
32289 Z_ADDREF_P(value);
32290 }
32291 zval_ptr_dtor_nogc(free_op_data);
32292 }
32293 } else if (IS_VAR == IS_CONST) {
32294 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32295 Z_ADDREF_P(value);
32296 }
32297 }
32298 } else {
32299 dim = EX_VAR(opline->op2.var);
32300 if (IS_CV == IS_CONST) {
32301 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32302 } else {
32303 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32304 }
32305 if (UNEXPECTED(variable_ptr == NULL)) {
32306 goto assign_dim_error;
32307 }
32308 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32309 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
32310 }
32311 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32312 ZVAL_COPY(EX_VAR(opline->result.var), value);
32313 }
32314 if (garbage) {
32315 GC_DTOR_NO_REF(garbage);
32316 }
32317 } else {
32318 if (EXPECTED(Z_ISREF_P(object_ptr))) {
32319 object_ptr = Z_REFVAL_P(object_ptr);
32320 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32321 goto try_assign_dim_array;
32322 }
32323 }
32324 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32325 zend_object *obj = Z_OBJ_P(object_ptr);
32326
32327 GC_ADDREF(obj);
32328 dim = EX_VAR(opline->op2.var);
32329 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32330 dim = ZVAL_UNDEFINED_OP2();
32331 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32332 dim++;
32333 }
32334
32335 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32336 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32337 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32338 } else if (IS_VAR & (IS_CV|IS_VAR)) {
32339 ZVAL_DEREF(value);
32340 }
32341
32342 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32343
32344 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32345 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32346 zend_objects_store_del(obj);
32347 }
32348 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32349 if (IS_CV == IS_UNUSED) {
32350 zend_use_new_element_for_string();
32351 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32352 UNDEF_RESULT();
32353 } else {
32354 dim = EX_VAR(opline->op2.var);
32355 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32356 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32357 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32358 }
32359 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32360 if (Z_ISREF_P(orig_object_ptr)
32361 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32362 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32363 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32364 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32365 UNDEF_RESULT();
32366 } else {
32367 HashTable *ht = zend_new_array(8);
32368 uint8_t old_type = Z_TYPE_P(object_ptr);
32369
32370 ZVAL_ARR(object_ptr, ht);
32371 if (UNEXPECTED(old_type == IS_FALSE)) {
32372 GC_ADDREF(ht);
32373 zend_false_to_array_deprecated();
32374 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32375 zend_array_destroy(ht);
32376 goto assign_dim_error;
32377 }
32378 }
32379 goto try_assign_dim_array;
32380 }
32381 } else {
32382 zend_use_scalar_as_array();
32383 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32384 assign_dim_error:
32385 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32386 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32387 ZVAL_NULL(EX_VAR(opline->result.var));
32388 }
32389 }
32390 }
32391 if (IS_CV != IS_UNUSED) {
32392
32393 }
32394 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32395 /* assign_dim has two opcodes! */
32396 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32397 }
32398
ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32399 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32400 {
32401 USE_OPLINE
32402 zval *object_ptr, *orig_object_ptr;
32403 zval *value;
32404 zval *variable_ptr;
32405 zval *dim;
32406 zend_refcounted *garbage = NULL;
32407
32408 SAVE_OPLINE();
32409 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32410
32411 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32412 try_assign_dim_array:
32413 SEPARATE_ARRAY(object_ptr);
32414 if (IS_CV == IS_UNUSED) {
32415 value = EX_VAR((opline+1)->op1.var);
32416 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
32417 HashTable *ht = Z_ARRVAL_P(object_ptr);
32418 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
32419 GC_ADDREF(ht);
32420 }
32421 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32422 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
32423 zend_array_destroy(ht);
32424 goto assign_dim_error;
32425 }
32426 }
32427 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
32428 ZVAL_DEREF(value);
32429 }
32430 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
32431 if (UNEXPECTED(value == NULL)) {
32432 zend_cannot_add_element();
32433 goto assign_dim_error;
32434 } else if (IS_CV == IS_CV) {
32435 if (Z_REFCOUNTED_P(value)) {
32436 Z_ADDREF_P(value);
32437 }
32438 } else if (IS_CV == IS_VAR) {
32439 zval *free_op_data = EX_VAR((opline+1)->op1.var);
32440 if (Z_ISREF_P(free_op_data)) {
32441 if (Z_REFCOUNTED_P(value)) {
32442 Z_ADDREF_P(value);
32443 }
32444 zval_ptr_dtor_nogc(free_op_data);
32445 }
32446 } else if (IS_CV == IS_CONST) {
32447 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
32448 Z_ADDREF_P(value);
32449 }
32450 }
32451 } else {
32452 dim = EX_VAR(opline->op2.var);
32453 if (IS_CV == IS_CONST) {
32454 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32455 } else {
32456 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
32457 }
32458 if (UNEXPECTED(variable_ptr == NULL)) {
32459 goto assign_dim_error;
32460 }
32461 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
32462 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32463 }
32464 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32465 ZVAL_COPY(EX_VAR(opline->result.var), value);
32466 }
32467 if (garbage) {
32468 GC_DTOR_NO_REF(garbage);
32469 }
32470 } else {
32471 if (EXPECTED(Z_ISREF_P(object_ptr))) {
32472 object_ptr = Z_REFVAL_P(object_ptr);
32473 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
32474 goto try_assign_dim_array;
32475 }
32476 }
32477 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
32478 zend_object *obj = Z_OBJ_P(object_ptr);
32479
32480 GC_ADDREF(obj);
32481 dim = EX_VAR(opline->op2.var);
32482 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
32483 dim = ZVAL_UNDEFINED_OP2();
32484 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
32485 dim++;
32486 }
32487
32488 value = EX_VAR((opline+1)->op1.var);
32489 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
32490 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
32491 } else if (IS_CV & (IS_CV|IS_VAR)) {
32492 ZVAL_DEREF(value);
32493 }
32494
32495 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
32496
32497 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
32498 zend_objects_store_del(obj);
32499 }
32500 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
32501 if (IS_CV == IS_UNUSED) {
32502 zend_use_new_element_for_string();
32503
32504 UNDEF_RESULT();
32505 } else {
32506 dim = EX_VAR(opline->op2.var);
32507 value = EX_VAR((opline+1)->op1.var);
32508 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
32509
32510 }
32511 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
32512 if (Z_ISREF_P(orig_object_ptr)
32513 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
32514 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
32515 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32516
32517 UNDEF_RESULT();
32518 } else {
32519 HashTable *ht = zend_new_array(8);
32520 uint8_t old_type = Z_TYPE_P(object_ptr);
32521
32522 ZVAL_ARR(object_ptr, ht);
32523 if (UNEXPECTED(old_type == IS_FALSE)) {
32524 GC_ADDREF(ht);
32525 zend_false_to_array_deprecated();
32526 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
32527 zend_array_destroy(ht);
32528 goto assign_dim_error;
32529 }
32530 }
32531 goto try_assign_dim_array;
32532 }
32533 } else {
32534 zend_use_scalar_as_array();
32535 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32536 assign_dim_error:
32537
32538 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32539 ZVAL_NULL(EX_VAR(opline->result.var));
32540 }
32541 }
32542 }
32543 if (IS_CV != IS_UNUSED) {
32544
32545 }
32546 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32547 /* assign_dim has two opcodes! */
32548 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32549 }
32550
ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32551 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32552 {
32553 USE_OPLINE
32554 zval *value;
32555 zval *variable_ptr;
32556
32557 SAVE_OPLINE();
32558 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32559 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32560
32561 if (0 || UNEXPECTED(0)) {
32562 zend_refcounted *garbage = NULL;
32563
32564 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32565 if (UNEXPECTED(0)) {
32566 ZVAL_COPY(EX_VAR(opline->result.var), value);
32567 }
32568 if (garbage) {
32569 GC_DTOR_NO_REF(garbage);
32570 }
32571 } else {
32572 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32573 }
32574 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32575 /* zend_assign_to_variable() always takes care of op2, never free it! */
32576
32577 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32578 }
32579
ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32580 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32581 {
32582 USE_OPLINE
32583 zval *value;
32584 zval *variable_ptr;
32585
32586 SAVE_OPLINE();
32587 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32588 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32589
32590 if (0 || UNEXPECTED(1)) {
32591 zend_refcounted *garbage = NULL;
32592
32593 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
32594 if (UNEXPECTED(1)) {
32595 ZVAL_COPY(EX_VAR(opline->result.var), value);
32596 }
32597 if (garbage) {
32598 GC_DTOR_NO_REF(garbage);
32599 }
32600 } else {
32601 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32602 }
32603 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32604 /* zend_assign_to_variable() always takes care of op2, never free it! */
32605
32606 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32607 }
32608
ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32609 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32610 {
32611 USE_OPLINE
32612 zval *variable_ptr;
32613 zval *value_ptr;
32614 zend_refcounted *garbage = NULL;
32615
32616 SAVE_OPLINE();
32617 value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
32618 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32619
32620 if (IS_VAR == IS_VAR &&
32621 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
32622
32623 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
32624 variable_ptr = &EG(uninitialized_zval);
32625 } else if (IS_CV == IS_VAR &&
32626 opline->extended_value == ZEND_RETURNS_FUNCTION &&
32627 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
32628
32629 variable_ptr = zend_wrong_assign_to_variable_reference(
32630 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
32631 } else {
32632 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
32633 }
32634
32635 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32636 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
32637 }
32638
32639 if (garbage) {
32640 GC_DTOR(garbage);
32641 }
32642
32643 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32644 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32645 }
32646
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32647 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32648 {
32649 USE_OPLINE
32650 zval *property, *container, *value_ptr;
32651
32652 SAVE_OPLINE();
32653
32654 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32655 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32656
32657 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
32658
32659 if (1) {
32660 if (IS_VAR == IS_UNUSED) {
32661 if (IS_CV == IS_CONST) {
32662 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32663 } else {
32664 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32665 }
32666 } else {
32667 if (IS_CV == IS_CONST) {
32668 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32669 } else {
32670 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32671 }
32672 }
32673 } else {
32674 zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32675 }
32676
32677 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32678
32679 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
32680 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32681 }
32682
32683 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32684 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32685 {
32686 USE_OPLINE
32687 zval *property, *container, *value_ptr;
32688
32689 SAVE_OPLINE();
32690
32691 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32692 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32693
32694 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
32695
32696 if (1) {
32697 if (IS_VAR == IS_UNUSED) {
32698 if (IS_CV == IS_CONST) {
32699 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32700 } else {
32701 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32702 }
32703 } else {
32704 if (IS_CV == IS_CONST) {
32705 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32706 } else {
32707 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32708 }
32709 }
32710 } else {
32711 zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
32712 }
32713
32714 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32715
32716
32717 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32718 }
32719
32720 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32721 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32722 {
32723 USE_OPLINE
32724 zval *function_name;
32725 zend_class_entry *ce;
32726 uint32_t call_info;
32727 zend_function *fbc;
32728 zend_execute_data *call;
32729
32730 SAVE_OPLINE();
32731
32732 if (IS_VAR == IS_CONST) {
32733 /* no function found. try a static method in class */
32734 ce = CACHED_PTR(opline->result.num);
32735 if (UNEXPECTED(ce == NULL)) {
32736 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);
32737 if (UNEXPECTED(ce == NULL)) {
32738
32739 HANDLE_EXCEPTION();
32740 }
32741 if (IS_CV != IS_CONST) {
32742 CACHE_PTR(opline->result.num, ce);
32743 }
32744 }
32745 } else if (IS_VAR == IS_UNUSED) {
32746 ce = zend_fetch_class(NULL, opline->op1.num);
32747 if (UNEXPECTED(ce == NULL)) {
32748
32749 HANDLE_EXCEPTION();
32750 }
32751 } else {
32752 ce = Z_CE_P(EX_VAR(opline->op1.var));
32753 }
32754
32755 if (IS_VAR == IS_CONST &&
32756 IS_CV == IS_CONST &&
32757 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
32758 /* nothing to do */
32759 } else if (IS_VAR != IS_CONST &&
32760 IS_CV == IS_CONST &&
32761 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
32762 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
32763 } else if (IS_CV != IS_UNUSED) {
32764 function_name = EX_VAR(opline->op2.var);
32765 if (IS_CV != IS_CONST) {
32766 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
32767 do {
32768 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
32769 function_name = Z_REFVAL_P(function_name);
32770 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
32771 break;
32772 }
32773 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
32774 ZVAL_UNDEFINED_OP2();
32775 if (UNEXPECTED(EG(exception) != NULL)) {
32776 HANDLE_EXCEPTION();
32777 }
32778 }
32779 zend_throw_error(NULL, "Method name must be a string");
32780
32781 HANDLE_EXCEPTION();
32782 } while (0);
32783 }
32784 }
32785
32786 if (ce->get_static_method) {
32787 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
32788 } else {
32789 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
32790 }
32791 if (UNEXPECTED(fbc == NULL)) {
32792 if (EXPECTED(!EG(exception))) {
32793 zend_undefined_method(ce, Z_STR_P(function_name));
32794 }
32795
32796 HANDLE_EXCEPTION();
32797 }
32798 if (IS_CV == IS_CONST &&
32799 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
32800 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
32801 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
32802 }
32803 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32804 init_func_run_time_cache(&fbc->op_array);
32805 }
32806 if (IS_CV != IS_CONST) {
32807
32808 }
32809 } else {
32810 if (UNEXPECTED(ce->constructor == NULL)) {
32811 zend_throw_error(NULL, "Cannot call constructor");
32812 HANDLE_EXCEPTION();
32813 }
32814 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
32815 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
32816 HANDLE_EXCEPTION();
32817 }
32818 fbc = ce->constructor;
32819 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32820 init_func_run_time_cache(&fbc->op_array);
32821 }
32822 }
32823
32824 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
32825 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
32826 ce = (zend_class_entry*)Z_OBJ(EX(This));
32827 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
32828 } else {
32829 zend_non_static_method_call(fbc);
32830 HANDLE_EXCEPTION();
32831 }
32832 } else {
32833 /* previous opcode is ZEND_FETCH_CLASS */
32834 if (IS_VAR == IS_UNUSED
32835 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
32836 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
32837 if (Z_TYPE(EX(This)) == IS_OBJECT) {
32838 ce = Z_OBJCE(EX(This));
32839 } else {
32840 ce = Z_CE(EX(This));
32841 }
32842 }
32843 call_info = ZEND_CALL_NESTED_FUNCTION;
32844 }
32845
32846 call = zend_vm_stack_push_call_frame(call_info,
32847 fbc, opline->extended_value, ce);
32848 call->prev_execute_data = EX(call);
32849 EX(call) = call;
32850
32851 ZEND_VM_NEXT_OPCODE();
32852 }
32853
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32854 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32855 {
32856 USE_OPLINE
32857 zval *expr_ptr, new_expr;
32858
32859 SAVE_OPLINE();
32860 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
32861 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
32862 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32863 if (Z_ISREF_P(expr_ptr)) {
32864 Z_ADDREF_P(expr_ptr);
32865 } else {
32866 ZVAL_MAKE_REF_EX(expr_ptr, 2);
32867 }
32868 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32869 } else {
32870 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32871 if (IS_VAR == IS_TMP_VAR) {
32872 /* pass */
32873 } else if (IS_VAR == IS_CONST) {
32874 Z_TRY_ADDREF_P(expr_ptr);
32875 } else if (IS_VAR == IS_CV) {
32876 ZVAL_DEREF(expr_ptr);
32877 Z_TRY_ADDREF_P(expr_ptr);
32878 } else /* if (IS_VAR == IS_VAR) */ {
32879 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
32880 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
32881
32882 expr_ptr = Z_REFVAL_P(expr_ptr);
32883 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
32884 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
32885 expr_ptr = &new_expr;
32886 efree_size(ref, sizeof(zend_reference));
32887 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
32888 Z_ADDREF_P(expr_ptr);
32889 }
32890 }
32891 }
32892 }
32893
32894 if (IS_CV != IS_UNUSED) {
32895 zval *offset = EX_VAR(opline->op2.var);
32896 zend_string *str;
32897 zend_ulong hval;
32898
32899 add_again:
32900 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
32901 str = Z_STR_P(offset);
32902 if (IS_CV != IS_CONST) {
32903 if (ZEND_HANDLE_NUMERIC(str, hval)) {
32904 goto num_index;
32905 }
32906 }
32907 str_index:
32908 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
32909 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
32910 hval = Z_LVAL_P(offset);
32911 num_index:
32912 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
32913 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
32914 offset = Z_REFVAL_P(offset);
32915 goto add_again;
32916 } else if (Z_TYPE_P(offset) == IS_NULL) {
32917 str = ZSTR_EMPTY_ALLOC();
32918 goto str_index;
32919 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
32920 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
32921 goto num_index;
32922 } else if (Z_TYPE_P(offset) == IS_FALSE) {
32923 hval = 0;
32924 goto num_index;
32925 } else if (Z_TYPE_P(offset) == IS_TRUE) {
32926 hval = 1;
32927 goto num_index;
32928 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
32929 zend_use_resource_as_offset(offset);
32930 hval = Z_RES_HANDLE_P(offset);
32931 goto num_index;
32932 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
32933 ZVAL_UNDEFINED_OP2();
32934 str = ZSTR_EMPTY_ALLOC();
32935 goto str_index;
32936 } else {
32937 zend_illegal_array_offset_access(offset);
32938 zval_ptr_dtor_nogc(expr_ptr);
32939 }
32940
32941 } else {
32942 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
32943 zend_cannot_add_element();
32944 zval_ptr_dtor_nogc(expr_ptr);
32945 }
32946 }
32947 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32948 }
32949
ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32950 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32951 {
32952 zval *array;
32953 uint32_t size;
32954 USE_OPLINE
32955
32956 array = EX_VAR(opline->result.var);
32957 if (IS_VAR != IS_UNUSED) {
32958 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
32959 ZVAL_ARR(array, zend_new_array(size));
32960 /* Explicitly initialize array as not-packed if flag is set */
32961 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
32962 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
32963 }
32964 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
32965 } else {
32966 ZVAL_ARR(array, zend_new_array(0));
32967 ZEND_VM_NEXT_OPCODE();
32968 }
32969 }
32970
ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32971 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32972 {
32973 USE_OPLINE
32974 zval *container;
32975 zval *offset;
32976 zend_ulong hval;
32977 zend_string *key;
32978
32979 SAVE_OPLINE();
32980 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32981 offset = EX_VAR(opline->op2.var);
32982
32983 do {
32984 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
32985 HashTable *ht;
32986
32987 unset_dim_array:
32988 SEPARATE_ARRAY(container);
32989 ht = Z_ARRVAL_P(container);
32990 offset_again:
32991 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
32992 key = Z_STR_P(offset);
32993 if (IS_CV != IS_CONST) {
32994 if (ZEND_HANDLE_NUMERIC(key, hval)) {
32995 goto num_index_dim;
32996 }
32997 }
32998 str_index_dim:
32999 ZEND_ASSERT(ht != &EG(symbol_table));
33000 zend_hash_del(ht, key);
33001 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
33002 hval = Z_LVAL_P(offset);
33003 num_index_dim:
33004 zend_hash_index_del(ht, hval);
33005 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
33006 offset = Z_REFVAL_P(offset);
33007 goto offset_again;
33008 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
33009 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
33010 goto num_index_dim;
33011 } else if (Z_TYPE_P(offset) == IS_NULL) {
33012 key = ZSTR_EMPTY_ALLOC();
33013 goto str_index_dim;
33014 } else if (Z_TYPE_P(offset) == IS_FALSE) {
33015 hval = 0;
33016 goto num_index_dim;
33017 } else if (Z_TYPE_P(offset) == IS_TRUE) {
33018 hval = 1;
33019 goto num_index_dim;
33020 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
33021 zend_use_resource_as_offset(offset);
33022 hval = Z_RES_HANDLE_P(offset);
33023 goto num_index_dim;
33024 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
33025 ZVAL_UNDEFINED_OP2();
33026 key = ZSTR_EMPTY_ALLOC();
33027 goto str_index_dim;
33028 } else {
33029 zend_illegal_array_offset_unset(offset);
33030 }
33031 break;
33032 } else if (Z_ISREF_P(container)) {
33033 container = Z_REFVAL_P(container);
33034 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
33035 goto unset_dim_array;
33036 }
33037 }
33038 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33039 container = ZVAL_UNDEFINED_OP1();
33040 }
33041 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
33042 offset = ZVAL_UNDEFINED_OP2();
33043 }
33044 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33045 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
33046 offset++;
33047 }
33048 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
33049 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
33050 zend_throw_error(NULL, "Cannot unset string offsets");
33051 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
33052 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
33053 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
33054 zend_false_to_array_deprecated();
33055 }
33056 } while (0);
33057
33058 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33059 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33060 }
33061
ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33062 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33063 {
33064 USE_OPLINE
33065 zval *container;
33066 zval *offset;
33067 zend_string *name, *tmp_name;
33068
33069 SAVE_OPLINE();
33070 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33071 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
33072
33073 do {
33074 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
33075 if (Z_ISREF_P(container)) {
33076 container = Z_REFVAL_P(container);
33077 if (Z_TYPE_P(container) != IS_OBJECT) {
33078 if (IS_VAR == IS_CV
33079 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33080 ZVAL_UNDEFINED_OP1();
33081 }
33082 break;
33083 }
33084 } else {
33085 break;
33086 }
33087 }
33088 if (IS_CV == IS_CONST) {
33089 name = Z_STR_P(offset);
33090 } else {
33091 name = zval_try_get_tmp_string(offset, &tmp_name);
33092 if (UNEXPECTED(!name)) {
33093 break;
33094 }
33095 }
33096 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
33097 if (IS_CV != IS_CONST) {
33098 zend_tmp_string_release(tmp_name);
33099 }
33100 } while (0);
33101
33102 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33103 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33104 }
33105
ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33106 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33107 {
33108 USE_OPLINE
33109
33110 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
33111
33112 SAVE_OPLINE();
33113 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
33114 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33115 }
33116
33117 /* Destroy the previously yielded value */
33118 zval_ptr_dtor(&generator->value);
33119
33120 /* Destroy the previously yielded key */
33121 zval_ptr_dtor(&generator->key);
33122
33123 /* Set the new yielded value */
33124 if (IS_VAR != IS_UNUSED) {
33125 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
33126 /* Constants and temporary variables aren't yieldable by reference,
33127 * but we still allow them with a notice. */
33128 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
33129 zval *value;
33130
33131 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
33132
33133 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33134 ZVAL_COPY_VALUE(&generator->value, value);
33135 if (IS_VAR == IS_CONST) {
33136 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
33137 Z_ADDREF(generator->value);
33138 }
33139 }
33140 } else {
33141 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33142
33143 /* If a function call result is yielded and the function did
33144 * not return by reference we throw a notice. */
33145 do {
33146 if (IS_VAR == IS_VAR) {
33147 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
33148 if (opline->extended_value == ZEND_RETURNS_FUNCTION
33149 && !Z_ISREF_P(value_ptr)) {
33150 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
33151 ZVAL_COPY(&generator->value, value_ptr);
33152 break;
33153 }
33154 }
33155 if (Z_ISREF_P(value_ptr)) {
33156 Z_ADDREF_P(value_ptr);
33157 } else {
33158 ZVAL_MAKE_REF_EX(value_ptr, 2);
33159 }
33160 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
33161 } while (0);
33162
33163 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33164 }
33165 } else {
33166 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
33167
33168 /* Consts, temporary variables and references need copying */
33169 if (IS_VAR == IS_CONST) {
33170 ZVAL_COPY_VALUE(&generator->value, value);
33171 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
33172 Z_ADDREF(generator->value);
33173 }
33174 } else if (IS_VAR == IS_TMP_VAR) {
33175 ZVAL_COPY_VALUE(&generator->value, value);
33176 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
33177 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
33178 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
33179 } else {
33180 ZVAL_COPY_VALUE(&generator->value, value);
33181 if (IS_VAR == IS_CV) {
33182 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
33183 }
33184 }
33185 }
33186 } else {
33187 /* If no value was specified yield null */
33188 ZVAL_NULL(&generator->value);
33189 }
33190
33191 /* Set the new yielded key */
33192 if (IS_CV != IS_UNUSED) {
33193 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
33194 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
33195 key = Z_REFVAL_P(key);
33196 }
33197 ZVAL_COPY(&generator->key, key);
33198
33199 if (Z_TYPE(generator->key) == IS_LONG
33200 && Z_LVAL(generator->key) > generator->largest_used_integer_key
33201 ) {
33202 generator->largest_used_integer_key = Z_LVAL(generator->key);
33203 }
33204 } else {
33205 /* If no key was specified we use auto-increment keys */
33206 generator->largest_used_integer_key++;
33207 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
33208 }
33209
33210 if (RETURN_VALUE_USED(opline)) {
33211 /* If the return value of yield is used set the send
33212 * target and initialize it to NULL */
33213 generator->send_target = EX_VAR(opline->result.var);
33214 ZVAL_NULL(generator->send_target);
33215 } else {
33216 generator->send_target = NULL;
33217 }
33218
33219 /* The GOTO VM uses a local opline variable. We need to set the opline
33220 * variable in execute_data so we don't resume at an old position. */
33221 SAVE_OPLINE();
33222
33223 ZEND_VM_RETURN();
33224 }
33225
ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33226 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33227 {
33228 USE_OPLINE
33229 zval *array;
33230 zval *value, *variable_ptr;
33231 uint32_t value_type;
33232 HashTable *fe_ht;
33233 HashPosition pos;
33234
33235 array = EX_VAR(opline->op1.var);
33236 SAVE_OPLINE();
33237 fe_ht = Z_ARRVAL_P(array);
33238 pos = Z_FE_POS_P(array);
33239 if (HT_IS_PACKED(fe_ht)) {
33240 value = fe_ht->arPacked + pos;
33241 while (1) {
33242 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33243 /* reached end of iteration */
33244 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33245 ZEND_VM_CONTINUE();
33246 }
33247 value_type = Z_TYPE_INFO_P(value);
33248 ZEND_ASSERT(value_type != IS_INDIRECT);
33249 if (EXPECTED(value_type != IS_UNDEF)) {
33250 break;
33251 }
33252 pos++;
33253 value++;
33254 }
33255 Z_FE_POS_P(array) = pos + 1;
33256 if (0) {
33257 ZVAL_LONG(EX_VAR(opline->result.var), pos);
33258 }
33259 } else {
33260 Bucket *p;
33261
33262 p = fe_ht->arData + pos;
33263 while (1) {
33264 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33265 /* reached end of iteration */
33266 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33267 ZEND_VM_CONTINUE();
33268 }
33269 pos++;
33270 value = &p->val;
33271 value_type = Z_TYPE_INFO_P(value);
33272 ZEND_ASSERT(value_type != IS_INDIRECT);
33273 if (EXPECTED(value_type != IS_UNDEF)) {
33274 break;
33275 }
33276 p++;
33277 }
33278 Z_FE_POS_P(array) = pos;
33279 if (0) {
33280 if (!p->key) {
33281 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
33282 } else {
33283 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
33284 }
33285 }
33286 }
33287
33288 variable_ptr = EX_VAR(opline->op2.var);
33289 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
33290 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33291 }
33292
33293
ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33294 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33295 {
33296 USE_OPLINE
33297 zval *array;
33298 zval *value, *variable_ptr;
33299 uint32_t value_type;
33300 HashTable *fe_ht;
33301 HashPosition pos;
33302
33303 array = EX_VAR(opline->op1.var);
33304 SAVE_OPLINE();
33305 fe_ht = Z_ARRVAL_P(array);
33306 pos = Z_FE_POS_P(array);
33307 if (HT_IS_PACKED(fe_ht)) {
33308 value = fe_ht->arPacked + pos;
33309 while (1) {
33310 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33311 /* reached end of iteration */
33312 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33313 ZEND_VM_CONTINUE();
33314 }
33315 value_type = Z_TYPE_INFO_P(value);
33316 ZEND_ASSERT(value_type != IS_INDIRECT);
33317 if (EXPECTED(value_type != IS_UNDEF)) {
33318 break;
33319 }
33320 pos++;
33321 value++;
33322 }
33323 Z_FE_POS_P(array) = pos + 1;
33324 if (1) {
33325 ZVAL_LONG(EX_VAR(opline->result.var), pos);
33326 }
33327 } else {
33328 Bucket *p;
33329
33330 p = fe_ht->arData + pos;
33331 while (1) {
33332 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
33333 /* reached end of iteration */
33334 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
33335 ZEND_VM_CONTINUE();
33336 }
33337 pos++;
33338 value = &p->val;
33339 value_type = Z_TYPE_INFO_P(value);
33340 ZEND_ASSERT(value_type != IS_INDIRECT);
33341 if (EXPECTED(value_type != IS_UNDEF)) {
33342 break;
33343 }
33344 p++;
33345 }
33346 Z_FE_POS_P(array) = pos;
33347 if (1) {
33348 if (!p->key) {
33349 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
33350 } else {
33351 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
33352 }
33353 }
33354 }
33355
33356 variable_ptr = EX_VAR(opline->op2.var);
33357 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
33358 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33359 }
33360
33361
ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33362 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33363 {
33364 USE_OPLINE
33365 zval *obj;
33366 zend_object *zobj;
33367 zend_class_entry *ce, *scope;
33368 zend_function *clone;
33369 zend_object_clone_obj_t clone_call;
33370
33371 SAVE_OPLINE();
33372 obj = &EX(This);
33373
33374 do {
33375 if (IS_UNUSED == IS_CONST ||
33376 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
33377 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
33378 obj = Z_REFVAL_P(obj);
33379 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
33380 break;
33381 }
33382 }
33383 ZVAL_UNDEF(EX_VAR(opline->result.var));
33384 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
33385 ZVAL_UNDEFINED_OP1();
33386 if (UNEXPECTED(EG(exception) != NULL)) {
33387 HANDLE_EXCEPTION();
33388 }
33389 }
33390 zend_throw_error(NULL, "__clone method called on non-object");
33391
33392 HANDLE_EXCEPTION();
33393 }
33394 } while (0);
33395
33396 zobj = Z_OBJ_P(obj);
33397 ce = zobj->ce;
33398 clone = ce->clone;
33399 clone_call = zobj->handlers->clone_obj;
33400 if (UNEXPECTED(clone_call == NULL)) {
33401 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
33402
33403 ZVAL_UNDEF(EX_VAR(opline->result.var));
33404 HANDLE_EXCEPTION();
33405 }
33406
33407 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
33408 scope = EX(func)->op_array.scope;
33409 if (clone->common.scope != scope) {
33410 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
33411 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
33412 zend_wrong_clone_call(clone, scope);
33413
33414 ZVAL_UNDEF(EX_VAR(opline->result.var));
33415 HANDLE_EXCEPTION();
33416 }
33417 }
33418 }
33419
33420 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
33421
33422 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33423 }
33424
ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33425 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33426 {
33427 uint32_t fetch_type;
33428 zend_class_entry *called_scope, *scope;
33429 USE_OPLINE
33430
33431 if (IS_UNUSED != IS_UNUSED) {
33432 SAVE_OPLINE();
33433 zval *op = NULL;
33434 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
33435 ZVAL_DEREF(op);
33436 if (Z_TYPE_P(op) != IS_OBJECT) {
33437 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
33438 ZVAL_UNDEF(EX_VAR(opline->result.var));
33439
33440 HANDLE_EXCEPTION();
33441 }
33442 }
33443
33444 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
33445
33446 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33447 }
33448
33449 fetch_type = opline->op1.num;
33450 scope = EX(func)->op_array.scope;
33451 if (UNEXPECTED(scope == NULL)) {
33452 SAVE_OPLINE();
33453 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
33454 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
33455 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
33456 ZVAL_UNDEF(EX_VAR(opline->result.var));
33457 HANDLE_EXCEPTION();
33458 }
33459
33460 switch (fetch_type) {
33461 case ZEND_FETCH_CLASS_SELF:
33462 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
33463 break;
33464 case ZEND_FETCH_CLASS_PARENT:
33465 if (UNEXPECTED(scope->parent == NULL)) {
33466 SAVE_OPLINE();
33467 zend_throw_error(NULL,
33468 "Cannot use \"parent\" when current class scope has no parent");
33469 ZVAL_UNDEF(EX_VAR(opline->result.var));
33470 HANDLE_EXCEPTION();
33471 }
33472 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
33473 break;
33474 case ZEND_FETCH_CLASS_STATIC:
33475 if (Z_TYPE(EX(This)) == IS_OBJECT) {
33476 called_scope = Z_OBJCE(EX(This));
33477 } else {
33478 called_scope = Z_CE(EX(This));
33479 }
33480 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
33481 break;
33482 EMPTY_SWITCH_DEFAULT_CASE()
33483 }
33484 ZEND_VM_NEXT_OPCODE();
33485 }
33486
ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33487 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33488 {
33489 USE_OPLINE
33490 zval *object;
33491 zval *property;
33492 zval *value;
33493 zval *zptr;
33494 void *_cache_slot[3] = {0};
33495 void **cache_slot;
33496 zend_property_info *prop_info;
33497 zend_object *zobj;
33498 zend_string *name, *tmp_name;
33499
33500 SAVE_OPLINE();
33501 object = &EX(This);
33502 property = RT_CONSTANT(opline, opline->op2);
33503
33504 do {
33505 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
33506
33507 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33508 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33509 object = Z_REFVAL_P(object);
33510 goto assign_op_object;
33511 }
33512 if (IS_UNUSED == IS_CV
33513 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33514 ZVAL_UNDEFINED_OP1();
33515 }
33516 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33517 break;
33518 }
33519
33520 assign_op_object:
33521 /* here we are sure we are dealing with an object */
33522 zobj = Z_OBJ_P(object);
33523 if (IS_CONST == IS_CONST) {
33524 name = Z_STR_P(property);
33525 } else {
33526 name = zval_try_get_tmp_string(property, &tmp_name);
33527 if (UNEXPECTED(!name)) {
33528 UNDEF_RESULT();
33529 break;
33530 }
33531 }
33532 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
33533 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33534 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33535 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33536 ZVAL_NULL(EX_VAR(opline->result.var));
33537 }
33538 } else {
33539 zend_reference *ref;
33540
33541 do {
33542 if (UNEXPECTED(Z_ISREF_P(zptr))) {
33543 ref = Z_REF_P(zptr);
33544 zptr = Z_REFVAL_P(zptr);
33545 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
33546 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
33547 break;
33548 }
33549 }
33550
33551 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
33552 if (prop_info) {
33553 /* special case for typed properties */
33554 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
33555 } else {
33556 zend_binary_op(zptr, zptr, value OPLINE_CC);
33557 }
33558 } while (0);
33559
33560 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33561 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
33562 }
33563 }
33564 } else {
33565 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
33566 }
33567 if (IS_CONST != IS_CONST) {
33568 zend_tmp_string_release(tmp_name);
33569 }
33570 } while (0);
33571
33572 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
33573
33574
33575 /* assign_obj has two opcodes! */
33576 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33577 }
33578
33579 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33580 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33581 {
33582 USE_OPLINE
33583 zval *object;
33584 zval *property;
33585 zval *zptr;
33586 void *_cache_slot[3] = {0};
33587 void **cache_slot;
33588 zend_property_info *prop_info;
33589 zend_object *zobj;
33590 zend_string *name, *tmp_name;
33591
33592 SAVE_OPLINE();
33593 object = &EX(This);
33594 property = RT_CONSTANT(opline, opline->op2);
33595
33596 do {
33597 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33598 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33599 object = Z_REFVAL_P(object);
33600 goto pre_incdec_object;
33601 }
33602 if (IS_UNUSED == IS_CV
33603 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33604 ZVAL_UNDEFINED_OP1();
33605 }
33606 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33607 break;
33608 }
33609
33610 pre_incdec_object:
33611 /* here we are sure we are dealing with an object */
33612 zobj = Z_OBJ_P(object);
33613 if (IS_CONST == IS_CONST) {
33614 name = Z_STR_P(property);
33615 } else {
33616 name = zval_try_get_tmp_string(property, &tmp_name);
33617 if (UNEXPECTED(!name)) {
33618 UNDEF_RESULT();
33619 break;
33620 }
33621 }
33622 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
33623 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33624 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33625 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33626 ZVAL_NULL(EX_VAR(opline->result.var));
33627 }
33628 } else {
33629 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
33630 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
33631 }
33632 } else {
33633 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
33634 }
33635 if (IS_CONST != IS_CONST) {
33636 zend_tmp_string_release(tmp_name);
33637 }
33638 } while (0);
33639
33640
33641 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33642 }
33643
ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33644 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33645 {
33646 USE_OPLINE
33647 zval *object;
33648 zval *property;
33649 zval *zptr;
33650 void *_cache_slot[3] = {0};
33651 void **cache_slot;
33652 zend_property_info *prop_info;
33653 zend_object *zobj;
33654 zend_string *name, *tmp_name;
33655
33656 SAVE_OPLINE();
33657 object = &EX(This);
33658 property = RT_CONSTANT(opline, opline->op2);
33659
33660 do {
33661 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33662 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33663 object = Z_REFVAL_P(object);
33664 goto post_incdec_object;
33665 }
33666 if (IS_UNUSED == IS_CV
33667 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
33668 ZVAL_UNDEFINED_OP1();
33669 }
33670 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
33671 break;
33672 }
33673
33674 post_incdec_object:
33675 /* here we are sure we are dealing with an object */
33676 zobj = Z_OBJ_P(object);
33677 if (IS_CONST == IS_CONST) {
33678 name = Z_STR_P(property);
33679 } else {
33680 name = zval_try_get_tmp_string(property, &tmp_name);
33681 if (UNEXPECTED(!name)) {
33682 ZVAL_UNDEF(EX_VAR(opline->result.var));
33683 break;
33684 }
33685 }
33686 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
33687 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
33688 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
33689 ZVAL_NULL(EX_VAR(opline->result.var));
33690 } else {
33691 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
33692 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
33693 }
33694 } else {
33695 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
33696 }
33697 if (IS_CONST != IS_CONST) {
33698 zend_tmp_string_release(tmp_name);
33699 }
33700 } while (0);
33701
33702
33703 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33704 }
33705
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33706 static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33707 {
33708 USE_OPLINE
33709 zval *container;
33710 void **cache_slot = NULL;
33711
33712 SAVE_OPLINE();
33713 container = &EX(This);
33714
33715 if (IS_UNUSED == IS_CONST ||
33716 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
33717 do {
33718 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
33719 container = Z_REFVAL_P(container);
33720 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33721 break;
33722 }
33723 }
33724 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33725 ZVAL_UNDEFINED_OP1();
33726 }
33727 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
33728 ZVAL_NULL(EX_VAR(opline->result.var));
33729 goto fetch_obj_r_finish;
33730 } while (0);
33731 }
33732
33733 /* here we are sure we are dealing with an object */
33734 do {
33735 zend_object *zobj = Z_OBJ_P(container);
33736 zend_string *name, *tmp_name;
33737 zval *retval;
33738
33739 if (IS_CONST == IS_CONST) {
33740 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
33741
33742 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
33743 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33744
33745 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33746 fetch_obj_r_simple:
33747 retval = OBJ_PROP(zobj, prop_offset);
33748 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
33749 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33750 goto fetch_obj_r_copy;
33751 } else {
33752 fetch_obj_r_fast_copy:
33753 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33754 ZEND_VM_NEXT_OPCODE();
33755 }
33756 }
33757 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
33758 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
33759 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
33760 prop_offset = prop_info->offset;
33761 goto fetch_obj_r_simple;
33762 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
33763 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
33764 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
33765 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
33766
33767 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
33768 if (IS_UNUSED & IS_CV) {
33769 GC_ADDREF(zobj);
33770 }
33771 if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
33772 call_info |= ZEND_CALL_RELEASE_THIS;
33773 }
33774 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
33775 call->prev_execute_data = execute_data;
33776 call->call = NULL;
33777 call->return_value = EX_VAR(opline->result.var);
33778 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
33779
33780 execute_data = call;
33781 EG(current_execute_data) = execute_data;
33782 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
33783
33784 #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
33785 opline = hook->op_array.opcodes;
33786 #else
33787 EX(opline) = hook->op_array.opcodes;
33788 #endif
33789 LOAD_OPLINE_EX();
33790
33791
33792 ZEND_VM_ENTER_EX();
33793 }
33794 /* Fall through to read_property for hooks. */
33795 } else if (EXPECTED(zobj->properties != NULL)) {
33796 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
33797 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33798 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
33799 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
33800
33801 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
33802 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
33803
33804 if (EXPECTED(p->key == name) ||
33805 (EXPECTED(p->h == ZSTR_H(name)) &&
33806 EXPECTED(p->key != NULL) &&
33807 EXPECTED(zend_string_equal_content(p->key, name)))) {
33808 retval = &p->val;
33809 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33810 goto fetch_obj_r_copy;
33811 } else {
33812 goto fetch_obj_r_fast_copy;
33813 }
33814 }
33815 }
33816 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
33817 }
33818 retval = zend_hash_find_known_hash(zobj->properties, name);
33819 if (EXPECTED(retval)) {
33820 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
33821 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
33822 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33823 goto fetch_obj_r_copy;
33824 } else {
33825 goto fetch_obj_r_fast_copy;
33826 }
33827 }
33828 }
33829 }
33830 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33831 } else {
33832 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33833 if (UNEXPECTED(!name)) {
33834 ZVAL_UNDEF(EX_VAR(opline->result.var));
33835 break;
33836 }
33837 }
33838
33839 #if ZEND_DEBUG
33840 /* For non-standard object handlers, verify a declared property type in debug builds.
33841 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
33842 zend_property_info *prop_info = NULL;
33843 if (zobj->handlers->read_property != zend_std_read_property) {
33844 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
33845 }
33846 #endif
33847 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
33848 #if ZEND_DEBUG
33849 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
33850 && ZEND_TYPE_IS_SET(prop_info->type)) {
33851 ZVAL_OPT_DEREF(retval);
33852 zend_verify_property_type(prop_info, retval, /* strict */ true);
33853 }
33854 #endif
33855
33856 if (IS_CONST != IS_CONST) {
33857 zend_tmp_string_release(tmp_name);
33858 }
33859
33860 if (retval != EX_VAR(opline->result.var)) {
33861 fetch_obj_r_copy:
33862 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33863 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
33864 zend_unwrap_reference(retval);
33865 }
33866 } while (0);
33867
33868 fetch_obj_r_finish:
33869
33870
33871 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33872 }
33873
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33874 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33875 {
33876 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33877 }
33878
ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33879 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33880 {
33881 USE_OPLINE
33882 zval *property, *container, *result;
33883
33884 SAVE_OPLINE();
33885
33886 container = &EX(This);
33887 property = RT_CONSTANT(opline, opline->op2);
33888 result = EX_VAR(opline->result.var);
33889 zend_fetch_property_address(
33890 result, container, IS_UNUSED, property, IS_CONST,
33891 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
33892 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
33893
33894 if (IS_UNUSED == IS_VAR) {
33895 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
33896 }
33897 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33898 }
33899
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33900 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33901 {
33902 USE_OPLINE
33903 zval *property, *container, *result;
33904
33905 SAVE_OPLINE();
33906 container = &EX(This);
33907 property = RT_CONSTANT(opline, opline->op2);
33908 result = EX_VAR(opline->result.var);
33909 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);
33910
33911 if (IS_UNUSED == IS_VAR) {
33912 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
33913 }
33914 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33915 }
33916
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33917 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33918 {
33919 USE_OPLINE
33920 zval *container;
33921 void **cache_slot = NULL;
33922
33923 SAVE_OPLINE();
33924 container = &EX(This);
33925
33926 if (IS_UNUSED == IS_CONST ||
33927 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
33928 do {
33929 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
33930 container = Z_REFVAL_P(container);
33931 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33932 break;
33933 }
33934 }
33935 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
33936 ZVAL_UNDEFINED_OP2();
33937 }
33938 ZVAL_NULL(EX_VAR(opline->result.var));
33939 goto fetch_obj_is_finish;
33940 } while (0);
33941 }
33942
33943 /* here we are sure we are dealing with an object */
33944 do {
33945 zend_object *zobj = Z_OBJ_P(container);
33946 zend_string *name, *tmp_name;
33947 zval *retval;
33948
33949 if (IS_CONST == IS_CONST) {
33950 cache_slot = CACHE_ADDR(opline->extended_value);
33951
33952 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
33953 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33954
33955 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33956 fetch_obj_is_simple:
33957 retval = OBJ_PROP(zobj, prop_offset);
33958 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
33959 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33960 goto fetch_obj_is_copy;
33961 } else {
33962 fetch_obj_is_fast_copy:
33963 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33964 ZEND_VM_NEXT_OPCODE();
33965 }
33966 }
33967 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
33968 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
33969 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
33970 prop_offset = prop_info->offset;
33971 goto fetch_obj_is_simple;
33972 }
33973 /* Fall through to read_property for hooks. */
33974 } else if (EXPECTED(zobj->properties != NULL)) {
33975 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
33976 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33977 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
33978 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
33979
33980 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
33981 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
33982
33983 if (EXPECTED(p->key == name) ||
33984 (EXPECTED(p->h == ZSTR_H(name)) &&
33985 EXPECTED(p->key != NULL) &&
33986 EXPECTED(zend_string_equal_content(p->key, name)))) {
33987 retval = &p->val;
33988 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33989 goto fetch_obj_is_copy;
33990 } else {
33991 goto fetch_obj_is_fast_copy;
33992 }
33993 }
33994 }
33995 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
33996 }
33997 retval = zend_hash_find_known_hash(zobj->properties, name);
33998 if (EXPECTED(retval)) {
33999 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
34000 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
34001 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
34002 goto fetch_obj_is_copy;
34003 } else {
34004 goto fetch_obj_is_fast_copy;
34005 }
34006 }
34007 }
34008 }
34009 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34010 } else {
34011 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34012 if (UNEXPECTED(!name)) {
34013 ZVAL_UNDEF(EX_VAR(opline->result.var));
34014 break;
34015 }
34016 }
34017
34018 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
34019
34020 if (IS_CONST != IS_CONST) {
34021 zend_tmp_string_release(tmp_name);
34022 }
34023
34024 if (retval != EX_VAR(opline->result.var)) {
34025 fetch_obj_is_copy:
34026 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
34027 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
34028 zend_unwrap_reference(retval);
34029 }
34030 } while (0);
34031
34032 fetch_obj_is_finish:
34033
34034
34035 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34036 }
34037
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34038 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34039 {
34040 #if 0
34041 USE_OPLINE
34042 #endif
34043
34044 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
34045 /* Behave like FETCH_OBJ_W */
34046 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
34047 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34048 }
34049 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34050 } else {
34051 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34052 }
34053 }
34054
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34055 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34056 {
34057 USE_OPLINE
34058 zval *container, *property, *result;
34059
34060 SAVE_OPLINE();
34061 container = &EX(This);
34062 property = RT_CONSTANT(opline, opline->op2);
34063 result = EX_VAR(opline->result.var);
34064 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);
34065
34066 if (IS_UNUSED == IS_VAR) {
34067 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
34068 }
34069 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34070 }
34071
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34072 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34073 {
34074 USE_OPLINE
34075 zval *object, *value, tmp;
34076 zend_object *zobj;
34077 zend_string *name, *tmp_name;
34078 zend_refcounted *garbage = NULL;
34079
34080 SAVE_OPLINE();
34081 object = &EX(This);
34082 value = RT_CONSTANT((opline+1), (opline+1)->op1);
34083
34084 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34085 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34086 object = Z_REFVAL_P(object);
34087 goto assign_object;
34088 }
34089 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34090 value = &EG(uninitialized_zval);
34091 goto free_and_exit_assign_obj;
34092 }
34093
34094 assign_object:
34095 zobj = Z_OBJ_P(object);
34096 if (IS_CONST == IS_CONST) {
34097 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34098 void **cache_slot = CACHE_ADDR(opline->extended_value);
34099 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34100 zval *property_val;
34101
34102 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34103 property_val = OBJ_PROP(zobj, prop_offset);
34104 if (Z_TYPE_P(property_val) != IS_UNDEF) {
34105 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34106
34107 if (prop_info != NULL) {
34108 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34109 goto free_and_exit_assign_obj;
34110 } else {
34111 fast_assign_obj:
34112 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
34113 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34114 ZVAL_COPY(EX_VAR(opline->result.var), value);
34115 }
34116 goto exit_assign_obj;
34117 }
34118 }
34119 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34120 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34121 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34122 zobj = zend_lazy_object_init(zobj);
34123 if (!zobj) {
34124 value = &EG(uninitialized_zval);
34125 goto free_and_exit_assign_obj;
34126 }
34127 }
34128 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34129 rebuild_object_properties_internal(zobj);
34130 }
34131 if (EXPECTED(zobj->properties != NULL)) {
34132 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34133 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34134 GC_DELREF(zobj->properties);
34135 }
34136 zobj->properties = zend_array_dup(zobj->properties);
34137 }
34138 property_val = zend_hash_find_known_hash(zobj->properties, name);
34139 if (property_val) {
34140 goto fast_assign_obj;
34141 }
34142 }
34143
34144 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34145 if (IS_CONST == IS_CONST) {
34146 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34147 Z_ADDREF_P(value);
34148 }
34149 } else if (IS_CONST != IS_TMP_VAR) {
34150 if (Z_ISREF_P(value)) {
34151 if (IS_CONST == IS_VAR) {
34152 zend_reference *ref = Z_REF_P(value);
34153 if (GC_DELREF(ref) == 0) {
34154 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34155 efree_size(ref, sizeof(zend_reference));
34156 value = &tmp;
34157 } else {
34158 value = Z_REFVAL_P(value);
34159 Z_TRY_ADDREF_P(value);
34160 }
34161 } else {
34162 value = Z_REFVAL_P(value);
34163 Z_TRY_ADDREF_P(value);
34164 }
34165 } else if (IS_CONST == IS_CV) {
34166 Z_TRY_ADDREF_P(value);
34167 }
34168 }
34169 zend_hash_add_new(zobj->properties, name, value);
34170 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34171 ZVAL_COPY(EX_VAR(opline->result.var), value);
34172 }
34173 goto exit_assign_obj;
34174 }
34175 } else {
34176 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34177 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34178 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
34179 property_val = OBJ_PROP(zobj, prop_info->offset);
34180 if (ZEND_TYPE_IS_SET(prop_info->type)) {
34181 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34182 goto free_and_exit_assign_obj;
34183 } else {
34184 goto fast_assign_obj;
34185 }
34186 }
34187 /* Fall through to write_property for hooks. */
34188 }
34189 }
34190 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34191 } else {
34192 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34193 if (UNEXPECTED(!name)) {
34194
34195 UNDEF_RESULT();
34196 goto exit_assign_obj;
34197 }
34198 }
34199
34200 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
34201 ZVAL_DEREF(value);
34202 }
34203
34204 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34205
34206 if (IS_CONST != IS_CONST) {
34207 zend_tmp_string_release(tmp_name);
34208 }
34209
34210 free_and_exit_assign_obj:
34211 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34212 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34213 }
34214
34215 exit_assign_obj:
34216 if (garbage) {
34217 GC_DTOR_NO_REF(garbage);
34218 }
34219
34220
34221 /* assign_obj has two opcodes! */
34222 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34223 }
34224
34225 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34226 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34227 {
34228 USE_OPLINE
34229 zval *object, *value, tmp;
34230 zend_object *zobj;
34231 zend_string *name, *tmp_name;
34232 zend_refcounted *garbage = NULL;
34233
34234 SAVE_OPLINE();
34235 object = &EX(This);
34236 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
34237
34238 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34239 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34240 object = Z_REFVAL_P(object);
34241 goto assign_object;
34242 }
34243 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34244 value = &EG(uninitialized_zval);
34245 goto free_and_exit_assign_obj;
34246 }
34247
34248 assign_object:
34249 zobj = Z_OBJ_P(object);
34250 if (IS_CONST == IS_CONST) {
34251 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34252 void **cache_slot = CACHE_ADDR(opline->extended_value);
34253 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34254 zval *property_val;
34255
34256 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34257 property_val = OBJ_PROP(zobj, prop_offset);
34258 if (Z_TYPE_P(property_val) != IS_UNDEF) {
34259 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34260
34261 if (prop_info != NULL) {
34262 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34263 goto free_and_exit_assign_obj;
34264 } else {
34265 fast_assign_obj:
34266 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
34267 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34268 ZVAL_COPY(EX_VAR(opline->result.var), value);
34269 }
34270 goto exit_assign_obj;
34271 }
34272 }
34273 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34274 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34275 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34276 zobj = zend_lazy_object_init(zobj);
34277 if (!zobj) {
34278 value = &EG(uninitialized_zval);
34279 goto free_and_exit_assign_obj;
34280 }
34281 }
34282 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34283 rebuild_object_properties_internal(zobj);
34284 }
34285 if (EXPECTED(zobj->properties != NULL)) {
34286 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34287 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34288 GC_DELREF(zobj->properties);
34289 }
34290 zobj->properties = zend_array_dup(zobj->properties);
34291 }
34292 property_val = zend_hash_find_known_hash(zobj->properties, name);
34293 if (property_val) {
34294 goto fast_assign_obj;
34295 }
34296 }
34297
34298 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34299 if (IS_TMP_VAR == IS_CONST) {
34300 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34301 Z_ADDREF_P(value);
34302 }
34303 } else if (IS_TMP_VAR != IS_TMP_VAR) {
34304 if (Z_ISREF_P(value)) {
34305 if (IS_TMP_VAR == IS_VAR) {
34306 zend_reference *ref = Z_REF_P(value);
34307 if (GC_DELREF(ref) == 0) {
34308 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34309 efree_size(ref, sizeof(zend_reference));
34310 value = &tmp;
34311 } else {
34312 value = Z_REFVAL_P(value);
34313 Z_TRY_ADDREF_P(value);
34314 }
34315 } else {
34316 value = Z_REFVAL_P(value);
34317 Z_TRY_ADDREF_P(value);
34318 }
34319 } else if (IS_TMP_VAR == IS_CV) {
34320 Z_TRY_ADDREF_P(value);
34321 }
34322 }
34323 zend_hash_add_new(zobj->properties, name, value);
34324 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34325 ZVAL_COPY(EX_VAR(opline->result.var), value);
34326 }
34327 goto exit_assign_obj;
34328 }
34329 } else {
34330 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34331 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34332 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
34333 property_val = OBJ_PROP(zobj, prop_info->offset);
34334 if (ZEND_TYPE_IS_SET(prop_info->type)) {
34335 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34336 goto free_and_exit_assign_obj;
34337 } else {
34338 goto fast_assign_obj;
34339 }
34340 }
34341 /* Fall through to write_property for hooks. */
34342 }
34343 }
34344 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34345 } else {
34346 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34347 if (UNEXPECTED(!name)) {
34348 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34349 UNDEF_RESULT();
34350 goto exit_assign_obj;
34351 }
34352 }
34353
34354 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
34355 ZVAL_DEREF(value);
34356 }
34357
34358 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34359
34360 if (IS_CONST != IS_CONST) {
34361 zend_tmp_string_release(tmp_name);
34362 }
34363
34364 free_and_exit_assign_obj:
34365 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34366 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34367 }
34368 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34369 exit_assign_obj:
34370 if (garbage) {
34371 GC_DTOR_NO_REF(garbage);
34372 }
34373
34374
34375 /* assign_obj has two opcodes! */
34376 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34377 }
34378
34379 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34380 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34381 {
34382 USE_OPLINE
34383 zval *object, *value, tmp;
34384 zend_object *zobj;
34385 zend_string *name, *tmp_name;
34386 zend_refcounted *garbage = NULL;
34387
34388 SAVE_OPLINE();
34389 object = &EX(This);
34390 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
34391
34392 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34393 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34394 object = Z_REFVAL_P(object);
34395 goto assign_object;
34396 }
34397 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34398 value = &EG(uninitialized_zval);
34399 goto free_and_exit_assign_obj;
34400 }
34401
34402 assign_object:
34403 zobj = Z_OBJ_P(object);
34404 if (IS_CONST == IS_CONST) {
34405 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34406 void **cache_slot = CACHE_ADDR(opline->extended_value);
34407 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34408 zval *property_val;
34409
34410 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34411 property_val = OBJ_PROP(zobj, prop_offset);
34412 if (Z_TYPE_P(property_val) != IS_UNDEF) {
34413 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34414
34415 if (prop_info != NULL) {
34416 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34417 goto free_and_exit_assign_obj;
34418 } else {
34419 fast_assign_obj:
34420 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
34421 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34422 ZVAL_COPY(EX_VAR(opline->result.var), value);
34423 }
34424 goto exit_assign_obj;
34425 }
34426 }
34427 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34428 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34429 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34430 zobj = zend_lazy_object_init(zobj);
34431 if (!zobj) {
34432 value = &EG(uninitialized_zval);
34433 goto free_and_exit_assign_obj;
34434 }
34435 }
34436 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34437 rebuild_object_properties_internal(zobj);
34438 }
34439 if (EXPECTED(zobj->properties != NULL)) {
34440 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34441 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34442 GC_DELREF(zobj->properties);
34443 }
34444 zobj->properties = zend_array_dup(zobj->properties);
34445 }
34446 property_val = zend_hash_find_known_hash(zobj->properties, name);
34447 if (property_val) {
34448 goto fast_assign_obj;
34449 }
34450 }
34451
34452 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34453 if (IS_VAR == IS_CONST) {
34454 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34455 Z_ADDREF_P(value);
34456 }
34457 } else if (IS_VAR != IS_TMP_VAR) {
34458 if (Z_ISREF_P(value)) {
34459 if (IS_VAR == IS_VAR) {
34460 zend_reference *ref = Z_REF_P(value);
34461 if (GC_DELREF(ref) == 0) {
34462 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34463 efree_size(ref, sizeof(zend_reference));
34464 value = &tmp;
34465 } else {
34466 value = Z_REFVAL_P(value);
34467 Z_TRY_ADDREF_P(value);
34468 }
34469 } else {
34470 value = Z_REFVAL_P(value);
34471 Z_TRY_ADDREF_P(value);
34472 }
34473 } else if (IS_VAR == IS_CV) {
34474 Z_TRY_ADDREF_P(value);
34475 }
34476 }
34477 zend_hash_add_new(zobj->properties, name, value);
34478 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34479 ZVAL_COPY(EX_VAR(opline->result.var), value);
34480 }
34481 goto exit_assign_obj;
34482 }
34483 } else {
34484 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34485 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34486 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
34487 property_val = OBJ_PROP(zobj, prop_info->offset);
34488 if (ZEND_TYPE_IS_SET(prop_info->type)) {
34489 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34490 goto free_and_exit_assign_obj;
34491 } else {
34492 goto fast_assign_obj;
34493 }
34494 }
34495 /* Fall through to write_property for hooks. */
34496 }
34497 }
34498 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34499 } else {
34500 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34501 if (UNEXPECTED(!name)) {
34502 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34503 UNDEF_RESULT();
34504 goto exit_assign_obj;
34505 }
34506 }
34507
34508 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
34509 ZVAL_DEREF(value);
34510 }
34511
34512 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34513
34514 if (IS_CONST != IS_CONST) {
34515 zend_tmp_string_release(tmp_name);
34516 }
34517
34518 free_and_exit_assign_obj:
34519 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34520 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34521 }
34522 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34523 exit_assign_obj:
34524 if (garbage) {
34525 GC_DTOR_NO_REF(garbage);
34526 }
34527
34528
34529 /* assign_obj has two opcodes! */
34530 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34531 }
34532
34533 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34534 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34535 {
34536 USE_OPLINE
34537 zval *object, *value, tmp;
34538 zend_object *zobj;
34539 zend_string *name, *tmp_name;
34540 zend_refcounted *garbage = NULL;
34541
34542 SAVE_OPLINE();
34543 object = &EX(This);
34544 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
34545
34546 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34547 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34548 object = Z_REFVAL_P(object);
34549 goto assign_object;
34550 }
34551 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
34552 value = &EG(uninitialized_zval);
34553 goto free_and_exit_assign_obj;
34554 }
34555
34556 assign_object:
34557 zobj = Z_OBJ_P(object);
34558 if (IS_CONST == IS_CONST) {
34559 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
34560 void **cache_slot = CACHE_ADDR(opline->extended_value);
34561 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
34562 zval *property_val;
34563
34564 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
34565 property_val = OBJ_PROP(zobj, prop_offset);
34566 if (Z_TYPE_P(property_val) != IS_UNDEF) {
34567 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
34568
34569 if (prop_info != NULL) {
34570 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34571 goto free_and_exit_assign_obj;
34572 } else {
34573 fast_assign_obj:
34574 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
34575 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34576 ZVAL_COPY(EX_VAR(opline->result.var), value);
34577 }
34578 goto exit_assign_obj;
34579 }
34580 }
34581 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
34582 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34583 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
34584 zobj = zend_lazy_object_init(zobj);
34585 if (!zobj) {
34586 value = &EG(uninitialized_zval);
34587 goto free_and_exit_assign_obj;
34588 }
34589 }
34590 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34591 rebuild_object_properties_internal(zobj);
34592 }
34593 if (EXPECTED(zobj->properties != NULL)) {
34594 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
34595 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
34596 GC_DELREF(zobj->properties);
34597 }
34598 zobj->properties = zend_array_dup(zobj->properties);
34599 }
34600 property_val = zend_hash_find_known_hash(zobj->properties, name);
34601 if (property_val) {
34602 goto fast_assign_obj;
34603 }
34604 }
34605
34606 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
34607 if (IS_CV == IS_CONST) {
34608 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
34609 Z_ADDREF_P(value);
34610 }
34611 } else if (IS_CV != IS_TMP_VAR) {
34612 if (Z_ISREF_P(value)) {
34613 if (IS_CV == IS_VAR) {
34614 zend_reference *ref = Z_REF_P(value);
34615 if (GC_DELREF(ref) == 0) {
34616 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
34617 efree_size(ref, sizeof(zend_reference));
34618 value = &tmp;
34619 } else {
34620 value = Z_REFVAL_P(value);
34621 Z_TRY_ADDREF_P(value);
34622 }
34623 } else {
34624 value = Z_REFVAL_P(value);
34625 Z_TRY_ADDREF_P(value);
34626 }
34627 } else if (IS_CV == IS_CV) {
34628 Z_TRY_ADDREF_P(value);
34629 }
34630 }
34631 zend_hash_add_new(zobj->properties, name, value);
34632 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34633 ZVAL_COPY(EX_VAR(opline->result.var), value);
34634 }
34635 goto exit_assign_obj;
34636 }
34637 } else {
34638 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
34639 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
34640 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
34641 property_val = OBJ_PROP(zobj, prop_info->offset);
34642 if (ZEND_TYPE_IS_SET(prop_info->type)) {
34643 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
34644 goto free_and_exit_assign_obj;
34645 } else {
34646 goto fast_assign_obj;
34647 }
34648 }
34649 /* Fall through to write_property for hooks. */
34650 }
34651 }
34652 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34653 } else {
34654 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
34655 if (UNEXPECTED(!name)) {
34656
34657 UNDEF_RESULT();
34658 goto exit_assign_obj;
34659 }
34660 }
34661
34662 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
34663 ZVAL_DEREF(value);
34664 }
34665
34666 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
34667
34668 if (IS_CONST != IS_CONST) {
34669 zend_tmp_string_release(tmp_name);
34670 }
34671
34672 free_and_exit_assign_obj:
34673 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
34674 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
34675 }
34676
34677 exit_assign_obj:
34678 if (garbage) {
34679 GC_DTOR_NO_REF(garbage);
34680 }
34681
34682
34683 /* assign_obj has two opcodes! */
34684 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34685 }
34686
34687 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34688 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34689 {
34690 USE_OPLINE
34691 zval *property, *container, *value_ptr;
34692
34693 SAVE_OPLINE();
34694
34695 container = &EX(This);
34696 property = RT_CONSTANT(opline, opline->op2);
34697
34698 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
34699
34700 if (1) {
34701 if (IS_UNUSED == IS_UNUSED) {
34702 if (IS_CONST == IS_CONST) {
34703 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34704 } else {
34705 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34706 }
34707 } else {
34708 if (IS_CONST == IS_CONST) {
34709 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34710 } else {
34711 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34712 }
34713 }
34714 } else {
34715 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34716 }
34717
34718
34719 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
34720 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34721 }
34722
34723 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34724 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34725 {
34726 USE_OPLINE
34727 zval *property, *container, *value_ptr;
34728
34729 SAVE_OPLINE();
34730
34731 container = &EX(This);
34732 property = RT_CONSTANT(opline, opline->op2);
34733
34734 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
34735
34736 if (1) {
34737 if (IS_UNUSED == IS_UNUSED) {
34738 if (IS_CONST == IS_CONST) {
34739 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34740 } else {
34741 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34742 }
34743 } else {
34744 if (IS_CONST == IS_CONST) {
34745 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34746 } else {
34747 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34748 }
34749 }
34750 } else {
34751 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
34752 }
34753
34754
34755
34756 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34757 }
34758
34759 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34760 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34761 {
34762 USE_OPLINE
34763 zend_string **rope;
34764 zval *var;
34765
34766 /* Compiler allocates the necessary number of zval slots to keep the rope */
34767 rope = (zend_string**)EX_VAR(opline->result.var);
34768 if (IS_CONST == IS_CONST) {
34769 var = RT_CONSTANT(opline, opline->op2);
34770 rope[0] = Z_STR_P(var);
34771 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
34772 Z_ADDREF_P(var);
34773 }
34774 } else {
34775 var = RT_CONSTANT(opline, opline->op2);
34776 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
34777 if (IS_CONST == IS_CV) {
34778 rope[0] = zend_string_copy(Z_STR_P(var));
34779 } else {
34780 rope[0] = Z_STR_P(var);
34781 }
34782 } else {
34783 SAVE_OPLINE();
34784 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
34785 ZVAL_UNDEFINED_OP2();
34786 }
34787 rope[0] = zval_get_string_func(var);
34788
34789 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34790 }
34791 }
34792 ZEND_VM_NEXT_OPCODE();
34793 }
34794
ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34795 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34796 {
34797 zval *class_name;
34798 USE_OPLINE
34799
34800 SAVE_OPLINE();
34801 if (IS_CONST == IS_UNUSED) {
34802 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
34803 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34804 } else if (IS_CONST == IS_CONST) {
34805 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
34806
34807 if (UNEXPECTED(ce == NULL)) {
34808 class_name = RT_CONSTANT(opline, opline->op2);
34809 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
34810 CACHE_PTR(opline->extended_value, ce);
34811 }
34812 Z_CE_P(EX_VAR(opline->result.var)) = ce;
34813 } else {
34814 class_name = RT_CONSTANT(opline, opline->op2);
34815 try_class_name:
34816 if (Z_TYPE_P(class_name) == IS_OBJECT) {
34817 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
34818 } else if (Z_TYPE_P(class_name) == IS_STRING) {
34819 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
34820 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
34821 class_name = Z_REFVAL_P(class_name);
34822 goto try_class_name;
34823 } else {
34824 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
34825 ZVAL_UNDEFINED_OP2();
34826 if (UNEXPECTED(EG(exception) != NULL)) {
34827 HANDLE_EXCEPTION();
34828 }
34829 }
34830 zend_throw_error(NULL, "Class name must be a valid object or a string");
34831 }
34832 }
34833
34834 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34835 }
34836
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34837 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34838 {
34839 USE_OPLINE
34840 zval *function_name;
34841 zval *object;
34842 zend_function *fbc;
34843 zend_class_entry *called_scope;
34844 zend_object *obj;
34845 zend_execute_data *call;
34846 uint32_t call_info;
34847
34848 SAVE_OPLINE();
34849
34850 object = &EX(This);
34851
34852 if (IS_CONST != IS_CONST) {
34853 function_name = RT_CONSTANT(opline, opline->op2);
34854 }
34855
34856 if (IS_CONST != IS_CONST &&
34857 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
34858 do {
34859 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
34860 function_name = Z_REFVAL_P(function_name);
34861 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
34862 break;
34863 }
34864 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
34865 ZVAL_UNDEFINED_OP2();
34866 if (UNEXPECTED(EG(exception) != NULL)) {
34867
34868 HANDLE_EXCEPTION();
34869 }
34870 }
34871 zend_throw_error(NULL, "Method name must be a string");
34872
34873
34874 HANDLE_EXCEPTION();
34875 } while (0);
34876 }
34877
34878 if (IS_UNUSED == IS_UNUSED) {
34879 obj = Z_OBJ_P(object);
34880 } else {
34881 do {
34882 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
34883 obj = Z_OBJ_P(object);
34884 } else {
34885 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
34886 zend_reference *ref = Z_REF_P(object);
34887
34888 object = &ref->val;
34889 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
34890 obj = Z_OBJ_P(object);
34891 if (IS_UNUSED & IS_VAR) {
34892 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
34893 efree_size(ref, sizeof(zend_reference));
34894 } else {
34895 Z_ADDREF_P(object);
34896 }
34897 }
34898 break;
34899 }
34900 }
34901 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
34902 object = ZVAL_UNDEFINED_OP1();
34903 if (UNEXPECTED(EG(exception) != NULL)) {
34904 if (IS_CONST != IS_CONST) {
34905
34906 }
34907 HANDLE_EXCEPTION();
34908 }
34909 }
34910 if (IS_CONST == IS_CONST) {
34911 function_name = RT_CONSTANT(opline, opline->op2);
34912 }
34913 zend_invalid_method_call(object, function_name);
34914
34915
34916 HANDLE_EXCEPTION();
34917 }
34918 } while (0);
34919 }
34920
34921 called_scope = obj->ce;
34922
34923 if (IS_CONST == IS_CONST &&
34924 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
34925 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
34926 } else {
34927 zend_object *orig_obj = obj;
34928
34929 if (IS_CONST == IS_CONST) {
34930 function_name = RT_CONSTANT(opline, opline->op2);
34931 }
34932
34933 /* First, locate the function. */
34934 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
34935 if (UNEXPECTED(fbc == NULL)) {
34936 if (EXPECTED(!EG(exception))) {
34937 zend_undefined_method(obj->ce, Z_STR_P(function_name));
34938 }
34939
34940 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
34941 zend_objects_store_del(orig_obj);
34942 }
34943 HANDLE_EXCEPTION();
34944 }
34945 if (IS_CONST == IS_CONST &&
34946 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
34947 EXPECTED(obj == orig_obj)) {
34948 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
34949 }
34950 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
34951 GC_ADDREF(obj); /* For $this pointer */
34952 if (GC_DELREF(orig_obj) == 0) {
34953 zend_objects_store_del(orig_obj);
34954 }
34955 }
34956 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
34957 init_func_run_time_cache(&fbc->op_array);
34958 }
34959 }
34960
34961 if (IS_CONST != IS_CONST) {
34962
34963 }
34964
34965 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
34966 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
34967 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
34968 zend_objects_store_del(obj);
34969 if (UNEXPECTED(EG(exception))) {
34970 HANDLE_EXCEPTION();
34971 }
34972 }
34973 /* call static method */
34974 obj = (zend_object*)called_scope;
34975 call_info = ZEND_CALL_NESTED_FUNCTION;
34976 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
34977 if (IS_UNUSED == IS_CV) {
34978 GC_ADDREF(obj); /* For $this pointer */
34979 }
34980 /* CV may be changed indirectly (e.g. when it's a reference) */
34981 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
34982 }
34983
34984 call = zend_vm_stack_push_call_frame(call_info,
34985 fbc, opline->extended_value, obj);
34986 call->prev_execute_data = EX(call);
34987 EX(call) = call;
34988
34989 ZEND_VM_NEXT_OPCODE();
34990 }
34991
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34992 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34993 {
34994 USE_OPLINE
34995 zval *function_name;
34996 zend_class_entry *ce;
34997 uint32_t call_info;
34998 zend_function *fbc;
34999 zend_execute_data *call;
35000
35001 SAVE_OPLINE();
35002
35003 if (IS_UNUSED == IS_CONST) {
35004 /* no function found. try a static method in class */
35005 ce = CACHED_PTR(opline->result.num);
35006 if (UNEXPECTED(ce == NULL)) {
35007 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);
35008 if (UNEXPECTED(ce == NULL)) {
35009
35010 HANDLE_EXCEPTION();
35011 }
35012 if (IS_CONST != IS_CONST) {
35013 CACHE_PTR(opline->result.num, ce);
35014 }
35015 }
35016 } else if (IS_UNUSED == IS_UNUSED) {
35017 ce = zend_fetch_class(NULL, opline->op1.num);
35018 if (UNEXPECTED(ce == NULL)) {
35019
35020 HANDLE_EXCEPTION();
35021 }
35022 } else {
35023 ce = Z_CE_P(EX_VAR(opline->op1.var));
35024 }
35025
35026 if (IS_UNUSED == IS_CONST &&
35027 IS_CONST == IS_CONST &&
35028 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
35029 /* nothing to do */
35030 } else if (IS_UNUSED != IS_CONST &&
35031 IS_CONST == IS_CONST &&
35032 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
35033 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
35034 } else if (IS_CONST != IS_UNUSED) {
35035 function_name = RT_CONSTANT(opline, opline->op2);
35036 if (IS_CONST != IS_CONST) {
35037 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
35038 do {
35039 if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
35040 function_name = Z_REFVAL_P(function_name);
35041 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
35042 break;
35043 }
35044 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
35045 ZVAL_UNDEFINED_OP2();
35046 if (UNEXPECTED(EG(exception) != NULL)) {
35047 HANDLE_EXCEPTION();
35048 }
35049 }
35050 zend_throw_error(NULL, "Method name must be a string");
35051
35052 HANDLE_EXCEPTION();
35053 } while (0);
35054 }
35055 }
35056
35057 if (ce->get_static_method) {
35058 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
35059 } else {
35060 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
35061 }
35062 if (UNEXPECTED(fbc == NULL)) {
35063 if (EXPECTED(!EG(exception))) {
35064 zend_undefined_method(ce, Z_STR_P(function_name));
35065 }
35066
35067 HANDLE_EXCEPTION();
35068 }
35069 if (IS_CONST == IS_CONST &&
35070 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
35071 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
35072 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
35073 }
35074 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
35075 init_func_run_time_cache(&fbc->op_array);
35076 }
35077 if (IS_CONST != IS_CONST) {
35078
35079 }
35080 } else {
35081 if (UNEXPECTED(ce->constructor == NULL)) {
35082 zend_throw_error(NULL, "Cannot call constructor");
35083 HANDLE_EXCEPTION();
35084 }
35085 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
35086 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
35087 HANDLE_EXCEPTION();
35088 }
35089 fbc = ce->constructor;
35090 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
35091 init_func_run_time_cache(&fbc->op_array);
35092 }
35093 }
35094
35095 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
35096 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
35097 ce = (zend_class_entry*)Z_OBJ(EX(This));
35098 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
35099 } else {
35100 zend_non_static_method_call(fbc);
35101 HANDLE_EXCEPTION();
35102 }
35103 } else {
35104 /* previous opcode is ZEND_FETCH_CLASS */
35105 if (IS_UNUSED == IS_UNUSED
35106 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
35107 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
35108 if (Z_TYPE(EX(This)) == IS_OBJECT) {
35109 ce = Z_OBJCE(EX(This));
35110 } else {
35111 ce = Z_CE(EX(This));
35112 }
35113 }
35114 call_info = ZEND_CALL_NESTED_FUNCTION;
35115 }
35116
35117 call = zend_vm_stack_push_call_frame(call_info,
35118 fbc, opline->extended_value, ce);
35119 call->prev_execute_data = EX(call);
35120 EX(call) = call;
35121
35122 ZEND_VM_NEXT_OPCODE();
35123 }
35124
ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35125 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35126 {
35127 USE_OPLINE
35128 uint32_t arg_num;
35129
35130 if (IS_CONST == IS_CONST) {
35131 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
35132 arg_num = zend_get_arg_offset_by_name(
35133 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
35134 if (UNEXPECTED(arg_num == 0)) {
35135 /* Treat this as a by-value argument, and throw an error during SEND. */
35136 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35137 ZEND_VM_NEXT_OPCODE();
35138 }
35139 } else {
35140 arg_num = opline->op2.num;
35141 }
35142
35143 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
35144 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
35145 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35146 } else {
35147 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35148 }
35149 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
35150 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35151 } else {
35152 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
35153 }
35154 ZEND_VM_NEXT_OPCODE();
35155 }
35156
ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35157 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35158 {
35159 USE_OPLINE
35160 zend_constant *c;
35161
35162 c = CACHED_PTR(opline->extended_value);
35163 if (EXPECTED(c != NULL) && EXPECTED(!IS_SPECIAL_CACHE_VAL(c))) {
35164 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), &c->value);
35165 ZEND_VM_NEXT_OPCODE();
35166 }
35167
35168 SAVE_OPLINE();
35169 zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num OPLINE_CC EXECUTE_DATA_CC);
35170 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35171 }
35172
ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35173 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35174 {
35175 zend_class_entry *ce, *scope;
35176 zend_class_constant *c;
35177 zval *value, *zv, *constant_zv;
35178 zend_string *constant_name;
35179 USE_OPLINE
35180
35181 SAVE_OPLINE();
35182
35183 do {
35184 if (IS_UNUSED == IS_CONST && IS_CONST == IS_CONST) {
35185 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
35186 value = CACHED_PTR(opline->extended_value + sizeof(void*));
35187 break;
35188 }
35189 }
35190 if (IS_UNUSED == IS_CONST) {
35191 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
35192 ce = CACHED_PTR(opline->extended_value);
35193 } else {
35194 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);
35195 if (UNEXPECTED(ce == NULL)) {
35196 ZVAL_UNDEF(EX_VAR(opline->result.var));
35197
35198 HANDLE_EXCEPTION();
35199 }
35200 CACHE_PTR(opline->extended_value, ce);
35201 }
35202 } else if (IS_UNUSED == IS_UNUSED) {
35203 ce = zend_fetch_class(NULL, opline->op1.num);
35204 if (UNEXPECTED(ce == NULL)) {
35205 ZVAL_UNDEF(EX_VAR(opline->result.var));
35206
35207 HANDLE_EXCEPTION();
35208 }
35209 } else {
35210 ce = Z_CE_P(EX_VAR(opline->op1.var));
35211 }
35212 if (IS_UNUSED != IS_CONST
35213 && IS_CONST == IS_CONST
35214 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
35215 value = CACHED_PTR(opline->extended_value + sizeof(void*));
35216 break;
35217 }
35218
35219 constant_zv = RT_CONSTANT(opline, opline->op2);
35220 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
35221 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
35222 ZVAL_UNDEF(EX_VAR(opline->result.var));
35223
35224 HANDLE_EXCEPTION();
35225 }
35226 constant_name = Z_STR_P(constant_zv);
35227 /* Magic 'class' for constant OP2 is caught at compile-time */
35228 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
35229 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
35230
35231 ZEND_VM_NEXT_OPCODE();
35232 }
35233 zv = IS_CONST == IS_CONST
35234 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
35235 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
35236
35237 if (EXPECTED(zv != NULL)) {
35238 c = Z_PTR_P(zv);
35239 scope = EX(func)->op_array.scope;
35240 if (!zend_verify_const_access(c, scope)) {
35241 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));
35242 ZVAL_UNDEF(EX_VAR(opline->result.var));
35243
35244 HANDLE_EXCEPTION();
35245 }
35246
35247 if (ce->ce_flags & ZEND_ACC_TRAIT) {
35248 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35249 ZVAL_UNDEF(EX_VAR(opline->result.var));
35250
35251 HANDLE_EXCEPTION();
35252 }
35253
35254 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
35255 if (UNEXPECTED(is_constant_deprecated)) {
35256 zend_deprecated_class_constant(c, constant_name);
35257
35258 if (EG(exception)) {
35259 ZVAL_UNDEF(EX_VAR(opline->result.var));
35260
35261 HANDLE_EXCEPTION();
35262 }
35263 }
35264
35265 value = &c->value;
35266 // Enums require loading of all class constants to build the backed enum table
35267 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)) {
35268 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
35269 ZVAL_UNDEF(EX_VAR(opline->result.var));
35270
35271 HANDLE_EXCEPTION();
35272 }
35273 }
35274 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
35275 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
35276 ZVAL_UNDEF(EX_VAR(opline->result.var));
35277
35278 HANDLE_EXCEPTION();
35279 }
35280 }
35281 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
35282 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
35283 }
35284 } else {
35285 zend_throw_error(NULL, "Undefined constant %s::%s",
35286 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35287 ZVAL_UNDEF(EX_VAR(opline->result.var));
35288
35289 HANDLE_EXCEPTION();
35290 }
35291 } while (0);
35292
35293 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
35294
35295 ZEND_VM_NEXT_OPCODE();
35296 }
35297
ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35298 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35299 {
35300 zval *array;
35301 uint32_t size;
35302 USE_OPLINE
35303
35304 array = EX_VAR(opline->result.var);
35305 if (IS_UNUSED != IS_UNUSED) {
35306 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
35307 ZVAL_ARR(array, zend_new_array(size));
35308 /* Explicitly initialize array as not-packed if flag is set */
35309 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
35310 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
35311 }
35312 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35313 } else {
35314 ZVAL_ARR(array, zend_new_array(0));
35315 ZEND_VM_NEXT_OPCODE();
35316 }
35317 }
35318
ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35319 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35320 {
35321 USE_OPLINE
35322 zval *container;
35323 zval *offset;
35324 zend_string *name, *tmp_name;
35325
35326 SAVE_OPLINE();
35327 container = &EX(This);
35328 offset = RT_CONSTANT(opline, opline->op2);
35329
35330 do {
35331 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
35332 if (Z_ISREF_P(container)) {
35333 container = Z_REFVAL_P(container);
35334 if (Z_TYPE_P(container) != IS_OBJECT) {
35335 if (IS_UNUSED == IS_CV
35336 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
35337 ZVAL_UNDEFINED_OP1();
35338 }
35339 break;
35340 }
35341 } else {
35342 break;
35343 }
35344 }
35345 if (IS_CONST == IS_CONST) {
35346 name = Z_STR_P(offset);
35347 } else {
35348 name = zval_try_get_tmp_string(offset, &tmp_name);
35349 if (UNEXPECTED(!name)) {
35350 break;
35351 }
35352 }
35353 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
35354 if (IS_CONST != IS_CONST) {
35355 zend_tmp_string_release(tmp_name);
35356 }
35357 } while (0);
35358
35359
35360 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35361 }
35362
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35363 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35364 {
35365 USE_OPLINE
35366 zval *container;
35367 int result;
35368 zval *offset;
35369 zend_string *name, *tmp_name;
35370
35371 SAVE_OPLINE();
35372 container = &EX(This);
35373 offset = RT_CONSTANT(opline, opline->op2);
35374
35375 if (IS_UNUSED == IS_CONST ||
35376 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
35377 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
35378 container = Z_REFVAL_P(container);
35379 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
35380 result = (opline->extended_value & ZEND_ISEMPTY);
35381 goto isset_object_finish;
35382 }
35383 } else {
35384 result = (opline->extended_value & ZEND_ISEMPTY);
35385 goto isset_object_finish;
35386 }
35387 }
35388
35389 if (IS_CONST == IS_CONST) {
35390 name = Z_STR_P(offset);
35391 } else {
35392 name = zval_try_get_tmp_string(offset, &tmp_name);
35393 if (UNEXPECTED(!name)) {
35394 result = 0;
35395 goto isset_object_finish;
35396 }
35397 }
35398
35399 result =
35400 (opline->extended_value & ZEND_ISEMPTY) ^
35401 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));
35402
35403 if (IS_CONST != IS_CONST) {
35404 zend_tmp_string_release(tmp_name);
35405 }
35406
35407 isset_object_finish:
35408
35409
35410 ZEND_VM_SMART_BRANCH(result, 1);
35411 }
35412
ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35413 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35414 {
35415 USE_OPLINE
35416
35417 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
35418
35419 SAVE_OPLINE();
35420 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
35421 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35422 }
35423
35424 /* Destroy the previously yielded value */
35425 zval_ptr_dtor(&generator->value);
35426
35427 /* Destroy the previously yielded key */
35428 zval_ptr_dtor(&generator->key);
35429
35430 /* Set the new yielded value */
35431 if (IS_UNUSED != IS_UNUSED) {
35432 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
35433 /* Constants and temporary variables aren't yieldable by reference,
35434 * but we still allow them with a notice. */
35435 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
35436 zval *value;
35437
35438 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
35439
35440 value = NULL;
35441 ZVAL_COPY_VALUE(&generator->value, value);
35442 if (IS_UNUSED == IS_CONST) {
35443 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
35444 Z_ADDREF(generator->value);
35445 }
35446 }
35447 } else {
35448 zval *value_ptr = NULL;
35449
35450 /* If a function call result is yielded and the function did
35451 * not return by reference we throw a notice. */
35452 do {
35453 if (IS_UNUSED == IS_VAR) {
35454 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
35455 if (opline->extended_value == ZEND_RETURNS_FUNCTION
35456 && !Z_ISREF_P(value_ptr)) {
35457 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
35458 ZVAL_COPY(&generator->value, value_ptr);
35459 break;
35460 }
35461 }
35462 if (Z_ISREF_P(value_ptr)) {
35463 Z_ADDREF_P(value_ptr);
35464 } else {
35465 ZVAL_MAKE_REF_EX(value_ptr, 2);
35466 }
35467 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
35468 } while (0);
35469
35470 }
35471 } else {
35472 zval *value = NULL;
35473
35474 /* Consts, temporary variables and references need copying */
35475 if (IS_UNUSED == IS_CONST) {
35476 ZVAL_COPY_VALUE(&generator->value, value);
35477 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
35478 Z_ADDREF(generator->value);
35479 }
35480 } else if (IS_UNUSED == IS_TMP_VAR) {
35481 ZVAL_COPY_VALUE(&generator->value, value);
35482 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
35483 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
35484
35485 } else {
35486 ZVAL_COPY_VALUE(&generator->value, value);
35487 if (IS_UNUSED == IS_CV) {
35488 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
35489 }
35490 }
35491 }
35492 } else {
35493 /* If no value was specified yield null */
35494 ZVAL_NULL(&generator->value);
35495 }
35496
35497 /* Set the new yielded key */
35498 if (IS_CONST != IS_UNUSED) {
35499 zval *key = RT_CONSTANT(opline, opline->op2);
35500 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
35501 key = Z_REFVAL_P(key);
35502 }
35503 ZVAL_COPY(&generator->key, key);
35504
35505 if (Z_TYPE(generator->key) == IS_LONG
35506 && Z_LVAL(generator->key) > generator->largest_used_integer_key
35507 ) {
35508 generator->largest_used_integer_key = Z_LVAL(generator->key);
35509 }
35510 } else {
35511 /* If no key was specified we use auto-increment keys */
35512 generator->largest_used_integer_key++;
35513 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
35514 }
35515
35516 if (RETURN_VALUE_USED(opline)) {
35517 /* If the return value of yield is used set the send
35518 * target and initialize it to NULL */
35519 generator->send_target = EX_VAR(opline->result.var);
35520 ZVAL_NULL(generator->send_target);
35521 } else {
35522 generator->send_target = NULL;
35523 }
35524
35525 /* The GOTO VM uses a local opline variable. We need to set the opline
35526 * variable in execute_data so we don't resume at an old position. */
35527 SAVE_OPLINE();
35528
35529 ZEND_VM_RETURN();
35530 }
35531
ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35532 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35533 {
35534 zend_class_entry *ce, *scope;
35535 zend_class_constant *c;
35536 zval *value, *zv, *constant_zv;
35537 zend_string *constant_name;
35538 USE_OPLINE
35539
35540 SAVE_OPLINE();
35541
35542 do {
35543 if (IS_UNUSED == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
35544 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
35545 value = CACHED_PTR(opline->extended_value + sizeof(void*));
35546 break;
35547 }
35548 }
35549 if (IS_UNUSED == IS_CONST) {
35550 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
35551 ce = CACHED_PTR(opline->extended_value);
35552 } else {
35553 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);
35554 if (UNEXPECTED(ce == NULL)) {
35555 ZVAL_UNDEF(EX_VAR(opline->result.var));
35556 FREE_OP(opline->op2_type, opline->op2.var);
35557 HANDLE_EXCEPTION();
35558 }
35559 CACHE_PTR(opline->extended_value, ce);
35560 }
35561 } else if (IS_UNUSED == IS_UNUSED) {
35562 ce = zend_fetch_class(NULL, opline->op1.num);
35563 if (UNEXPECTED(ce == NULL)) {
35564 ZVAL_UNDEF(EX_VAR(opline->result.var));
35565 FREE_OP(opline->op2_type, opline->op2.var);
35566 HANDLE_EXCEPTION();
35567 }
35568 } else {
35569 ce = Z_CE_P(EX_VAR(opline->op1.var));
35570 }
35571 if (IS_UNUSED != IS_CONST
35572 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
35573 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
35574 value = CACHED_PTR(opline->extended_value + sizeof(void*));
35575 break;
35576 }
35577
35578 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
35579 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
35580 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
35581 ZVAL_UNDEF(EX_VAR(opline->result.var));
35582 FREE_OP(opline->op2_type, opline->op2.var);
35583 HANDLE_EXCEPTION();
35584 }
35585 constant_name = Z_STR_P(constant_zv);
35586 /* Magic 'class' for constant OP2 is caught at compile-time */
35587 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
35588 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
35589 FREE_OP(opline->op2_type, opline->op2.var);
35590 ZEND_VM_NEXT_OPCODE();
35591 }
35592 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
35593 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
35594 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
35595
35596 if (EXPECTED(zv != NULL)) {
35597 c = Z_PTR_P(zv);
35598 scope = EX(func)->op_array.scope;
35599 if (!zend_verify_const_access(c, scope)) {
35600 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));
35601 ZVAL_UNDEF(EX_VAR(opline->result.var));
35602 FREE_OP(opline->op2_type, opline->op2.var);
35603 HANDLE_EXCEPTION();
35604 }
35605
35606 if (ce->ce_flags & ZEND_ACC_TRAIT) {
35607 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35608 ZVAL_UNDEF(EX_VAR(opline->result.var));
35609 FREE_OP(opline->op2_type, opline->op2.var);
35610 HANDLE_EXCEPTION();
35611 }
35612
35613 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
35614 if (UNEXPECTED(is_constant_deprecated)) {
35615 zend_deprecated_class_constant(c, constant_name);
35616
35617 if (EG(exception)) {
35618 ZVAL_UNDEF(EX_VAR(opline->result.var));
35619 FREE_OP(opline->op2_type, opline->op2.var);
35620 HANDLE_EXCEPTION();
35621 }
35622 }
35623
35624 value = &c->value;
35625 // Enums require loading of all class constants to build the backed enum table
35626 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)) {
35627 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
35628 ZVAL_UNDEF(EX_VAR(opline->result.var));
35629 FREE_OP(opline->op2_type, opline->op2.var);
35630 HANDLE_EXCEPTION();
35631 }
35632 }
35633 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
35634 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
35635 ZVAL_UNDEF(EX_VAR(opline->result.var));
35636 FREE_OP(opline->op2_type, opline->op2.var);
35637 HANDLE_EXCEPTION();
35638 }
35639 }
35640 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
35641 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
35642 }
35643 } else {
35644 zend_throw_error(NULL, "Undefined constant %s::%s",
35645 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
35646 ZVAL_UNDEF(EX_VAR(opline->result.var));
35647 FREE_OP(opline->op2_type, opline->op2.var);
35648 HANDLE_EXCEPTION();
35649 }
35650 } while (0);
35651
35652 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
35653
35654 FREE_OP(opline->op2_type, opline->op2.var);
35655 ZEND_VM_NEXT_OPCODE();
35656 }
35657
ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35658 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35659 {
35660 USE_OPLINE
35661 zval *object;
35662 zval *property;
35663 zval *value;
35664 zval *zptr;
35665 void *_cache_slot[3] = {0};
35666 void **cache_slot;
35667 zend_property_info *prop_info;
35668 zend_object *zobj;
35669 zend_string *name, *tmp_name;
35670
35671 SAVE_OPLINE();
35672 object = &EX(This);
35673 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35674
35675 do {
35676 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
35677
35678 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35679 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35680 object = Z_REFVAL_P(object);
35681 goto assign_op_object;
35682 }
35683 if (IS_UNUSED == IS_CV
35684 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35685 ZVAL_UNDEFINED_OP1();
35686 }
35687 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35688 break;
35689 }
35690
35691 assign_op_object:
35692 /* here we are sure we are dealing with an object */
35693 zobj = Z_OBJ_P(object);
35694 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35695 name = Z_STR_P(property);
35696 } else {
35697 name = zval_try_get_tmp_string(property, &tmp_name);
35698 if (UNEXPECTED(!name)) {
35699 UNDEF_RESULT();
35700 break;
35701 }
35702 }
35703 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
35704 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35705 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35706 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35707 ZVAL_NULL(EX_VAR(opline->result.var));
35708 }
35709 } else {
35710 zend_reference *ref;
35711
35712 do {
35713 if (UNEXPECTED(Z_ISREF_P(zptr))) {
35714 ref = Z_REF_P(zptr);
35715 zptr = Z_REFVAL_P(zptr);
35716 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
35717 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
35718 break;
35719 }
35720 }
35721
35722 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
35723 if (prop_info) {
35724 /* special case for typed properties */
35725 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
35726 } else {
35727 zend_binary_op(zptr, zptr, value OPLINE_CC);
35728 }
35729 } while (0);
35730
35731 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35732 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
35733 }
35734 }
35735 } else {
35736 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
35737 }
35738 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35739 zend_tmp_string_release(tmp_name);
35740 }
35741 } while (0);
35742
35743 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
35744 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35745
35746 /* assign_obj has two opcodes! */
35747 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35748 }
35749
35750 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35751 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35752 {
35753 USE_OPLINE
35754 zval *object;
35755 zval *property;
35756 zval *zptr;
35757 void *_cache_slot[3] = {0};
35758 void **cache_slot;
35759 zend_property_info *prop_info;
35760 zend_object *zobj;
35761 zend_string *name, *tmp_name;
35762
35763 SAVE_OPLINE();
35764 object = &EX(This);
35765 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35766
35767 do {
35768 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35769 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35770 object = Z_REFVAL_P(object);
35771 goto pre_incdec_object;
35772 }
35773 if (IS_UNUSED == IS_CV
35774 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35775 ZVAL_UNDEFINED_OP1();
35776 }
35777 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35778 break;
35779 }
35780
35781 pre_incdec_object:
35782 /* here we are sure we are dealing with an object */
35783 zobj = Z_OBJ_P(object);
35784 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35785 name = Z_STR_P(property);
35786 } else {
35787 name = zval_try_get_tmp_string(property, &tmp_name);
35788 if (UNEXPECTED(!name)) {
35789 UNDEF_RESULT();
35790 break;
35791 }
35792 }
35793 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
35794 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35795 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35796 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35797 ZVAL_NULL(EX_VAR(opline->result.var));
35798 }
35799 } else {
35800 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
35801 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
35802 }
35803 } else {
35804 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
35805 }
35806 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35807 zend_tmp_string_release(tmp_name);
35808 }
35809 } while (0);
35810
35811 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35812
35813 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35814 }
35815
ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35816 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35817 {
35818 USE_OPLINE
35819 zval *object;
35820 zval *property;
35821 zval *zptr;
35822 void *_cache_slot[3] = {0};
35823 void **cache_slot;
35824 zend_property_info *prop_info;
35825 zend_object *zobj;
35826 zend_string *name, *tmp_name;
35827
35828 SAVE_OPLINE();
35829 object = &EX(This);
35830 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35831
35832 do {
35833 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35834 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35835 object = Z_REFVAL_P(object);
35836 goto post_incdec_object;
35837 }
35838 if (IS_UNUSED == IS_CV
35839 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35840 ZVAL_UNDEFINED_OP1();
35841 }
35842 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35843 break;
35844 }
35845
35846 post_incdec_object:
35847 /* here we are sure we are dealing with an object */
35848 zobj = Z_OBJ_P(object);
35849 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35850 name = Z_STR_P(property);
35851 } else {
35852 name = zval_try_get_tmp_string(property, &tmp_name);
35853 if (UNEXPECTED(!name)) {
35854 ZVAL_UNDEF(EX_VAR(opline->result.var));
35855 break;
35856 }
35857 }
35858 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
35859 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35860 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35861 ZVAL_NULL(EX_VAR(opline->result.var));
35862 } else {
35863 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
35864 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
35865 }
35866 } else {
35867 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
35868 }
35869 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35870 zend_tmp_string_release(tmp_name);
35871 }
35872 } while (0);
35873
35874 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35875
35876 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35877 }
35878
ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35879 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35880 {
35881 USE_OPLINE
35882 zval *container;
35883 void **cache_slot = NULL;
35884
35885 SAVE_OPLINE();
35886 container = &EX(This);
35887
35888 if (IS_UNUSED == IS_CONST ||
35889 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
35890 do {
35891 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
35892 container = Z_REFVAL_P(container);
35893 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
35894 break;
35895 }
35896 }
35897 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
35898 ZVAL_UNDEFINED_OP1();
35899 }
35900 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35901 ZVAL_NULL(EX_VAR(opline->result.var));
35902 goto fetch_obj_r_finish;
35903 } while (0);
35904 }
35905
35906 /* here we are sure we are dealing with an object */
35907 do {
35908 zend_object *zobj = Z_OBJ_P(container);
35909 zend_string *name, *tmp_name;
35910 zval *retval;
35911
35912 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35913 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
35914
35915 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
35916 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35917
35918 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35919 fetch_obj_r_simple:
35920 retval = OBJ_PROP(zobj, prop_offset);
35921 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
35922 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35923 goto fetch_obj_r_copy;
35924 } else {
35925 fetch_obj_r_fast_copy:
35926 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
35927 ZEND_VM_NEXT_OPCODE();
35928 }
35929 }
35930 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
35931 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
35932 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
35933 prop_offset = prop_info->offset;
35934 goto fetch_obj_r_simple;
35935 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
35936 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
35937 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
35938 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
35939
35940 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
35941 if (IS_UNUSED & IS_CV) {
35942 GC_ADDREF(zobj);
35943 }
35944 if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
35945 call_info |= ZEND_CALL_RELEASE_THIS;
35946 }
35947 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
35948 call->prev_execute_data = execute_data;
35949 call->call = NULL;
35950 call->return_value = EX_VAR(opline->result.var);
35951 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
35952
35953 execute_data = call;
35954 EG(current_execute_data) = execute_data;
35955 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
35956
35957 #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
35958 opline = hook->op_array.opcodes;
35959 #else
35960 EX(opline) = hook->op_array.opcodes;
35961 #endif
35962 LOAD_OPLINE_EX();
35963
35964
35965 ZEND_VM_ENTER_EX();
35966 }
35967 /* Fall through to read_property for hooks. */
35968 } else if (EXPECTED(zobj->properties != NULL)) {
35969 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
35970 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35971 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
35972 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
35973
35974 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
35975 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
35976
35977 if (EXPECTED(p->key == name) ||
35978 (EXPECTED(p->h == ZSTR_H(name)) &&
35979 EXPECTED(p->key != NULL) &&
35980 EXPECTED(zend_string_equal_content(p->key, name)))) {
35981 retval = &p->val;
35982 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35983 goto fetch_obj_r_copy;
35984 } else {
35985 goto fetch_obj_r_fast_copy;
35986 }
35987 }
35988 }
35989 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
35990 }
35991 retval = zend_hash_find_known_hash(zobj->properties, name);
35992 if (EXPECTED(retval)) {
35993 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
35994 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
35995 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35996 goto fetch_obj_r_copy;
35997 } else {
35998 goto fetch_obj_r_fast_copy;
35999 }
36000 }
36001 }
36002 }
36003 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36004 } else {
36005 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36006 if (UNEXPECTED(!name)) {
36007 ZVAL_UNDEF(EX_VAR(opline->result.var));
36008 break;
36009 }
36010 }
36011
36012 #if ZEND_DEBUG
36013 /* For non-standard object handlers, verify a declared property type in debug builds.
36014 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
36015 zend_property_info *prop_info = NULL;
36016 if (zobj->handlers->read_property != zend_std_read_property) {
36017 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
36018 }
36019 #endif
36020 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
36021 #if ZEND_DEBUG
36022 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
36023 && ZEND_TYPE_IS_SET(prop_info->type)) {
36024 ZVAL_OPT_DEREF(retval);
36025 zend_verify_property_type(prop_info, retval, /* strict */ true);
36026 }
36027 #endif
36028
36029 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36030 zend_tmp_string_release(tmp_name);
36031 }
36032
36033 if (retval != EX_VAR(opline->result.var)) {
36034 fetch_obj_r_copy:
36035 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36036 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
36037 zend_unwrap_reference(retval);
36038 }
36039 } while (0);
36040
36041 fetch_obj_r_finish:
36042 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36043
36044 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36045 }
36046
ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36047 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36048 {
36049 USE_OPLINE
36050 zval *property, *container, *result;
36051
36052 SAVE_OPLINE();
36053
36054 container = &EX(This);
36055 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36056 result = EX_VAR(opline->result.var);
36057 zend_fetch_property_address(
36058 result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR),
36059 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
36060 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
36061 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36062 if (IS_UNUSED == IS_VAR) {
36063 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36064 }
36065 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36066 }
36067
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36068 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36069 {
36070 USE_OPLINE
36071 zval *property, *container, *result;
36072
36073 SAVE_OPLINE();
36074 container = &EX(This);
36075 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36076 result = EX_VAR(opline->result.var);
36077 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);
36078 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36079 if (IS_UNUSED == IS_VAR) {
36080 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36081 }
36082 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36083 }
36084
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36085 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36086 {
36087 USE_OPLINE
36088 zval *container;
36089 void **cache_slot = NULL;
36090
36091 SAVE_OPLINE();
36092 container = &EX(This);
36093
36094 if (IS_UNUSED == IS_CONST ||
36095 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
36096 do {
36097 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
36098 container = Z_REFVAL_P(container);
36099 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
36100 break;
36101 }
36102 }
36103 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
36104 ZVAL_UNDEFINED_OP2();
36105 }
36106 ZVAL_NULL(EX_VAR(opline->result.var));
36107 goto fetch_obj_is_finish;
36108 } while (0);
36109 }
36110
36111 /* here we are sure we are dealing with an object */
36112 do {
36113 zend_object *zobj = Z_OBJ_P(container);
36114 zend_string *name, *tmp_name;
36115 zval *retval;
36116
36117 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36118 cache_slot = CACHE_ADDR(opline->extended_value);
36119
36120 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
36121 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36122
36123 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36124 fetch_obj_is_simple:
36125 retval = OBJ_PROP(zobj, prop_offset);
36126 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
36127 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36128 goto fetch_obj_is_copy;
36129 } else {
36130 fetch_obj_is_fast_copy:
36131 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36132 ZEND_VM_NEXT_OPCODE();
36133 }
36134 }
36135 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
36136 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
36137 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
36138 prop_offset = prop_info->offset;
36139 goto fetch_obj_is_simple;
36140 }
36141 /* Fall through to read_property for hooks. */
36142 } else if (EXPECTED(zobj->properties != NULL)) {
36143 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
36144 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36145 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
36146 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
36147
36148 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
36149 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
36150
36151 if (EXPECTED(p->key == name) ||
36152 (EXPECTED(p->h == ZSTR_H(name)) &&
36153 EXPECTED(p->key != NULL) &&
36154 EXPECTED(zend_string_equal_content(p->key, name)))) {
36155 retval = &p->val;
36156 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36157 goto fetch_obj_is_copy;
36158 } else {
36159 goto fetch_obj_is_fast_copy;
36160 }
36161 }
36162 }
36163 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
36164 }
36165 retval = zend_hash_find_known_hash(zobj->properties, name);
36166 if (EXPECTED(retval)) {
36167 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
36168 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
36169 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
36170 goto fetch_obj_is_copy;
36171 } else {
36172 goto fetch_obj_is_fast_copy;
36173 }
36174 }
36175 }
36176 }
36177 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36178 } else {
36179 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36180 if (UNEXPECTED(!name)) {
36181 ZVAL_UNDEF(EX_VAR(opline->result.var));
36182 break;
36183 }
36184 }
36185
36186 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
36187
36188 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36189 zend_tmp_string_release(tmp_name);
36190 }
36191
36192 if (retval != EX_VAR(opline->result.var)) {
36193 fetch_obj_is_copy:
36194 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
36195 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
36196 zend_unwrap_reference(retval);
36197 }
36198 } while (0);
36199
36200 fetch_obj_is_finish:
36201 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36202
36203 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36204 }
36205
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36206 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36207 {
36208 #if 0
36209 USE_OPLINE
36210 #endif
36211
36212 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
36213 /* Behave like FETCH_OBJ_W */
36214 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
36215 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36216 }
36217 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36218 } else {
36219 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36220 }
36221 }
36222
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36223 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36224 {
36225 USE_OPLINE
36226 zval *container, *property, *result;
36227
36228 SAVE_OPLINE();
36229 container = &EX(This);
36230 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36231 result = EX_VAR(opline->result.var);
36232 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);
36233 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36234 if (IS_UNUSED == IS_VAR) {
36235 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
36236 }
36237 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36238 }
36239
ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36240 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36241 {
36242 USE_OPLINE
36243 zval *object, *value, tmp;
36244 zend_object *zobj;
36245 zend_string *name, *tmp_name;
36246 zend_refcounted *garbage = NULL;
36247
36248 SAVE_OPLINE();
36249 object = &EX(This);
36250 value = RT_CONSTANT((opline+1), (opline+1)->op1);
36251
36252 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36253 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36254 object = Z_REFVAL_P(object);
36255 goto assign_object;
36256 }
36257 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36258 value = &EG(uninitialized_zval);
36259 goto free_and_exit_assign_obj;
36260 }
36261
36262 assign_object:
36263 zobj = Z_OBJ_P(object);
36264 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36265 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36266 void **cache_slot = CACHE_ADDR(opline->extended_value);
36267 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36268 zval *property_val;
36269
36270 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36271 property_val = OBJ_PROP(zobj, prop_offset);
36272 if (Z_TYPE_P(property_val) != IS_UNDEF) {
36273 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36274
36275 if (prop_info != NULL) {
36276 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36277 goto free_and_exit_assign_obj;
36278 } else {
36279 fast_assign_obj:
36280 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
36281 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36282 ZVAL_COPY(EX_VAR(opline->result.var), value);
36283 }
36284 goto exit_assign_obj;
36285 }
36286 }
36287 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36288 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36289 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36290 zobj = zend_lazy_object_init(zobj);
36291 if (!zobj) {
36292 value = &EG(uninitialized_zval);
36293 goto free_and_exit_assign_obj;
36294 }
36295 }
36296 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36297 rebuild_object_properties_internal(zobj);
36298 }
36299 if (EXPECTED(zobj->properties != NULL)) {
36300 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36301 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36302 GC_DELREF(zobj->properties);
36303 }
36304 zobj->properties = zend_array_dup(zobj->properties);
36305 }
36306 property_val = zend_hash_find_known_hash(zobj->properties, name);
36307 if (property_val) {
36308 goto fast_assign_obj;
36309 }
36310 }
36311
36312 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36313 if (IS_CONST == IS_CONST) {
36314 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36315 Z_ADDREF_P(value);
36316 }
36317 } else if (IS_CONST != IS_TMP_VAR) {
36318 if (Z_ISREF_P(value)) {
36319 if (IS_CONST == IS_VAR) {
36320 zend_reference *ref = Z_REF_P(value);
36321 if (GC_DELREF(ref) == 0) {
36322 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36323 efree_size(ref, sizeof(zend_reference));
36324 value = &tmp;
36325 } else {
36326 value = Z_REFVAL_P(value);
36327 Z_TRY_ADDREF_P(value);
36328 }
36329 } else {
36330 value = Z_REFVAL_P(value);
36331 Z_TRY_ADDREF_P(value);
36332 }
36333 } else if (IS_CONST == IS_CV) {
36334 Z_TRY_ADDREF_P(value);
36335 }
36336 }
36337 zend_hash_add_new(zobj->properties, name, value);
36338 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36339 ZVAL_COPY(EX_VAR(opline->result.var), value);
36340 }
36341 goto exit_assign_obj;
36342 }
36343 } else {
36344 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36345 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36346 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
36347 property_val = OBJ_PROP(zobj, prop_info->offset);
36348 if (ZEND_TYPE_IS_SET(prop_info->type)) {
36349 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36350 goto free_and_exit_assign_obj;
36351 } else {
36352 goto fast_assign_obj;
36353 }
36354 }
36355 /* Fall through to write_property for hooks. */
36356 }
36357 }
36358 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36359 } else {
36360 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36361 if (UNEXPECTED(!name)) {
36362
36363 UNDEF_RESULT();
36364 goto exit_assign_obj;
36365 }
36366 }
36367
36368 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
36369 ZVAL_DEREF(value);
36370 }
36371
36372 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36373
36374 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36375 zend_tmp_string_release(tmp_name);
36376 }
36377
36378 free_and_exit_assign_obj:
36379 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36380 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36381 }
36382
36383 exit_assign_obj:
36384 if (garbage) {
36385 GC_DTOR_NO_REF(garbage);
36386 }
36387 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36388
36389 /* assign_obj has two opcodes! */
36390 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36391 }
36392
36393 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36394 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36395 {
36396 USE_OPLINE
36397 zval *object, *value, tmp;
36398 zend_object *zobj;
36399 zend_string *name, *tmp_name;
36400 zend_refcounted *garbage = NULL;
36401
36402 SAVE_OPLINE();
36403 object = &EX(This);
36404 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
36405
36406 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36407 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36408 object = Z_REFVAL_P(object);
36409 goto assign_object;
36410 }
36411 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36412 value = &EG(uninitialized_zval);
36413 goto free_and_exit_assign_obj;
36414 }
36415
36416 assign_object:
36417 zobj = Z_OBJ_P(object);
36418 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36419 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36420 void **cache_slot = CACHE_ADDR(opline->extended_value);
36421 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36422 zval *property_val;
36423
36424 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36425 property_val = OBJ_PROP(zobj, prop_offset);
36426 if (Z_TYPE_P(property_val) != IS_UNDEF) {
36427 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36428
36429 if (prop_info != NULL) {
36430 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36431 goto free_and_exit_assign_obj;
36432 } else {
36433 fast_assign_obj:
36434 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
36435 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36436 ZVAL_COPY(EX_VAR(opline->result.var), value);
36437 }
36438 goto exit_assign_obj;
36439 }
36440 }
36441 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36442 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36443 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36444 zobj = zend_lazy_object_init(zobj);
36445 if (!zobj) {
36446 value = &EG(uninitialized_zval);
36447 goto free_and_exit_assign_obj;
36448 }
36449 }
36450 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36451 rebuild_object_properties_internal(zobj);
36452 }
36453 if (EXPECTED(zobj->properties != NULL)) {
36454 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36455 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36456 GC_DELREF(zobj->properties);
36457 }
36458 zobj->properties = zend_array_dup(zobj->properties);
36459 }
36460 property_val = zend_hash_find_known_hash(zobj->properties, name);
36461 if (property_val) {
36462 goto fast_assign_obj;
36463 }
36464 }
36465
36466 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36467 if (IS_TMP_VAR == IS_CONST) {
36468 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36469 Z_ADDREF_P(value);
36470 }
36471 } else if (IS_TMP_VAR != IS_TMP_VAR) {
36472 if (Z_ISREF_P(value)) {
36473 if (IS_TMP_VAR == IS_VAR) {
36474 zend_reference *ref = Z_REF_P(value);
36475 if (GC_DELREF(ref) == 0) {
36476 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36477 efree_size(ref, sizeof(zend_reference));
36478 value = &tmp;
36479 } else {
36480 value = Z_REFVAL_P(value);
36481 Z_TRY_ADDREF_P(value);
36482 }
36483 } else {
36484 value = Z_REFVAL_P(value);
36485 Z_TRY_ADDREF_P(value);
36486 }
36487 } else if (IS_TMP_VAR == IS_CV) {
36488 Z_TRY_ADDREF_P(value);
36489 }
36490 }
36491 zend_hash_add_new(zobj->properties, name, value);
36492 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36493 ZVAL_COPY(EX_VAR(opline->result.var), value);
36494 }
36495 goto exit_assign_obj;
36496 }
36497 } else {
36498 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36499 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36500 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
36501 property_val = OBJ_PROP(zobj, prop_info->offset);
36502 if (ZEND_TYPE_IS_SET(prop_info->type)) {
36503 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36504 goto free_and_exit_assign_obj;
36505 } else {
36506 goto fast_assign_obj;
36507 }
36508 }
36509 /* Fall through to write_property for hooks. */
36510 }
36511 }
36512 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36513 } else {
36514 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36515 if (UNEXPECTED(!name)) {
36516 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36517 UNDEF_RESULT();
36518 goto exit_assign_obj;
36519 }
36520 }
36521
36522 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
36523 ZVAL_DEREF(value);
36524 }
36525
36526 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36527
36528 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36529 zend_tmp_string_release(tmp_name);
36530 }
36531
36532 free_and_exit_assign_obj:
36533 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36534 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36535 }
36536 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36537 exit_assign_obj:
36538 if (garbage) {
36539 GC_DTOR_NO_REF(garbage);
36540 }
36541 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36542
36543 /* assign_obj has two opcodes! */
36544 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36545 }
36546
36547 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36548 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36549 {
36550 USE_OPLINE
36551 zval *object, *value, tmp;
36552 zend_object *zobj;
36553 zend_string *name, *tmp_name;
36554 zend_refcounted *garbage = NULL;
36555
36556 SAVE_OPLINE();
36557 object = &EX(This);
36558 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
36559
36560 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36561 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36562 object = Z_REFVAL_P(object);
36563 goto assign_object;
36564 }
36565 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36566 value = &EG(uninitialized_zval);
36567 goto free_and_exit_assign_obj;
36568 }
36569
36570 assign_object:
36571 zobj = Z_OBJ_P(object);
36572 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36573 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36574 void **cache_slot = CACHE_ADDR(opline->extended_value);
36575 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36576 zval *property_val;
36577
36578 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36579 property_val = OBJ_PROP(zobj, prop_offset);
36580 if (Z_TYPE_P(property_val) != IS_UNDEF) {
36581 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36582
36583 if (prop_info != NULL) {
36584 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36585 goto free_and_exit_assign_obj;
36586 } else {
36587 fast_assign_obj:
36588 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
36589 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36590 ZVAL_COPY(EX_VAR(opline->result.var), value);
36591 }
36592 goto exit_assign_obj;
36593 }
36594 }
36595 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36596 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36597 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36598 zobj = zend_lazy_object_init(zobj);
36599 if (!zobj) {
36600 value = &EG(uninitialized_zval);
36601 goto free_and_exit_assign_obj;
36602 }
36603 }
36604 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36605 rebuild_object_properties_internal(zobj);
36606 }
36607 if (EXPECTED(zobj->properties != NULL)) {
36608 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36609 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36610 GC_DELREF(zobj->properties);
36611 }
36612 zobj->properties = zend_array_dup(zobj->properties);
36613 }
36614 property_val = zend_hash_find_known_hash(zobj->properties, name);
36615 if (property_val) {
36616 goto fast_assign_obj;
36617 }
36618 }
36619
36620 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36621 if (IS_VAR == IS_CONST) {
36622 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36623 Z_ADDREF_P(value);
36624 }
36625 } else if (IS_VAR != IS_TMP_VAR) {
36626 if (Z_ISREF_P(value)) {
36627 if (IS_VAR == IS_VAR) {
36628 zend_reference *ref = Z_REF_P(value);
36629 if (GC_DELREF(ref) == 0) {
36630 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36631 efree_size(ref, sizeof(zend_reference));
36632 value = &tmp;
36633 } else {
36634 value = Z_REFVAL_P(value);
36635 Z_TRY_ADDREF_P(value);
36636 }
36637 } else {
36638 value = Z_REFVAL_P(value);
36639 Z_TRY_ADDREF_P(value);
36640 }
36641 } else if (IS_VAR == IS_CV) {
36642 Z_TRY_ADDREF_P(value);
36643 }
36644 }
36645 zend_hash_add_new(zobj->properties, name, value);
36646 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36647 ZVAL_COPY(EX_VAR(opline->result.var), value);
36648 }
36649 goto exit_assign_obj;
36650 }
36651 } else {
36652 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36653 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36654 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
36655 property_val = OBJ_PROP(zobj, prop_info->offset);
36656 if (ZEND_TYPE_IS_SET(prop_info->type)) {
36657 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36658 goto free_and_exit_assign_obj;
36659 } else {
36660 goto fast_assign_obj;
36661 }
36662 }
36663 /* Fall through to write_property for hooks. */
36664 }
36665 }
36666 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36667 } else {
36668 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36669 if (UNEXPECTED(!name)) {
36670 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36671 UNDEF_RESULT();
36672 goto exit_assign_obj;
36673 }
36674 }
36675
36676 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
36677 ZVAL_DEREF(value);
36678 }
36679
36680 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36681
36682 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36683 zend_tmp_string_release(tmp_name);
36684 }
36685
36686 free_and_exit_assign_obj:
36687 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36688 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36689 }
36690 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36691 exit_assign_obj:
36692 if (garbage) {
36693 GC_DTOR_NO_REF(garbage);
36694 }
36695 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36696
36697 /* assign_obj has two opcodes! */
36698 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36699 }
36700
36701 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36702 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36703 {
36704 USE_OPLINE
36705 zval *object, *value, tmp;
36706 zend_object *zobj;
36707 zend_string *name, *tmp_name;
36708 zend_refcounted *garbage = NULL;
36709
36710 SAVE_OPLINE();
36711 object = &EX(This);
36712 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
36713
36714 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
36715 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
36716 object = Z_REFVAL_P(object);
36717 goto assign_object;
36718 }
36719 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
36720 value = &EG(uninitialized_zval);
36721 goto free_and_exit_assign_obj;
36722 }
36723
36724 assign_object:
36725 zobj = Z_OBJ_P(object);
36726 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36727 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
36728 void **cache_slot = CACHE_ADDR(opline->extended_value);
36729 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
36730 zval *property_val;
36731
36732 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
36733 property_val = OBJ_PROP(zobj, prop_offset);
36734 if (Z_TYPE_P(property_val) != IS_UNDEF) {
36735 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
36736
36737 if (prop_info != NULL) {
36738 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36739 goto free_and_exit_assign_obj;
36740 } else {
36741 fast_assign_obj:
36742 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
36743 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36744 ZVAL_COPY(EX_VAR(opline->result.var), value);
36745 }
36746 goto exit_assign_obj;
36747 }
36748 }
36749 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
36750 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36751 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
36752 zobj = zend_lazy_object_init(zobj);
36753 if (!zobj) {
36754 value = &EG(uninitialized_zval);
36755 goto free_and_exit_assign_obj;
36756 }
36757 }
36758 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36759 rebuild_object_properties_internal(zobj);
36760 }
36761 if (EXPECTED(zobj->properties != NULL)) {
36762 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
36763 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
36764 GC_DELREF(zobj->properties);
36765 }
36766 zobj->properties = zend_array_dup(zobj->properties);
36767 }
36768 property_val = zend_hash_find_known_hash(zobj->properties, name);
36769 if (property_val) {
36770 goto fast_assign_obj;
36771 }
36772 }
36773
36774 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
36775 if (IS_CV == IS_CONST) {
36776 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
36777 Z_ADDREF_P(value);
36778 }
36779 } else if (IS_CV != IS_TMP_VAR) {
36780 if (Z_ISREF_P(value)) {
36781 if (IS_CV == IS_VAR) {
36782 zend_reference *ref = Z_REF_P(value);
36783 if (GC_DELREF(ref) == 0) {
36784 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
36785 efree_size(ref, sizeof(zend_reference));
36786 value = &tmp;
36787 } else {
36788 value = Z_REFVAL_P(value);
36789 Z_TRY_ADDREF_P(value);
36790 }
36791 } else {
36792 value = Z_REFVAL_P(value);
36793 Z_TRY_ADDREF_P(value);
36794 }
36795 } else if (IS_CV == IS_CV) {
36796 Z_TRY_ADDREF_P(value);
36797 }
36798 }
36799 zend_hash_add_new(zobj->properties, name, value);
36800 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
36801 ZVAL_COPY(EX_VAR(opline->result.var), value);
36802 }
36803 goto exit_assign_obj;
36804 }
36805 } else {
36806 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
36807 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
36808 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
36809 property_val = OBJ_PROP(zobj, prop_info->offset);
36810 if (ZEND_TYPE_IS_SET(prop_info->type)) {
36811 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
36812 goto free_and_exit_assign_obj;
36813 } else {
36814 goto fast_assign_obj;
36815 }
36816 }
36817 /* Fall through to write_property for hooks. */
36818 }
36819 }
36820 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
36821 } else {
36822 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
36823 if (UNEXPECTED(!name)) {
36824
36825 UNDEF_RESULT();
36826 goto exit_assign_obj;
36827 }
36828 }
36829
36830 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
36831 ZVAL_DEREF(value);
36832 }
36833
36834 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
36835
36836 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36837 zend_tmp_string_release(tmp_name);
36838 }
36839
36840 free_and_exit_assign_obj:
36841 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
36842 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
36843 }
36844
36845 exit_assign_obj:
36846 if (garbage) {
36847 GC_DTOR_NO_REF(garbage);
36848 }
36849 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36850
36851 /* assign_obj has two opcodes! */
36852 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36853 }
36854
36855 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36856 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36857 {
36858 USE_OPLINE
36859 zval *property, *container, *value_ptr;
36860
36861 SAVE_OPLINE();
36862
36863 container = &EX(This);
36864 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36865
36866 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
36867
36868 if (1) {
36869 if (IS_UNUSED == IS_UNUSED) {
36870 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36871 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36872 } else {
36873 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36874 }
36875 } else {
36876 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36877 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36878 } else {
36879 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36880 }
36881 }
36882 } else {
36883 zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
36884 }
36885
36886 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36887 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
36888 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36889 }
36890
36891 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36892 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36893 {
36894 USE_OPLINE
36895 zval *property, *container, *value_ptr;
36896
36897 SAVE_OPLINE();
36898
36899 container = &EX(This);
36900 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36901
36902 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
36903
36904 if (1) {
36905 if (IS_UNUSED == IS_UNUSED) {
36906 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36907 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36908 } else {
36909 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36910 }
36911 } else {
36912 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36913 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36914 } else {
36915 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
36916 }
36917 }
36918 } else {
36919 zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
36920 }
36921
36922 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36923
36924 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36925 }
36926
36927 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36928 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36929 {
36930 USE_OPLINE
36931 zend_string **rope;
36932 zval *var;
36933
36934 /* Compiler allocates the necessary number of zval slots to keep the rope */
36935 rope = (zend_string**)EX_VAR(opline->result.var);
36936 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36937 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36938 rope[0] = Z_STR_P(var);
36939 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
36940 Z_ADDREF_P(var);
36941 }
36942 } else {
36943 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36944 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
36945 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
36946 rope[0] = zend_string_copy(Z_STR_P(var));
36947 } else {
36948 rope[0] = Z_STR_P(var);
36949 }
36950 } else {
36951 SAVE_OPLINE();
36952 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
36953 ZVAL_UNDEFINED_OP2();
36954 }
36955 rope[0] = zval_get_string_func(var);
36956 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36957 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36958 }
36959 }
36960 ZEND_VM_NEXT_OPCODE();
36961 }
36962
ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36963 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36964 {
36965 zval *class_name;
36966 USE_OPLINE
36967
36968 SAVE_OPLINE();
36969 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
36970 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
36971 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36972 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36973 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
36974
36975 if (UNEXPECTED(ce == NULL)) {
36976 class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36977 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
36978 CACHE_PTR(opline->extended_value, ce);
36979 }
36980 Z_CE_P(EX_VAR(opline->result.var)) = ce;
36981 } else {
36982 class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36983 try_class_name:
36984 if (Z_TYPE_P(class_name) == IS_OBJECT) {
36985 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
36986 } else if (Z_TYPE_P(class_name) == IS_STRING) {
36987 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
36988 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
36989 class_name = Z_REFVAL_P(class_name);
36990 goto try_class_name;
36991 } else {
36992 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
36993 ZVAL_UNDEFINED_OP2();
36994 if (UNEXPECTED(EG(exception) != NULL)) {
36995 HANDLE_EXCEPTION();
36996 }
36997 }
36998 zend_throw_error(NULL, "Class name must be a valid object or a string");
36999 }
37000 }
37001
37002 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37003 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37004 }
37005
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37006 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37007 {
37008 USE_OPLINE
37009 zval *function_name;
37010 zval *object;
37011 zend_function *fbc;
37012 zend_class_entry *called_scope;
37013 zend_object *obj;
37014 zend_execute_data *call;
37015 uint32_t call_info;
37016
37017 SAVE_OPLINE();
37018
37019 object = &EX(This);
37020
37021 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37022 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37023 }
37024
37025 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
37026 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37027 do {
37028 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
37029 function_name = Z_REFVAL_P(function_name);
37030 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37031 break;
37032 }
37033 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37034 ZVAL_UNDEFINED_OP2();
37035 if (UNEXPECTED(EG(exception) != NULL)) {
37036
37037 HANDLE_EXCEPTION();
37038 }
37039 }
37040 zend_throw_error(NULL, "Method name must be a string");
37041 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37042
37043 HANDLE_EXCEPTION();
37044 } while (0);
37045 }
37046
37047 if (IS_UNUSED == IS_UNUSED) {
37048 obj = Z_OBJ_P(object);
37049 } else {
37050 do {
37051 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
37052 obj = Z_OBJ_P(object);
37053 } else {
37054 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
37055 zend_reference *ref = Z_REF_P(object);
37056
37057 object = &ref->val;
37058 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
37059 obj = Z_OBJ_P(object);
37060 if (IS_UNUSED & IS_VAR) {
37061 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
37062 efree_size(ref, sizeof(zend_reference));
37063 } else {
37064 Z_ADDREF_P(object);
37065 }
37066 }
37067 break;
37068 }
37069 }
37070 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
37071 object = ZVAL_UNDEFINED_OP1();
37072 if (UNEXPECTED(EG(exception) != NULL)) {
37073 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37074 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37075 }
37076 HANDLE_EXCEPTION();
37077 }
37078 }
37079 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37080 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37081 }
37082 zend_invalid_method_call(object, function_name);
37083 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37084
37085 HANDLE_EXCEPTION();
37086 }
37087 } while (0);
37088 }
37089
37090 called_scope = obj->ce;
37091
37092 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37093 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
37094 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37095 } else {
37096 zend_object *orig_obj = obj;
37097
37098 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37099 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37100 }
37101
37102 /* First, locate the function. */
37103 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));
37104 if (UNEXPECTED(fbc == NULL)) {
37105 if (EXPECTED(!EG(exception))) {
37106 zend_undefined_method(obj->ce, Z_STR_P(function_name));
37107 }
37108 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37109 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
37110 zend_objects_store_del(orig_obj);
37111 }
37112 HANDLE_EXCEPTION();
37113 }
37114 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37115 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37116 EXPECTED(obj == orig_obj)) {
37117 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
37118 }
37119 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
37120 GC_ADDREF(obj); /* For $this pointer */
37121 if (GC_DELREF(orig_obj) == 0) {
37122 zend_objects_store_del(orig_obj);
37123 }
37124 }
37125 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37126 init_func_run_time_cache(&fbc->op_array);
37127 }
37128 }
37129
37130 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37131 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37132 }
37133
37134 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37135 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
37136 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
37137 zend_objects_store_del(obj);
37138 if (UNEXPECTED(EG(exception))) {
37139 HANDLE_EXCEPTION();
37140 }
37141 }
37142 /* call static method */
37143 obj = (zend_object*)called_scope;
37144 call_info = ZEND_CALL_NESTED_FUNCTION;
37145 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
37146 if (IS_UNUSED == IS_CV) {
37147 GC_ADDREF(obj); /* For $this pointer */
37148 }
37149 /* CV may be changed indirectly (e.g. when it's a reference) */
37150 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
37151 }
37152
37153 call = zend_vm_stack_push_call_frame(call_info,
37154 fbc, opline->extended_value, obj);
37155 call->prev_execute_data = EX(call);
37156 EX(call) = call;
37157
37158 ZEND_VM_NEXT_OPCODE();
37159 }
37160
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37161 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37162 {
37163 USE_OPLINE
37164 zval *function_name;
37165 zend_class_entry *ce;
37166 uint32_t call_info;
37167 zend_function *fbc;
37168 zend_execute_data *call;
37169
37170 SAVE_OPLINE();
37171
37172 if (IS_UNUSED == IS_CONST) {
37173 /* no function found. try a static method in class */
37174 ce = CACHED_PTR(opline->result.num);
37175 if (UNEXPECTED(ce == NULL)) {
37176 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);
37177 if (UNEXPECTED(ce == NULL)) {
37178 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37179 HANDLE_EXCEPTION();
37180 }
37181 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37182 CACHE_PTR(opline->result.num, ce);
37183 }
37184 }
37185 } else if (IS_UNUSED == IS_UNUSED) {
37186 ce = zend_fetch_class(NULL, opline->op1.num);
37187 if (UNEXPECTED(ce == NULL)) {
37188 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37189 HANDLE_EXCEPTION();
37190 }
37191 } else {
37192 ce = Z_CE_P(EX_VAR(opline->op1.var));
37193 }
37194
37195 if (IS_UNUSED == IS_CONST &&
37196 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
37197 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
37198 /* nothing to do */
37199 } else if (IS_UNUSED != IS_CONST &&
37200 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
37201 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
37202 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37203 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
37204 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37205 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37206 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37207 do {
37208 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
37209 function_name = Z_REFVAL_P(function_name);
37210 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37211 break;
37212 }
37213 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37214 ZVAL_UNDEFINED_OP2();
37215 if (UNEXPECTED(EG(exception) != NULL)) {
37216 HANDLE_EXCEPTION();
37217 }
37218 }
37219 zend_throw_error(NULL, "Method name must be a string");
37220 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37221 HANDLE_EXCEPTION();
37222 } while (0);
37223 }
37224 }
37225
37226 if (ce->get_static_method) {
37227 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
37228 } else {
37229 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));
37230 }
37231 if (UNEXPECTED(fbc == NULL)) {
37232 if (EXPECTED(!EG(exception))) {
37233 zend_undefined_method(ce, Z_STR_P(function_name));
37234 }
37235 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37236 HANDLE_EXCEPTION();
37237 }
37238 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
37239 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37240 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
37241 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
37242 }
37243 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37244 init_func_run_time_cache(&fbc->op_array);
37245 }
37246 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37247 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37248 }
37249 } else {
37250 if (UNEXPECTED(ce->constructor == NULL)) {
37251 zend_throw_error(NULL, "Cannot call constructor");
37252 HANDLE_EXCEPTION();
37253 }
37254 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
37255 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
37256 HANDLE_EXCEPTION();
37257 }
37258 fbc = ce->constructor;
37259 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37260 init_func_run_time_cache(&fbc->op_array);
37261 }
37262 }
37263
37264 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
37265 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
37266 ce = (zend_class_entry*)Z_OBJ(EX(This));
37267 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37268 } else {
37269 zend_non_static_method_call(fbc);
37270 HANDLE_EXCEPTION();
37271 }
37272 } else {
37273 /* previous opcode is ZEND_FETCH_CLASS */
37274 if (IS_UNUSED == IS_UNUSED
37275 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
37276 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
37277 if (Z_TYPE(EX(This)) == IS_OBJECT) {
37278 ce = Z_OBJCE(EX(This));
37279 } else {
37280 ce = Z_CE(EX(This));
37281 }
37282 }
37283 call_info = ZEND_CALL_NESTED_FUNCTION;
37284 }
37285
37286 call = zend_vm_stack_push_call_frame(call_info,
37287 fbc, opline->extended_value, ce);
37288 call->prev_execute_data = EX(call);
37289 EX(call) = call;
37290
37291 ZEND_VM_NEXT_OPCODE();
37292 }
37293
ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37294 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37295 {
37296 zval *array;
37297 uint32_t size;
37298 USE_OPLINE
37299
37300 array = EX_VAR(opline->result.var);
37301 if (IS_UNUSED != IS_UNUSED) {
37302 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
37303 ZVAL_ARR(array, zend_new_array(size));
37304 /* Explicitly initialize array as not-packed if flag is set */
37305 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
37306 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
37307 }
37308 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37309 } else {
37310 ZVAL_ARR(array, zend_new_array(0));
37311 ZEND_VM_NEXT_OPCODE();
37312 }
37313 }
37314
ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37315 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37316 {
37317 USE_OPLINE
37318 zval *container;
37319 zval *offset;
37320 zend_string *name, *tmp_name;
37321
37322 SAVE_OPLINE();
37323 container = &EX(This);
37324 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37325
37326 do {
37327 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
37328 if (Z_ISREF_P(container)) {
37329 container = Z_REFVAL_P(container);
37330 if (Z_TYPE_P(container) != IS_OBJECT) {
37331 if (IS_UNUSED == IS_CV
37332 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
37333 ZVAL_UNDEFINED_OP1();
37334 }
37335 break;
37336 }
37337 } else {
37338 break;
37339 }
37340 }
37341 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37342 name = Z_STR_P(offset);
37343 } else {
37344 name = zval_try_get_tmp_string(offset, &tmp_name);
37345 if (UNEXPECTED(!name)) {
37346 break;
37347 }
37348 }
37349 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));
37350 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37351 zend_tmp_string_release(tmp_name);
37352 }
37353 } while (0);
37354
37355 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37356
37357 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37358 }
37359
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37360 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37361 {
37362 USE_OPLINE
37363 zval *container;
37364 int result;
37365 zval *offset;
37366 zend_string *name, *tmp_name;
37367
37368 SAVE_OPLINE();
37369 container = &EX(This);
37370 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37371
37372 if (IS_UNUSED == IS_CONST ||
37373 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
37374 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
37375 container = Z_REFVAL_P(container);
37376 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
37377 result = (opline->extended_value & ZEND_ISEMPTY);
37378 goto isset_object_finish;
37379 }
37380 } else {
37381 result = (opline->extended_value & ZEND_ISEMPTY);
37382 goto isset_object_finish;
37383 }
37384 }
37385
37386 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
37387 name = Z_STR_P(offset);
37388 } else {
37389 name = zval_try_get_tmp_string(offset, &tmp_name);
37390 if (UNEXPECTED(!name)) {
37391 result = 0;
37392 goto isset_object_finish;
37393 }
37394 }
37395
37396 result =
37397 (opline->extended_value & ZEND_ISEMPTY) ^
37398 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));
37399
37400 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
37401 zend_tmp_string_release(tmp_name);
37402 }
37403
37404 isset_object_finish:
37405 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37406
37407 ZEND_VM_SMART_BRANCH(result, 1);
37408 }
37409
ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37410 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37411 {
37412 USE_OPLINE
37413
37414 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
37415
37416 SAVE_OPLINE();
37417 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
37418 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37419 }
37420
37421 /* Destroy the previously yielded value */
37422 zval_ptr_dtor(&generator->value);
37423
37424 /* Destroy the previously yielded key */
37425 zval_ptr_dtor(&generator->key);
37426
37427 /* Set the new yielded value */
37428 if (IS_UNUSED != IS_UNUSED) {
37429 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
37430 /* Constants and temporary variables aren't yieldable by reference,
37431 * but we still allow them with a notice. */
37432 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
37433 zval *value;
37434
37435 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37436
37437 value = NULL;
37438 ZVAL_COPY_VALUE(&generator->value, value);
37439 if (IS_UNUSED == IS_CONST) {
37440 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37441 Z_ADDREF(generator->value);
37442 }
37443 }
37444 } else {
37445 zval *value_ptr = NULL;
37446
37447 /* If a function call result is yielded and the function did
37448 * not return by reference we throw a notice. */
37449 do {
37450 if (IS_UNUSED == IS_VAR) {
37451 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
37452 if (opline->extended_value == ZEND_RETURNS_FUNCTION
37453 && !Z_ISREF_P(value_ptr)) {
37454 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37455 ZVAL_COPY(&generator->value, value_ptr);
37456 break;
37457 }
37458 }
37459 if (Z_ISREF_P(value_ptr)) {
37460 Z_ADDREF_P(value_ptr);
37461 } else {
37462 ZVAL_MAKE_REF_EX(value_ptr, 2);
37463 }
37464 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
37465 } while (0);
37466
37467 }
37468 } else {
37469 zval *value = NULL;
37470
37471 /* Consts, temporary variables and references need copying */
37472 if (IS_UNUSED == IS_CONST) {
37473 ZVAL_COPY_VALUE(&generator->value, value);
37474 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37475 Z_ADDREF(generator->value);
37476 }
37477 } else if (IS_UNUSED == IS_TMP_VAR) {
37478 ZVAL_COPY_VALUE(&generator->value, value);
37479 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
37480 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
37481
37482 } else {
37483 ZVAL_COPY_VALUE(&generator->value, value);
37484 if (IS_UNUSED == IS_CV) {
37485 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
37486 }
37487 }
37488 }
37489 } else {
37490 /* If no value was specified yield null */
37491 ZVAL_NULL(&generator->value);
37492 }
37493
37494 /* Set the new yielded key */
37495 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
37496 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
37497 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
37498 key = Z_REFVAL_P(key);
37499 }
37500 ZVAL_COPY(&generator->key, key);
37501 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
37502
37503 if (Z_TYPE(generator->key) == IS_LONG
37504 && Z_LVAL(generator->key) > generator->largest_used_integer_key
37505 ) {
37506 generator->largest_used_integer_key = Z_LVAL(generator->key);
37507 }
37508 } else {
37509 /* If no key was specified we use auto-increment keys */
37510 generator->largest_used_integer_key++;
37511 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
37512 }
37513
37514 if (RETURN_VALUE_USED(opline)) {
37515 /* If the return value of yield is used set the send
37516 * target and initialize it to NULL */
37517 generator->send_target = EX_VAR(opline->result.var);
37518 ZVAL_NULL(generator->send_target);
37519 } else {
37520 generator->send_target = NULL;
37521 }
37522
37523 /* The GOTO VM uses a local opline variable. We need to set the opline
37524 * variable in execute_data so we don't resume at an old position. */
37525 SAVE_OPLINE();
37526
37527 ZEND_VM_RETURN();
37528 }
37529
ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37530 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37531 {
37532 zval *class_name;
37533 USE_OPLINE
37534
37535 SAVE_OPLINE();
37536 if (IS_UNUSED == IS_UNUSED) {
37537 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
37538 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37539 } else if (IS_UNUSED == IS_CONST) {
37540 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
37541
37542 if (UNEXPECTED(ce == NULL)) {
37543 class_name = NULL;
37544 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
37545 CACHE_PTR(opline->extended_value, ce);
37546 }
37547 Z_CE_P(EX_VAR(opline->result.var)) = ce;
37548 } else {
37549 class_name = NULL;
37550 try_class_name:
37551 if (Z_TYPE_P(class_name) == IS_OBJECT) {
37552 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
37553 } else if (Z_TYPE_P(class_name) == IS_STRING) {
37554 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
37555 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
37556 class_name = Z_REFVAL_P(class_name);
37557 goto try_class_name;
37558 } else {
37559 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
37560 ZVAL_UNDEFINED_OP2();
37561 if (UNEXPECTED(EG(exception) != NULL)) {
37562 HANDLE_EXCEPTION();
37563 }
37564 }
37565 zend_throw_error(NULL, "Class name must be a valid object or a string");
37566 }
37567 }
37568
37569 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37570 }
37571
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37572 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37573 {
37574 USE_OPLINE
37575 zval *function_name;
37576 zend_class_entry *ce;
37577 uint32_t call_info;
37578 zend_function *fbc;
37579 zend_execute_data *call;
37580
37581 SAVE_OPLINE();
37582
37583 if (IS_UNUSED == IS_CONST) {
37584 /* no function found. try a static method in class */
37585 ce = CACHED_PTR(opline->result.num);
37586 if (UNEXPECTED(ce == NULL)) {
37587 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);
37588 if (UNEXPECTED(ce == NULL)) {
37589
37590 HANDLE_EXCEPTION();
37591 }
37592 if (IS_UNUSED != IS_CONST) {
37593 CACHE_PTR(opline->result.num, ce);
37594 }
37595 }
37596 } else if (IS_UNUSED == IS_UNUSED) {
37597 ce = zend_fetch_class(NULL, opline->op1.num);
37598 if (UNEXPECTED(ce == NULL)) {
37599
37600 HANDLE_EXCEPTION();
37601 }
37602 } else {
37603 ce = Z_CE_P(EX_VAR(opline->op1.var));
37604 }
37605
37606 if (IS_UNUSED == IS_CONST &&
37607 IS_UNUSED == IS_CONST &&
37608 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
37609 /* nothing to do */
37610 } else if (IS_UNUSED != IS_CONST &&
37611 IS_UNUSED == IS_CONST &&
37612 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
37613 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
37614 } else if (IS_UNUSED != IS_UNUSED) {
37615 function_name = NULL;
37616 if (IS_UNUSED != IS_CONST) {
37617 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
37618 do {
37619 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
37620 function_name = Z_REFVAL_P(function_name);
37621 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
37622 break;
37623 }
37624 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
37625 ZVAL_UNDEFINED_OP2();
37626 if (UNEXPECTED(EG(exception) != NULL)) {
37627 HANDLE_EXCEPTION();
37628 }
37629 }
37630 zend_throw_error(NULL, "Method name must be a string");
37631
37632 HANDLE_EXCEPTION();
37633 } while (0);
37634 }
37635 }
37636
37637 if (ce->get_static_method) {
37638 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
37639 } else {
37640 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
37641 }
37642 if (UNEXPECTED(fbc == NULL)) {
37643 if (EXPECTED(!EG(exception))) {
37644 zend_undefined_method(ce, Z_STR_P(function_name));
37645 }
37646
37647 HANDLE_EXCEPTION();
37648 }
37649 if (IS_UNUSED == IS_CONST &&
37650 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
37651 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
37652 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
37653 }
37654 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37655 init_func_run_time_cache(&fbc->op_array);
37656 }
37657 if (IS_UNUSED != IS_CONST) {
37658
37659 }
37660 } else {
37661 if (UNEXPECTED(ce->constructor == NULL)) {
37662 zend_throw_error(NULL, "Cannot call constructor");
37663 HANDLE_EXCEPTION();
37664 }
37665 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
37666 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
37667 HANDLE_EXCEPTION();
37668 }
37669 fbc = ce->constructor;
37670 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
37671 init_func_run_time_cache(&fbc->op_array);
37672 }
37673 }
37674
37675 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
37676 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
37677 ce = (zend_class_entry*)Z_OBJ(EX(This));
37678 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
37679 } else {
37680 zend_non_static_method_call(fbc);
37681 HANDLE_EXCEPTION();
37682 }
37683 } else {
37684 /* previous opcode is ZEND_FETCH_CLASS */
37685 if (IS_UNUSED == IS_UNUSED
37686 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
37687 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
37688 if (Z_TYPE(EX(This)) == IS_OBJECT) {
37689 ce = Z_OBJCE(EX(This));
37690 } else {
37691 ce = Z_CE(EX(This));
37692 }
37693 }
37694 call_info = ZEND_CALL_NESTED_FUNCTION;
37695 }
37696
37697 call = zend_vm_stack_push_call_frame(call_info,
37698 fbc, opline->extended_value, ce);
37699 call->prev_execute_data = EX(call);
37700 EX(call) = call;
37701
37702 ZEND_VM_NEXT_OPCODE();
37703 }
37704
ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37705 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37706 {
37707 if (IS_UNUSED == IS_UNUSED) {
37708 SAVE_OPLINE();
37709 zend_verify_missing_return_type(EX(func));
37710 HANDLE_EXCEPTION();
37711 } else {
37712 /* prevents "undefined variable opline" errors */
37713 #if 0 || (IS_UNUSED != IS_UNUSED)
37714 USE_OPLINE
37715 zval *retval_ref, *retval_ptr;
37716 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
37717 retval_ref = retval_ptr = NULL;
37718
37719 if (IS_UNUSED == IS_CONST) {
37720 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
37721 retval_ref = retval_ptr = EX_VAR(opline->result.var);
37722 } else if (IS_UNUSED == IS_VAR) {
37723 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
37724 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
37725 }
37726 ZVAL_DEREF(retval_ptr);
37727 } else if (IS_UNUSED == IS_CV) {
37728 ZVAL_DEREF(retval_ptr);
37729 }
37730
37731 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
37732 ZEND_VM_NEXT_OPCODE();
37733 }
37734
37735 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
37736 SAVE_OPLINE();
37737 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
37738 if (UNEXPECTED(EG(exception))) {
37739 HANDLE_EXCEPTION();
37740 }
37741 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
37742 ZEND_VM_NEXT_OPCODE();
37743 }
37744 }
37745
37746 zend_reference *ref = NULL;
37747 void *cache_slot = CACHE_ADDR(opline->op2.num);
37748 if (UNEXPECTED(retval_ref != retval_ptr)) {
37749 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
37750 ref = Z_REF_P(retval_ref);
37751 } else {
37752 /* A cast might happen - unwrap the reference if this is a by-value return */
37753 if (Z_REFCOUNT_P(retval_ref) == 1) {
37754 ZVAL_UNREF(retval_ref);
37755 } else {
37756 Z_DELREF_P(retval_ref);
37757 ZVAL_COPY(retval_ref, retval_ptr);
37758 }
37759 retval_ptr = retval_ref;
37760 }
37761 }
37762
37763 SAVE_OPLINE();
37764 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
37765 zend_verify_return_error(EX(func), retval_ptr);
37766 HANDLE_EXCEPTION();
37767 }
37768 ZEND_VM_NEXT_OPCODE();
37769 #endif
37770 }
37771 }
37772
ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37773 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37774 {
37775 SAVE_OPLINE();
37776 zend_verify_never_error(EX(func));
37777 HANDLE_EXCEPTION();
37778 }
37779
ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37780 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37781 {
37782 USE_OPLINE
37783 uint32_t arg_num;
37784
37785 if (IS_UNUSED == IS_CONST) {
37786 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
37787 arg_num = zend_get_arg_offset_by_name(
37788 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
37789 if (UNEXPECTED(arg_num == 0)) {
37790 /* Treat this as a by-value argument, and throw an error during SEND. */
37791 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37792 ZEND_VM_NEXT_OPCODE();
37793 }
37794 } else {
37795 arg_num = opline->op2.num;
37796 }
37797
37798 if (EXPECTED(0)) {
37799 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37800 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37801 } else {
37802 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37803 }
37804 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37805 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37806 } else {
37807 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37808 }
37809 ZEND_VM_NEXT_OPCODE();
37810 }
37811
ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37812 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37813 {
37814 USE_OPLINE
37815 uint32_t arg_num;
37816
37817 if (IS_UNUSED == IS_CONST) {
37818 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
37819 arg_num = zend_get_arg_offset_by_name(
37820 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
37821 if (UNEXPECTED(arg_num == 0)) {
37822 /* Treat this as a by-value argument, and throw an error during SEND. */
37823 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37824 ZEND_VM_NEXT_OPCODE();
37825 }
37826 } else {
37827 arg_num = opline->op2.num;
37828 }
37829
37830 if (EXPECTED(1)) {
37831 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37832 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37833 } else {
37834 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37835 }
37836 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
37837 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37838 } else {
37839 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
37840 }
37841 ZEND_VM_NEXT_OPCODE();
37842 }
37843
ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37844 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37845 {
37846 USE_OPLINE
37847
37848 zend_execute_data *call = execute_data->call;
37849 if (EXPECTED(!(ZEND_CALL_INFO(call) & ZEND_CALL_MAY_HAVE_UNDEF))) {
37850 ZEND_VM_NEXT_OPCODE();
37851 }
37852
37853 SAVE_OPLINE();
37854 zend_handle_undef_args(call);
37855 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37856 }
37857
ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37858 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37859 {
37860 USE_OPLINE
37861 zval *result;
37862 zend_function *constructor;
37863 zend_class_entry *ce;
37864 zend_execute_data *call;
37865
37866 SAVE_OPLINE();
37867 if (IS_UNUSED == IS_CONST) {
37868 ce = CACHED_PTR(opline->op2.num);
37869 if (UNEXPECTED(ce == NULL)) {
37870 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);
37871 if (UNEXPECTED(ce == NULL)) {
37872 ZVAL_UNDEF(EX_VAR(opline->result.var));
37873 HANDLE_EXCEPTION();
37874 }
37875 CACHE_PTR(opline->op2.num, ce);
37876 }
37877 } else if (IS_UNUSED == IS_UNUSED) {
37878 ce = zend_fetch_class(NULL, opline->op1.num);
37879 if (UNEXPECTED(ce == NULL)) {
37880 ZVAL_UNDEF(EX_VAR(opline->result.var));
37881 HANDLE_EXCEPTION();
37882 }
37883 } else {
37884 ce = Z_CE_P(EX_VAR(opline->op1.var));
37885 }
37886
37887 result = EX_VAR(opline->result.var);
37888 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
37889 ZVAL_UNDEF(result);
37890 HANDLE_EXCEPTION();
37891 }
37892
37893 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
37894 if (constructor == NULL) {
37895 if (UNEXPECTED(EG(exception))) {
37896 HANDLE_EXCEPTION();
37897 }
37898
37899 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
37900 * opcode is DO_FCALL in case EXT instructions are used. */
37901 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
37902 ZEND_VM_NEXT_OPCODE_EX(1, 2);
37903 }
37904
37905 /* Perform a dummy function call */
37906 call = zend_vm_stack_push_call_frame(
37907 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
37908 opline->extended_value, NULL);
37909 } else {
37910 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
37911 init_func_run_time_cache(&constructor->op_array);
37912 }
37913 /* We are not handling overloaded classes right now */
37914 call = zend_vm_stack_push_call_frame(
37915 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
37916 constructor,
37917 opline->extended_value,
37918 Z_OBJ_P(result));
37919 Z_ADDREF_P(result);
37920 }
37921
37922 call->prev_execute_data = EX(call);
37923 EX(call) = call;
37924 ZEND_VM_NEXT_OPCODE();
37925 }
37926
ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37927 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37928 {
37929 zval *array;
37930 uint32_t size;
37931 USE_OPLINE
37932
37933 array = EX_VAR(opline->result.var);
37934 if (IS_UNUSED != IS_UNUSED) {
37935 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
37936 ZVAL_ARR(array, zend_new_array(size));
37937 /* Explicitly initialize array as not-packed if flag is set */
37938 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
37939 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
37940 }
37941 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37942 } else {
37943 ZVAL_ARR(array, zend_new_array(0));
37944 ZEND_VM_NEXT_OPCODE();
37945 }
37946 }
37947
ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37948 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37949 {
37950 USE_OPLINE
37951
37952 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
37953
37954 SAVE_OPLINE();
37955 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
37956 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37957 }
37958
37959 /* Destroy the previously yielded value */
37960 zval_ptr_dtor(&generator->value);
37961
37962 /* Destroy the previously yielded key */
37963 zval_ptr_dtor(&generator->key);
37964
37965 /* Set the new yielded value */
37966 if (IS_UNUSED != IS_UNUSED) {
37967 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
37968 /* Constants and temporary variables aren't yieldable by reference,
37969 * but we still allow them with a notice. */
37970 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
37971 zval *value;
37972
37973 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37974
37975 value = NULL;
37976 ZVAL_COPY_VALUE(&generator->value, value);
37977 if (IS_UNUSED == IS_CONST) {
37978 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37979 Z_ADDREF(generator->value);
37980 }
37981 }
37982 } else {
37983 zval *value_ptr = NULL;
37984
37985 /* If a function call result is yielded and the function did
37986 * not return by reference we throw a notice. */
37987 do {
37988 if (IS_UNUSED == IS_VAR) {
37989 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
37990 if (opline->extended_value == ZEND_RETURNS_FUNCTION
37991 && !Z_ISREF_P(value_ptr)) {
37992 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37993 ZVAL_COPY(&generator->value, value_ptr);
37994 break;
37995 }
37996 }
37997 if (Z_ISREF_P(value_ptr)) {
37998 Z_ADDREF_P(value_ptr);
37999 } else {
38000 ZVAL_MAKE_REF_EX(value_ptr, 2);
38001 }
38002 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
38003 } while (0);
38004
38005 }
38006 } else {
38007 zval *value = NULL;
38008
38009 /* Consts, temporary variables and references need copying */
38010 if (IS_UNUSED == IS_CONST) {
38011 ZVAL_COPY_VALUE(&generator->value, value);
38012 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
38013 Z_ADDREF(generator->value);
38014 }
38015 } else if (IS_UNUSED == IS_TMP_VAR) {
38016 ZVAL_COPY_VALUE(&generator->value, value);
38017 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
38018 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
38019
38020 } else {
38021 ZVAL_COPY_VALUE(&generator->value, value);
38022 if (IS_UNUSED == IS_CV) {
38023 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
38024 }
38025 }
38026 }
38027 } else {
38028 /* If no value was specified yield null */
38029 ZVAL_NULL(&generator->value);
38030 }
38031
38032 /* Set the new yielded key */
38033 if (IS_UNUSED != IS_UNUSED) {
38034 zval *key = NULL;
38035 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
38036 key = Z_REFVAL_P(key);
38037 }
38038 ZVAL_COPY(&generator->key, key);
38039
38040 if (Z_TYPE(generator->key) == IS_LONG
38041 && Z_LVAL(generator->key) > generator->largest_used_integer_key
38042 ) {
38043 generator->largest_used_integer_key = Z_LVAL(generator->key);
38044 }
38045 } else {
38046 /* If no key was specified we use auto-increment keys */
38047 generator->largest_used_integer_key++;
38048 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
38049 }
38050
38051 if (RETURN_VALUE_USED(opline)) {
38052 /* If the return value of yield is used set the send
38053 * target and initialize it to NULL */
38054 generator->send_target = EX_VAR(opline->result.var);
38055 ZVAL_NULL(generator->send_target);
38056 } else {
38057 generator->send_target = NULL;
38058 }
38059
38060 /* The GOTO VM uses a local opline variable. We need to set the opline
38061 * variable in execute_data so we don't resume at an old position. */
38062 SAVE_OPLINE();
38063
38064 ZEND_VM_RETURN();
38065 }
38066
ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38067 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38068 {
38069 USE_OPLINE
38070
38071 if (EXPECTED(Z_TYPE(EX(This)) == IS_OBJECT)) {
38072 zval *result = EX_VAR(opline->result.var);
38073
38074 ZVAL_OBJ(result, Z_OBJ(EX(This)));
38075 Z_ADDREF_P(result);
38076 ZEND_VM_NEXT_OPCODE();
38077 } else {
38078 ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38079 }
38080 }
38081
ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38082 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38083 {
38084 USE_OPLINE
38085
38086 /* For symbol tables we need to deal with exactly the same problems as for property tables. */
38087 ZVAL_ARR(EX_VAR(opline->result.var),
38088 zend_proptable_to_symtable(&EG(symbol_table), /* always_duplicate */ 1));
38089 ZEND_VM_NEXT_OPCODE();
38090 }
38091
ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38092 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38093 {
38094 USE_OPLINE
38095
38096 ZVAL_BOOL(EX_VAR(opline->result.var),
38097 (opline->extended_value & ZEND_ISEMPTY) ^
38098 (Z_TYPE(EX(This)) == IS_OBJECT));
38099 ZEND_VM_NEXT_OPCODE();
38100 }
38101
ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38102 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38103 {
38104 USE_OPLINE
38105
38106 if (IS_UNUSED == IS_UNUSED) {
38107 SAVE_OPLINE();
38108 if (UNEXPECTED(!EX(func)->common.scope)) {
38109 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
38110 ZVAL_UNDEF(EX_VAR(opline->result.var));
38111 HANDLE_EXCEPTION();
38112 } else {
38113 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
38114 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
38115 if (UNEXPECTED(EG(exception))) {
38116 HANDLE_EXCEPTION();
38117 }
38118 ZEND_VM_NEXT_OPCODE();
38119 }
38120 } else {
38121 zval *op1;
38122
38123 SAVE_OPLINE();
38124 op1 = NULL;
38125 while (1) {
38126 if (Z_TYPE_P(op1) == IS_OBJECT) {
38127 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
38128 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
38129 op1 = Z_REFVAL_P(op1);
38130 continue;
38131 } else {
38132 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
38133 ZVAL_UNDEFINED_OP1();
38134 }
38135 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
38136 ZVAL_UNDEF(EX_VAR(opline->result.var));
38137 }
38138 break;
38139 }
38140
38141 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38142 }
38143 }
38144
ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38145 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38146 {
38147 USE_OPLINE
38148
38149 if (Z_TYPE(EX(This)) == IS_OBJECT) {
38150 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name);
38151 } else if (Z_CE(EX(This))) {
38152 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name);
38153 } else {
38154 ZEND_ASSERT(!EX(func)->common.scope);
38155 SAVE_OPLINE();
38156 zend_throw_error(NULL, "get_called_class() must be called from within a class");
38157 ZVAL_UNDEF(EX_VAR(opline->result.var));
38158 HANDLE_EXCEPTION();
38159 }
38160 ZEND_VM_NEXT_OPCODE();
38161 }
38162
ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38163 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38164 {
38165 USE_OPLINE
38166
38167 ZVAL_LONG(EX_VAR(opline->result.var), EX_NUM_ARGS());
38168 ZEND_VM_NEXT_OPCODE();
38169 }
38170
ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38171 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38172 {
38173 USE_OPLINE
38174 zend_array *ht;
38175 uint32_t arg_count, result_size, skip;
38176
38177 arg_count = EX_NUM_ARGS();
38178 if (IS_UNUSED == IS_CONST) {
38179 skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
38180 if (arg_count < skip) {
38181 result_size = 0;
38182 } else {
38183 result_size = arg_count - skip;
38184 }
38185 } else {
38186 skip = 0;
38187 result_size = arg_count;
38188 }
38189
38190 if (result_size) {
38191 SAVE_OPLINE();
38192 uint32_t first_extra_arg = EX(func)->op_array.num_args;
38193
38194 ht = zend_new_array(result_size);
38195 ZVAL_ARR(EX_VAR(opline->result.var), ht);
38196 zend_hash_real_init_packed(ht);
38197 ZEND_HASH_FILL_PACKED(ht) {
38198 zval *p, *q;
38199 uint32_t i = skip;
38200 p = EX_VAR_NUM(i);
38201 if (arg_count > first_extra_arg) {
38202 while (i < first_extra_arg) {
38203 q = p;
38204 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
38205 ZVAL_DEREF(q);
38206 if (Z_OPT_REFCOUNTED_P(q)) {
38207 Z_ADDREF_P(q);
38208 }
38209 ZEND_HASH_FILL_SET(q);
38210 } else {
38211 ZEND_HASH_FILL_SET_NULL();
38212 }
38213 ZEND_HASH_FILL_NEXT();
38214 p++;
38215 i++;
38216 }
38217 if (skip < first_extra_arg) {
38218 skip = 0;
38219 } else {
38220 skip -= first_extra_arg;
38221 }
38222 p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
38223 }
38224 while (i < arg_count) {
38225 q = p;
38226 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
38227 ZVAL_DEREF(q);
38228 if (Z_OPT_REFCOUNTED_P(q)) {
38229 Z_ADDREF_P(q);
38230 }
38231 ZEND_HASH_FILL_SET(q);
38232 } else {
38233 ZEND_HASH_FILL_SET_NULL();
38234 }
38235 ZEND_HASH_FILL_NEXT();
38236 p++;
38237 i++;
38238 }
38239 } ZEND_HASH_FILL_END();
38240 ht->nNumOfElements = result_size;
38241 } else {
38242 ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
38243 }
38244 ZEND_VM_NEXT_OPCODE();
38245 }
38246
38247 /* Contrary to what its name indicates, ZEND_COPY_TMP may receive and define references. */
ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38248 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38249 {
38250 USE_OPLINE
38251 zend_execute_data *call = EX(call);
38252
38253 zend_closure_from_frame(EX_VAR(opline->result.var), call);
38254
38255 if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) {
38256 OBJ_RELEASE(Z_OBJ(call->This));
38257 }
38258
38259 EX(call) = call->prev_execute_data;
38260
38261 zend_vm_stack_free_call_frame(call);
38262
38263 ZEND_VM_NEXT_OPCODE();
38264 }
38265
ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38266 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38267 {
38268 USE_OPLINE
38269 SAVE_OPLINE();
38270
38271 zval *result = EX_VAR(opline->result.var);
38272 ZVAL_NULL(result);
38273
38274 #if 0 || 0
38275 if (0 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
38276 zend_frameless_observed_call(execute_data);
38277 } else
38278 #endif
38279 {
38280 zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline);
38281 function(EX_VAR(opline->result.var));
38282 }
38283 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38284 }
38285
ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38286 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38287 {
38288 USE_OPLINE
38289 SAVE_OPLINE();
38290
38291 zval *result = EX_VAR(opline->result.var);
38292 ZVAL_NULL(result);
38293
38294 #if 0 || 1
38295 if (1 && UNEXPECTED(zend_observer_handler_is_unobserved(ZEND_OBSERVER_DATA(ZEND_FLF_FUNC(opline))) == false)) {
38296 zend_frameless_observed_call(execute_data);
38297 } else
38298 #endif
38299 {
38300 zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline);
38301 function(EX_VAR(opline->result.var));
38302 }
38303 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38304 }
38305
ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38306 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38307 {
38308 USE_OPLINE
38309 zval *object;
38310 zval *property;
38311 zval *value;
38312 zval *zptr;
38313 void *_cache_slot[3] = {0};
38314 void **cache_slot;
38315 zend_property_info *prop_info;
38316 zend_object *zobj;
38317 zend_string *name, *tmp_name;
38318
38319 SAVE_OPLINE();
38320 object = &EX(This);
38321 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38322
38323 do {
38324 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
38325
38326 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38327 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38328 object = Z_REFVAL_P(object);
38329 goto assign_op_object;
38330 }
38331 if (IS_UNUSED == IS_CV
38332 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38333 ZVAL_UNDEFINED_OP1();
38334 }
38335 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38336 break;
38337 }
38338
38339 assign_op_object:
38340 /* here we are sure we are dealing with an object */
38341 zobj = Z_OBJ_P(object);
38342 if (IS_CV == IS_CONST) {
38343 name = Z_STR_P(property);
38344 } else {
38345 name = zval_try_get_tmp_string(property, &tmp_name);
38346 if (UNEXPECTED(!name)) {
38347 UNDEF_RESULT();
38348 break;
38349 }
38350 }
38351 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
38352 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38353 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38354 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38355 ZVAL_NULL(EX_VAR(opline->result.var));
38356 }
38357 } else {
38358 zend_reference *ref;
38359
38360 do {
38361 if (UNEXPECTED(Z_ISREF_P(zptr))) {
38362 ref = Z_REF_P(zptr);
38363 zptr = Z_REFVAL_P(zptr);
38364 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
38365 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
38366 break;
38367 }
38368 }
38369
38370 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
38371 if (prop_info) {
38372 /* special case for typed properties */
38373 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
38374 } else {
38375 zend_binary_op(zptr, zptr, value OPLINE_CC);
38376 }
38377 } while (0);
38378
38379 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38380 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
38381 }
38382 }
38383 } else {
38384 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
38385 }
38386 if (IS_CV != IS_CONST) {
38387 zend_tmp_string_release(tmp_name);
38388 }
38389 } while (0);
38390
38391 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
38392
38393
38394 /* assign_obj has two opcodes! */
38395 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38396 }
38397
38398 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38399 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38400 {
38401 USE_OPLINE
38402 zval *object;
38403 zval *property;
38404 zval *zptr;
38405 void *_cache_slot[3] = {0};
38406 void **cache_slot;
38407 zend_property_info *prop_info;
38408 zend_object *zobj;
38409 zend_string *name, *tmp_name;
38410
38411 SAVE_OPLINE();
38412 object = &EX(This);
38413 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38414
38415 do {
38416 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38417 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38418 object = Z_REFVAL_P(object);
38419 goto pre_incdec_object;
38420 }
38421 if (IS_UNUSED == IS_CV
38422 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38423 ZVAL_UNDEFINED_OP1();
38424 }
38425 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38426 break;
38427 }
38428
38429 pre_incdec_object:
38430 /* here we are sure we are dealing with an object */
38431 zobj = Z_OBJ_P(object);
38432 if (IS_CV == IS_CONST) {
38433 name = Z_STR_P(property);
38434 } else {
38435 name = zval_try_get_tmp_string(property, &tmp_name);
38436 if (UNEXPECTED(!name)) {
38437 UNDEF_RESULT();
38438 break;
38439 }
38440 }
38441 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
38442 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38443 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38444 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38445 ZVAL_NULL(EX_VAR(opline->result.var));
38446 }
38447 } else {
38448 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
38449 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
38450 }
38451 } else {
38452 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
38453 }
38454 if (IS_CV != IS_CONST) {
38455 zend_tmp_string_release(tmp_name);
38456 }
38457 } while (0);
38458
38459
38460 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38461 }
38462
ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38463 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38464 {
38465 USE_OPLINE
38466 zval *object;
38467 zval *property;
38468 zval *zptr;
38469 void *_cache_slot[3] = {0};
38470 void **cache_slot;
38471 zend_property_info *prop_info;
38472 zend_object *zobj;
38473 zend_string *name, *tmp_name;
38474
38475 SAVE_OPLINE();
38476 object = &EX(This);
38477 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38478
38479 do {
38480 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38481 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38482 object = Z_REFVAL_P(object);
38483 goto post_incdec_object;
38484 }
38485 if (IS_UNUSED == IS_CV
38486 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38487 ZVAL_UNDEFINED_OP1();
38488 }
38489 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
38490 break;
38491 }
38492
38493 post_incdec_object:
38494 /* here we are sure we are dealing with an object */
38495 zobj = Z_OBJ_P(object);
38496 if (IS_CV == IS_CONST) {
38497 name = Z_STR_P(property);
38498 } else {
38499 name = zval_try_get_tmp_string(property, &tmp_name);
38500 if (UNEXPECTED(!name)) {
38501 ZVAL_UNDEF(EX_VAR(opline->result.var));
38502 break;
38503 }
38504 }
38505 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
38506 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
38507 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
38508 ZVAL_NULL(EX_VAR(opline->result.var));
38509 } else {
38510 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
38511 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
38512 }
38513 } else {
38514 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
38515 }
38516 if (IS_CV != IS_CONST) {
38517 zend_tmp_string_release(tmp_name);
38518 }
38519 } while (0);
38520
38521
38522 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38523 }
38524
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38525 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38526 {
38527 USE_OPLINE
38528 zval *container;
38529 void **cache_slot = NULL;
38530
38531 SAVE_OPLINE();
38532 container = &EX(This);
38533
38534 if (IS_UNUSED == IS_CONST ||
38535 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
38536 do {
38537 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
38538 container = Z_REFVAL_P(container);
38539 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
38540 break;
38541 }
38542 }
38543 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
38544 ZVAL_UNDEFINED_OP1();
38545 }
38546 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38547 ZVAL_NULL(EX_VAR(opline->result.var));
38548 goto fetch_obj_r_finish;
38549 } while (0);
38550 }
38551
38552 /* here we are sure we are dealing with an object */
38553 do {
38554 zend_object *zobj = Z_OBJ_P(container);
38555 zend_string *name, *tmp_name;
38556 zval *retval;
38557
38558 if (IS_CV == IS_CONST) {
38559 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
38560
38561 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
38562 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38563
38564 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38565 fetch_obj_r_simple:
38566 retval = OBJ_PROP(zobj, prop_offset);
38567 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
38568 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38569 goto fetch_obj_r_copy;
38570 } else {
38571 fetch_obj_r_fast_copy:
38572 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38573 ZEND_VM_NEXT_OPCODE();
38574 }
38575 }
38576 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
38577 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
38578 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
38579 prop_offset = prop_info->offset;
38580 goto fetch_obj_r_simple;
38581 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
38582 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
38583 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
38584 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
38585
38586 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
38587 if (IS_UNUSED & IS_CV) {
38588 GC_ADDREF(zobj);
38589 }
38590 if (IS_UNUSED & (IS_CV|IS_VAR|IS_TMP_VAR)) {
38591 call_info |= ZEND_CALL_RELEASE_THIS;
38592 }
38593 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
38594 call->prev_execute_data = execute_data;
38595 call->call = NULL;
38596 call->return_value = EX_VAR(opline->result.var);
38597 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
38598
38599 execute_data = call;
38600 EG(current_execute_data) = execute_data;
38601 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
38602
38603 #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
38604 opline = hook->op_array.opcodes;
38605 #else
38606 EX(opline) = hook->op_array.opcodes;
38607 #endif
38608 LOAD_OPLINE_EX();
38609
38610
38611 ZEND_VM_ENTER_EX();
38612 }
38613 /* Fall through to read_property for hooks. */
38614 } else if (EXPECTED(zobj->properties != NULL)) {
38615 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
38616 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38617 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
38618 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
38619
38620 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
38621 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
38622
38623 if (EXPECTED(p->key == name) ||
38624 (EXPECTED(p->h == ZSTR_H(name)) &&
38625 EXPECTED(p->key != NULL) &&
38626 EXPECTED(zend_string_equal_content(p->key, name)))) {
38627 retval = &p->val;
38628 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38629 goto fetch_obj_r_copy;
38630 } else {
38631 goto fetch_obj_r_fast_copy;
38632 }
38633 }
38634 }
38635 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
38636 }
38637 retval = zend_hash_find_known_hash(zobj->properties, name);
38638 if (EXPECTED(retval)) {
38639 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
38640 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
38641 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38642 goto fetch_obj_r_copy;
38643 } else {
38644 goto fetch_obj_r_fast_copy;
38645 }
38646 }
38647 }
38648 }
38649 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38650 } else {
38651 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38652 if (UNEXPECTED(!name)) {
38653 ZVAL_UNDEF(EX_VAR(opline->result.var));
38654 break;
38655 }
38656 }
38657
38658 #if ZEND_DEBUG
38659 /* For non-standard object handlers, verify a declared property type in debug builds.
38660 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
38661 zend_property_info *prop_info = NULL;
38662 if (zobj->handlers->read_property != zend_std_read_property) {
38663 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
38664 }
38665 #endif
38666 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
38667 #if ZEND_DEBUG
38668 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
38669 && ZEND_TYPE_IS_SET(prop_info->type)) {
38670 ZVAL_OPT_DEREF(retval);
38671 zend_verify_property_type(prop_info, retval, /* strict */ true);
38672 }
38673 #endif
38674
38675 if (IS_CV != IS_CONST) {
38676 zend_tmp_string_release(tmp_name);
38677 }
38678
38679 if (retval != EX_VAR(opline->result.var)) {
38680 fetch_obj_r_copy:
38681 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38682 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
38683 zend_unwrap_reference(retval);
38684 }
38685 } while (0);
38686
38687 fetch_obj_r_finish:
38688
38689
38690 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38691 }
38692
ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38693 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38694 {
38695 USE_OPLINE
38696 zval *property, *container, *result;
38697
38698 SAVE_OPLINE();
38699
38700 container = &EX(This);
38701 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38702 result = EX_VAR(opline->result.var);
38703 zend_fetch_property_address(
38704 result, container, IS_UNUSED, property, IS_CV,
38705 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
38706 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
38707
38708 if (IS_UNUSED == IS_VAR) {
38709 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
38710 }
38711 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38712 }
38713
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38714 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38715 {
38716 USE_OPLINE
38717 zval *property, *container, *result;
38718
38719 SAVE_OPLINE();
38720 container = &EX(This);
38721 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38722 result = EX_VAR(opline->result.var);
38723 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);
38724
38725 if (IS_UNUSED == IS_VAR) {
38726 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
38727 }
38728 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38729 }
38730
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38731 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38732 {
38733 USE_OPLINE
38734 zval *container;
38735 void **cache_slot = NULL;
38736
38737 SAVE_OPLINE();
38738 container = &EX(This);
38739
38740 if (IS_UNUSED == IS_CONST ||
38741 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
38742 do {
38743 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
38744 container = Z_REFVAL_P(container);
38745 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
38746 break;
38747 }
38748 }
38749 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
38750 ZVAL_UNDEFINED_OP2();
38751 }
38752 ZVAL_NULL(EX_VAR(opline->result.var));
38753 goto fetch_obj_is_finish;
38754 } while (0);
38755 }
38756
38757 /* here we are sure we are dealing with an object */
38758 do {
38759 zend_object *zobj = Z_OBJ_P(container);
38760 zend_string *name, *tmp_name;
38761 zval *retval;
38762
38763 if (IS_CV == IS_CONST) {
38764 cache_slot = CACHE_ADDR(opline->extended_value);
38765
38766 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
38767 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38768
38769 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38770 fetch_obj_is_simple:
38771 retval = OBJ_PROP(zobj, prop_offset);
38772 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
38773 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38774 goto fetch_obj_is_copy;
38775 } else {
38776 fetch_obj_is_fast_copy:
38777 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38778 ZEND_VM_NEXT_OPCODE();
38779 }
38780 }
38781 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
38782 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
38783 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
38784 prop_offset = prop_info->offset;
38785 goto fetch_obj_is_simple;
38786 }
38787 /* Fall through to read_property for hooks. */
38788 } else if (EXPECTED(zobj->properties != NULL)) {
38789 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
38790 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38791 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
38792 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
38793
38794 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
38795 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
38796
38797 if (EXPECTED(p->key == name) ||
38798 (EXPECTED(p->h == ZSTR_H(name)) &&
38799 EXPECTED(p->key != NULL) &&
38800 EXPECTED(zend_string_equal_content(p->key, name)))) {
38801 retval = &p->val;
38802 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38803 goto fetch_obj_is_copy;
38804 } else {
38805 goto fetch_obj_is_fast_copy;
38806 }
38807 }
38808 }
38809 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
38810 }
38811 retval = zend_hash_find_known_hash(zobj->properties, name);
38812 if (EXPECTED(retval)) {
38813 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
38814 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
38815 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
38816 goto fetch_obj_is_copy;
38817 } else {
38818 goto fetch_obj_is_fast_copy;
38819 }
38820 }
38821 }
38822 }
38823 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38824 } else {
38825 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38826 if (UNEXPECTED(!name)) {
38827 ZVAL_UNDEF(EX_VAR(opline->result.var));
38828 break;
38829 }
38830 }
38831
38832 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
38833
38834 if (IS_CV != IS_CONST) {
38835 zend_tmp_string_release(tmp_name);
38836 }
38837
38838 if (retval != EX_VAR(opline->result.var)) {
38839 fetch_obj_is_copy:
38840 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
38841 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
38842 zend_unwrap_reference(retval);
38843 }
38844 } while (0);
38845
38846 fetch_obj_is_finish:
38847
38848
38849 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38850 }
38851
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38852 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38853 {
38854 #if 0
38855 USE_OPLINE
38856 #endif
38857
38858 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
38859 /* Behave like FETCH_OBJ_W */
38860 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
38861 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38862 }
38863 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38864 } else {
38865 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38866 }
38867 }
38868
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38869 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38870 {
38871 USE_OPLINE
38872 zval *container, *property, *result;
38873
38874 SAVE_OPLINE();
38875 container = &EX(This);
38876 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38877 result = EX_VAR(opline->result.var);
38878 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);
38879
38880 if (IS_UNUSED == IS_VAR) {
38881 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
38882 }
38883 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38884 }
38885
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38886 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38887 {
38888 USE_OPLINE
38889 zval *object, *value, tmp;
38890 zend_object *zobj;
38891 zend_string *name, *tmp_name;
38892 zend_refcounted *garbage = NULL;
38893
38894 SAVE_OPLINE();
38895 object = &EX(This);
38896 value = RT_CONSTANT((opline+1), (opline+1)->op1);
38897
38898 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38899 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38900 object = Z_REFVAL_P(object);
38901 goto assign_object;
38902 }
38903 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
38904 value = &EG(uninitialized_zval);
38905 goto free_and_exit_assign_obj;
38906 }
38907
38908 assign_object:
38909 zobj = Z_OBJ_P(object);
38910 if (IS_CV == IS_CONST) {
38911 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
38912 void **cache_slot = CACHE_ADDR(opline->extended_value);
38913 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38914 zval *property_val;
38915
38916 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38917 property_val = OBJ_PROP(zobj, prop_offset);
38918 if (Z_TYPE_P(property_val) != IS_UNDEF) {
38919 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
38920
38921 if (prop_info != NULL) {
38922 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
38923 goto free_and_exit_assign_obj;
38924 } else {
38925 fast_assign_obj:
38926 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
38927 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38928 ZVAL_COPY(EX_VAR(opline->result.var), value);
38929 }
38930 goto exit_assign_obj;
38931 }
38932 }
38933 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
38934 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38935 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
38936 zobj = zend_lazy_object_init(zobj);
38937 if (!zobj) {
38938 value = &EG(uninitialized_zval);
38939 goto free_and_exit_assign_obj;
38940 }
38941 }
38942 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
38943 rebuild_object_properties_internal(zobj);
38944 }
38945 if (EXPECTED(zobj->properties != NULL)) {
38946 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
38947 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
38948 GC_DELREF(zobj->properties);
38949 }
38950 zobj->properties = zend_array_dup(zobj->properties);
38951 }
38952 property_val = zend_hash_find_known_hash(zobj->properties, name);
38953 if (property_val) {
38954 goto fast_assign_obj;
38955 }
38956 }
38957
38958 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
38959 if (IS_CONST == IS_CONST) {
38960 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
38961 Z_ADDREF_P(value);
38962 }
38963 } else if (IS_CONST != IS_TMP_VAR) {
38964 if (Z_ISREF_P(value)) {
38965 if (IS_CONST == IS_VAR) {
38966 zend_reference *ref = Z_REF_P(value);
38967 if (GC_DELREF(ref) == 0) {
38968 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
38969 efree_size(ref, sizeof(zend_reference));
38970 value = &tmp;
38971 } else {
38972 value = Z_REFVAL_P(value);
38973 Z_TRY_ADDREF_P(value);
38974 }
38975 } else {
38976 value = Z_REFVAL_P(value);
38977 Z_TRY_ADDREF_P(value);
38978 }
38979 } else if (IS_CONST == IS_CV) {
38980 Z_TRY_ADDREF_P(value);
38981 }
38982 }
38983 zend_hash_add_new(zobj->properties, name, value);
38984 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38985 ZVAL_COPY(EX_VAR(opline->result.var), value);
38986 }
38987 goto exit_assign_obj;
38988 }
38989 } else {
38990 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
38991 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
38992 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
38993 property_val = OBJ_PROP(zobj, prop_info->offset);
38994 if (ZEND_TYPE_IS_SET(prop_info->type)) {
38995 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
38996 goto free_and_exit_assign_obj;
38997 } else {
38998 goto fast_assign_obj;
38999 }
39000 }
39001 /* Fall through to write_property for hooks. */
39002 }
39003 }
39004 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39005 } else {
39006 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39007 if (UNEXPECTED(!name)) {
39008
39009 UNDEF_RESULT();
39010 goto exit_assign_obj;
39011 }
39012 }
39013
39014 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
39015 ZVAL_DEREF(value);
39016 }
39017
39018 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39019
39020 if (IS_CV != IS_CONST) {
39021 zend_tmp_string_release(tmp_name);
39022 }
39023
39024 free_and_exit_assign_obj:
39025 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39026 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39027 }
39028
39029 exit_assign_obj:
39030 if (garbage) {
39031 GC_DTOR_NO_REF(garbage);
39032 }
39033
39034
39035 /* assign_obj has two opcodes! */
39036 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39037 }
39038
39039 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39040 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39041 {
39042 USE_OPLINE
39043 zval *object, *value, tmp;
39044 zend_object *zobj;
39045 zend_string *name, *tmp_name;
39046 zend_refcounted *garbage = NULL;
39047
39048 SAVE_OPLINE();
39049 object = &EX(This);
39050 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
39051
39052 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39053 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39054 object = Z_REFVAL_P(object);
39055 goto assign_object;
39056 }
39057 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
39058 value = &EG(uninitialized_zval);
39059 goto free_and_exit_assign_obj;
39060 }
39061
39062 assign_object:
39063 zobj = Z_OBJ_P(object);
39064 if (IS_CV == IS_CONST) {
39065 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39066 void **cache_slot = CACHE_ADDR(opline->extended_value);
39067 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39068 zval *property_val;
39069
39070 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39071 property_val = OBJ_PROP(zobj, prop_offset);
39072 if (Z_TYPE_P(property_val) != IS_UNDEF) {
39073 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39074
39075 if (prop_info != NULL) {
39076 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39077 goto free_and_exit_assign_obj;
39078 } else {
39079 fast_assign_obj:
39080 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
39081 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39082 ZVAL_COPY(EX_VAR(opline->result.var), value);
39083 }
39084 goto exit_assign_obj;
39085 }
39086 }
39087 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39088 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39089 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39090 zobj = zend_lazy_object_init(zobj);
39091 if (!zobj) {
39092 value = &EG(uninitialized_zval);
39093 goto free_and_exit_assign_obj;
39094 }
39095 }
39096 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39097 rebuild_object_properties_internal(zobj);
39098 }
39099 if (EXPECTED(zobj->properties != NULL)) {
39100 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39101 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39102 GC_DELREF(zobj->properties);
39103 }
39104 zobj->properties = zend_array_dup(zobj->properties);
39105 }
39106 property_val = zend_hash_find_known_hash(zobj->properties, name);
39107 if (property_val) {
39108 goto fast_assign_obj;
39109 }
39110 }
39111
39112 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39113 if (IS_TMP_VAR == IS_CONST) {
39114 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39115 Z_ADDREF_P(value);
39116 }
39117 } else if (IS_TMP_VAR != IS_TMP_VAR) {
39118 if (Z_ISREF_P(value)) {
39119 if (IS_TMP_VAR == IS_VAR) {
39120 zend_reference *ref = Z_REF_P(value);
39121 if (GC_DELREF(ref) == 0) {
39122 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39123 efree_size(ref, sizeof(zend_reference));
39124 value = &tmp;
39125 } else {
39126 value = Z_REFVAL_P(value);
39127 Z_TRY_ADDREF_P(value);
39128 }
39129 } else {
39130 value = Z_REFVAL_P(value);
39131 Z_TRY_ADDREF_P(value);
39132 }
39133 } else if (IS_TMP_VAR == IS_CV) {
39134 Z_TRY_ADDREF_P(value);
39135 }
39136 }
39137 zend_hash_add_new(zobj->properties, name, value);
39138 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39139 ZVAL_COPY(EX_VAR(opline->result.var), value);
39140 }
39141 goto exit_assign_obj;
39142 }
39143 } else {
39144 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39145 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39146 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
39147 property_val = OBJ_PROP(zobj, prop_info->offset);
39148 if (ZEND_TYPE_IS_SET(prop_info->type)) {
39149 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39150 goto free_and_exit_assign_obj;
39151 } else {
39152 goto fast_assign_obj;
39153 }
39154 }
39155 /* Fall through to write_property for hooks. */
39156 }
39157 }
39158 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39159 } else {
39160 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39161 if (UNEXPECTED(!name)) {
39162 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39163 UNDEF_RESULT();
39164 goto exit_assign_obj;
39165 }
39166 }
39167
39168 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
39169 ZVAL_DEREF(value);
39170 }
39171
39172 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39173
39174 if (IS_CV != IS_CONST) {
39175 zend_tmp_string_release(tmp_name);
39176 }
39177
39178 free_and_exit_assign_obj:
39179 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39180 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39181 }
39182 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39183 exit_assign_obj:
39184 if (garbage) {
39185 GC_DTOR_NO_REF(garbage);
39186 }
39187
39188
39189 /* assign_obj has two opcodes! */
39190 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39191 }
39192
39193 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39194 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39195 {
39196 USE_OPLINE
39197 zval *object, *value, tmp;
39198 zend_object *zobj;
39199 zend_string *name, *tmp_name;
39200 zend_refcounted *garbage = NULL;
39201
39202 SAVE_OPLINE();
39203 object = &EX(This);
39204 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
39205
39206 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39207 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39208 object = Z_REFVAL_P(object);
39209 goto assign_object;
39210 }
39211 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
39212 value = &EG(uninitialized_zval);
39213 goto free_and_exit_assign_obj;
39214 }
39215
39216 assign_object:
39217 zobj = Z_OBJ_P(object);
39218 if (IS_CV == IS_CONST) {
39219 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39220 void **cache_slot = CACHE_ADDR(opline->extended_value);
39221 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39222 zval *property_val;
39223
39224 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39225 property_val = OBJ_PROP(zobj, prop_offset);
39226 if (Z_TYPE_P(property_val) != IS_UNDEF) {
39227 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39228
39229 if (prop_info != NULL) {
39230 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39231 goto free_and_exit_assign_obj;
39232 } else {
39233 fast_assign_obj:
39234 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
39235 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39236 ZVAL_COPY(EX_VAR(opline->result.var), value);
39237 }
39238 goto exit_assign_obj;
39239 }
39240 }
39241 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39242 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39243 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39244 zobj = zend_lazy_object_init(zobj);
39245 if (!zobj) {
39246 value = &EG(uninitialized_zval);
39247 goto free_and_exit_assign_obj;
39248 }
39249 }
39250 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39251 rebuild_object_properties_internal(zobj);
39252 }
39253 if (EXPECTED(zobj->properties != NULL)) {
39254 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39255 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39256 GC_DELREF(zobj->properties);
39257 }
39258 zobj->properties = zend_array_dup(zobj->properties);
39259 }
39260 property_val = zend_hash_find_known_hash(zobj->properties, name);
39261 if (property_val) {
39262 goto fast_assign_obj;
39263 }
39264 }
39265
39266 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39267 if (IS_VAR == IS_CONST) {
39268 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39269 Z_ADDREF_P(value);
39270 }
39271 } else if (IS_VAR != IS_TMP_VAR) {
39272 if (Z_ISREF_P(value)) {
39273 if (IS_VAR == IS_VAR) {
39274 zend_reference *ref = Z_REF_P(value);
39275 if (GC_DELREF(ref) == 0) {
39276 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39277 efree_size(ref, sizeof(zend_reference));
39278 value = &tmp;
39279 } else {
39280 value = Z_REFVAL_P(value);
39281 Z_TRY_ADDREF_P(value);
39282 }
39283 } else {
39284 value = Z_REFVAL_P(value);
39285 Z_TRY_ADDREF_P(value);
39286 }
39287 } else if (IS_VAR == IS_CV) {
39288 Z_TRY_ADDREF_P(value);
39289 }
39290 }
39291 zend_hash_add_new(zobj->properties, name, value);
39292 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39293 ZVAL_COPY(EX_VAR(opline->result.var), value);
39294 }
39295 goto exit_assign_obj;
39296 }
39297 } else {
39298 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39299 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39300 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
39301 property_val = OBJ_PROP(zobj, prop_info->offset);
39302 if (ZEND_TYPE_IS_SET(prop_info->type)) {
39303 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39304 goto free_and_exit_assign_obj;
39305 } else {
39306 goto fast_assign_obj;
39307 }
39308 }
39309 /* Fall through to write_property for hooks. */
39310 }
39311 }
39312 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39313 } else {
39314 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39315 if (UNEXPECTED(!name)) {
39316 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39317 UNDEF_RESULT();
39318 goto exit_assign_obj;
39319 }
39320 }
39321
39322 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
39323 ZVAL_DEREF(value);
39324 }
39325
39326 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39327
39328 if (IS_CV != IS_CONST) {
39329 zend_tmp_string_release(tmp_name);
39330 }
39331
39332 free_and_exit_assign_obj:
39333 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39334 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39335 }
39336 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39337 exit_assign_obj:
39338 if (garbage) {
39339 GC_DTOR_NO_REF(garbage);
39340 }
39341
39342
39343 /* assign_obj has two opcodes! */
39344 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39345 }
39346
39347 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39348 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39349 {
39350 USE_OPLINE
39351 zval *object, *value, tmp;
39352 zend_object *zobj;
39353 zend_string *name, *tmp_name;
39354 zend_refcounted *garbage = NULL;
39355
39356 SAVE_OPLINE();
39357 object = &EX(This);
39358 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
39359
39360 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
39361 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
39362 object = Z_REFVAL_P(object);
39363 goto assign_object;
39364 }
39365 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
39366 value = &EG(uninitialized_zval);
39367 goto free_and_exit_assign_obj;
39368 }
39369
39370 assign_object:
39371 zobj = Z_OBJ_P(object);
39372 if (IS_CV == IS_CONST) {
39373 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
39374 void **cache_slot = CACHE_ADDR(opline->extended_value);
39375 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
39376 zval *property_val;
39377
39378 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
39379 property_val = OBJ_PROP(zobj, prop_offset);
39380 if (Z_TYPE_P(property_val) != IS_UNDEF) {
39381 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
39382
39383 if (prop_info != NULL) {
39384 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39385 goto free_and_exit_assign_obj;
39386 } else {
39387 fast_assign_obj:
39388 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
39389 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39390 ZVAL_COPY(EX_VAR(opline->result.var), value);
39391 }
39392 goto exit_assign_obj;
39393 }
39394 }
39395 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
39396 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39397 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
39398 zobj = zend_lazy_object_init(zobj);
39399 if (!zobj) {
39400 value = &EG(uninitialized_zval);
39401 goto free_and_exit_assign_obj;
39402 }
39403 }
39404 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39405 rebuild_object_properties_internal(zobj);
39406 }
39407 if (EXPECTED(zobj->properties != NULL)) {
39408 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
39409 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
39410 GC_DELREF(zobj->properties);
39411 }
39412 zobj->properties = zend_array_dup(zobj->properties);
39413 }
39414 property_val = zend_hash_find_known_hash(zobj->properties, name);
39415 if (property_val) {
39416 goto fast_assign_obj;
39417 }
39418 }
39419
39420 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
39421 if (IS_CV == IS_CONST) {
39422 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
39423 Z_ADDREF_P(value);
39424 }
39425 } else if (IS_CV != IS_TMP_VAR) {
39426 if (Z_ISREF_P(value)) {
39427 if (IS_CV == IS_VAR) {
39428 zend_reference *ref = Z_REF_P(value);
39429 if (GC_DELREF(ref) == 0) {
39430 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
39431 efree_size(ref, sizeof(zend_reference));
39432 value = &tmp;
39433 } else {
39434 value = Z_REFVAL_P(value);
39435 Z_TRY_ADDREF_P(value);
39436 }
39437 } else {
39438 value = Z_REFVAL_P(value);
39439 Z_TRY_ADDREF_P(value);
39440 }
39441 } else if (IS_CV == IS_CV) {
39442 Z_TRY_ADDREF_P(value);
39443 }
39444 }
39445 zend_hash_add_new(zobj->properties, name, value);
39446 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39447 ZVAL_COPY(EX_VAR(opline->result.var), value);
39448 }
39449 goto exit_assign_obj;
39450 }
39451 } else {
39452 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
39453 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
39454 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
39455 property_val = OBJ_PROP(zobj, prop_info->offset);
39456 if (ZEND_TYPE_IS_SET(prop_info->type)) {
39457 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
39458 goto free_and_exit_assign_obj;
39459 } else {
39460 goto fast_assign_obj;
39461 }
39462 }
39463 /* Fall through to write_property for hooks. */
39464 }
39465 }
39466 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
39467 } else {
39468 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
39469 if (UNEXPECTED(!name)) {
39470
39471 UNDEF_RESULT();
39472 goto exit_assign_obj;
39473 }
39474 }
39475
39476 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
39477 ZVAL_DEREF(value);
39478 }
39479
39480 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
39481
39482 if (IS_CV != IS_CONST) {
39483 zend_tmp_string_release(tmp_name);
39484 }
39485
39486 free_and_exit_assign_obj:
39487 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
39488 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
39489 }
39490
39491 exit_assign_obj:
39492 if (garbage) {
39493 GC_DTOR_NO_REF(garbage);
39494 }
39495
39496
39497 /* assign_obj has two opcodes! */
39498 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39499 }
39500
39501 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39502 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39503 {
39504 USE_OPLINE
39505 zval *property, *container, *value_ptr;
39506
39507 SAVE_OPLINE();
39508
39509 container = &EX(This);
39510 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39511
39512 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
39513
39514 if (1) {
39515 if (IS_UNUSED == IS_UNUSED) {
39516 if (IS_CV == IS_CONST) {
39517 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39518 } else {
39519 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39520 }
39521 } else {
39522 if (IS_CV == IS_CONST) {
39523 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39524 } else {
39525 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39526 }
39527 }
39528 } else {
39529 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39530 }
39531
39532
39533 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
39534 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39535 }
39536
39537 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39538 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39539 {
39540 USE_OPLINE
39541 zval *property, *container, *value_ptr;
39542
39543 SAVE_OPLINE();
39544
39545 container = &EX(This);
39546 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39547
39548 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
39549
39550 if (1) {
39551 if (IS_UNUSED == IS_UNUSED) {
39552 if (IS_CV == IS_CONST) {
39553 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39554 } else {
39555 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39556 }
39557 } else {
39558 if (IS_CV == IS_CONST) {
39559 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39560 } else {
39561 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39562 }
39563 }
39564 } else {
39565 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
39566 }
39567
39568
39569
39570 ZEND_VM_NEXT_OPCODE_EX(1, 2);
39571 }
39572
39573 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39574 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39575 {
39576 USE_OPLINE
39577 zend_string **rope;
39578 zval *var;
39579
39580 /* Compiler allocates the necessary number of zval slots to keep the rope */
39581 rope = (zend_string**)EX_VAR(opline->result.var);
39582 if (IS_CV == IS_CONST) {
39583 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39584 rope[0] = Z_STR_P(var);
39585 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
39586 Z_ADDREF_P(var);
39587 }
39588 } else {
39589 var = EX_VAR(opline->op2.var);
39590 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
39591 if (IS_CV == IS_CV) {
39592 rope[0] = zend_string_copy(Z_STR_P(var));
39593 } else {
39594 rope[0] = Z_STR_P(var);
39595 }
39596 } else {
39597 SAVE_OPLINE();
39598 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
39599 ZVAL_UNDEFINED_OP2();
39600 }
39601 rope[0] = zval_get_string_func(var);
39602
39603 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39604 }
39605 }
39606 ZEND_VM_NEXT_OPCODE();
39607 }
39608
ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39609 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39610 {
39611 zval *class_name;
39612 USE_OPLINE
39613
39614 SAVE_OPLINE();
39615 if (IS_CV == IS_UNUSED) {
39616 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
39617 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39618 } else if (IS_CV == IS_CONST) {
39619 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
39620
39621 if (UNEXPECTED(ce == NULL)) {
39622 class_name = EX_VAR(opline->op2.var);
39623 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
39624 CACHE_PTR(opline->extended_value, ce);
39625 }
39626 Z_CE_P(EX_VAR(opline->result.var)) = ce;
39627 } else {
39628 class_name = EX_VAR(opline->op2.var);
39629 try_class_name:
39630 if (Z_TYPE_P(class_name) == IS_OBJECT) {
39631 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
39632 } else if (Z_TYPE_P(class_name) == IS_STRING) {
39633 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
39634 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
39635 class_name = Z_REFVAL_P(class_name);
39636 goto try_class_name;
39637 } else {
39638 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
39639 ZVAL_UNDEFINED_OP2();
39640 if (UNEXPECTED(EG(exception) != NULL)) {
39641 HANDLE_EXCEPTION();
39642 }
39643 }
39644 zend_throw_error(NULL, "Class name must be a valid object or a string");
39645 }
39646 }
39647
39648 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39649 }
39650
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39651 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39652 {
39653 USE_OPLINE
39654 zval *function_name;
39655 zval *object;
39656 zend_function *fbc;
39657 zend_class_entry *called_scope;
39658 zend_object *obj;
39659 zend_execute_data *call;
39660 uint32_t call_info;
39661
39662 SAVE_OPLINE();
39663
39664 object = &EX(This);
39665
39666 if (IS_CV != IS_CONST) {
39667 function_name = EX_VAR(opline->op2.var);
39668 }
39669
39670 if (IS_CV != IS_CONST &&
39671 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
39672 do {
39673 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
39674 function_name = Z_REFVAL_P(function_name);
39675 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
39676 break;
39677 }
39678 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
39679 ZVAL_UNDEFINED_OP2();
39680 if (UNEXPECTED(EG(exception) != NULL)) {
39681
39682 HANDLE_EXCEPTION();
39683 }
39684 }
39685 zend_throw_error(NULL, "Method name must be a string");
39686
39687
39688 HANDLE_EXCEPTION();
39689 } while (0);
39690 }
39691
39692 if (IS_UNUSED == IS_UNUSED) {
39693 obj = Z_OBJ_P(object);
39694 } else {
39695 do {
39696 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
39697 obj = Z_OBJ_P(object);
39698 } else {
39699 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
39700 zend_reference *ref = Z_REF_P(object);
39701
39702 object = &ref->val;
39703 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
39704 obj = Z_OBJ_P(object);
39705 if (IS_UNUSED & IS_VAR) {
39706 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
39707 efree_size(ref, sizeof(zend_reference));
39708 } else {
39709 Z_ADDREF_P(object);
39710 }
39711 }
39712 break;
39713 }
39714 }
39715 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
39716 object = ZVAL_UNDEFINED_OP1();
39717 if (UNEXPECTED(EG(exception) != NULL)) {
39718 if (IS_CV != IS_CONST) {
39719
39720 }
39721 HANDLE_EXCEPTION();
39722 }
39723 }
39724 if (IS_CV == IS_CONST) {
39725 function_name = EX_VAR(opline->op2.var);
39726 }
39727 zend_invalid_method_call(object, function_name);
39728
39729
39730 HANDLE_EXCEPTION();
39731 }
39732 } while (0);
39733 }
39734
39735 called_scope = obj->ce;
39736
39737 if (IS_CV == IS_CONST &&
39738 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
39739 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
39740 } else {
39741 zend_object *orig_obj = obj;
39742
39743 if (IS_CV == IS_CONST) {
39744 function_name = EX_VAR(opline->op2.var);
39745 }
39746
39747 /* First, locate the function. */
39748 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
39749 if (UNEXPECTED(fbc == NULL)) {
39750 if (EXPECTED(!EG(exception))) {
39751 zend_undefined_method(obj->ce, Z_STR_P(function_name));
39752 }
39753
39754 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
39755 zend_objects_store_del(orig_obj);
39756 }
39757 HANDLE_EXCEPTION();
39758 }
39759 if (IS_CV == IS_CONST &&
39760 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
39761 EXPECTED(obj == orig_obj)) {
39762 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
39763 }
39764 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
39765 GC_ADDREF(obj); /* For $this pointer */
39766 if (GC_DELREF(orig_obj) == 0) {
39767 zend_objects_store_del(orig_obj);
39768 }
39769 }
39770 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
39771 init_func_run_time_cache(&fbc->op_array);
39772 }
39773 }
39774
39775 if (IS_CV != IS_CONST) {
39776
39777 }
39778
39779 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
39780 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
39781 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
39782 zend_objects_store_del(obj);
39783 if (UNEXPECTED(EG(exception))) {
39784 HANDLE_EXCEPTION();
39785 }
39786 }
39787 /* call static method */
39788 obj = (zend_object*)called_scope;
39789 call_info = ZEND_CALL_NESTED_FUNCTION;
39790 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
39791 if (IS_UNUSED == IS_CV) {
39792 GC_ADDREF(obj); /* For $this pointer */
39793 }
39794 /* CV may be changed indirectly (e.g. when it's a reference) */
39795 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
39796 }
39797
39798 call = zend_vm_stack_push_call_frame(call_info,
39799 fbc, opline->extended_value, obj);
39800 call->prev_execute_data = EX(call);
39801 EX(call) = call;
39802
39803 ZEND_VM_NEXT_OPCODE();
39804 }
39805
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39806 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39807 {
39808 USE_OPLINE
39809 zval *function_name;
39810 zend_class_entry *ce;
39811 uint32_t call_info;
39812 zend_function *fbc;
39813 zend_execute_data *call;
39814
39815 SAVE_OPLINE();
39816
39817 if (IS_UNUSED == IS_CONST) {
39818 /* no function found. try a static method in class */
39819 ce = CACHED_PTR(opline->result.num);
39820 if (UNEXPECTED(ce == NULL)) {
39821 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);
39822 if (UNEXPECTED(ce == NULL)) {
39823
39824 HANDLE_EXCEPTION();
39825 }
39826 if (IS_CV != IS_CONST) {
39827 CACHE_PTR(opline->result.num, ce);
39828 }
39829 }
39830 } else if (IS_UNUSED == IS_UNUSED) {
39831 ce = zend_fetch_class(NULL, opline->op1.num);
39832 if (UNEXPECTED(ce == NULL)) {
39833
39834 HANDLE_EXCEPTION();
39835 }
39836 } else {
39837 ce = Z_CE_P(EX_VAR(opline->op1.var));
39838 }
39839
39840 if (IS_UNUSED == IS_CONST &&
39841 IS_CV == IS_CONST &&
39842 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
39843 /* nothing to do */
39844 } else if (IS_UNUSED != IS_CONST &&
39845 IS_CV == IS_CONST &&
39846 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
39847 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
39848 } else if (IS_CV != IS_UNUSED) {
39849 function_name = EX_VAR(opline->op2.var);
39850 if (IS_CV != IS_CONST) {
39851 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
39852 do {
39853 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
39854 function_name = Z_REFVAL_P(function_name);
39855 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
39856 break;
39857 }
39858 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
39859 ZVAL_UNDEFINED_OP2();
39860 if (UNEXPECTED(EG(exception) != NULL)) {
39861 HANDLE_EXCEPTION();
39862 }
39863 }
39864 zend_throw_error(NULL, "Method name must be a string");
39865
39866 HANDLE_EXCEPTION();
39867 } while (0);
39868 }
39869 }
39870
39871 if (ce->get_static_method) {
39872 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
39873 } else {
39874 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
39875 }
39876 if (UNEXPECTED(fbc == NULL)) {
39877 if (EXPECTED(!EG(exception))) {
39878 zend_undefined_method(ce, Z_STR_P(function_name));
39879 }
39880
39881 HANDLE_EXCEPTION();
39882 }
39883 if (IS_CV == IS_CONST &&
39884 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
39885 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
39886 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
39887 }
39888 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
39889 init_func_run_time_cache(&fbc->op_array);
39890 }
39891 if (IS_CV != IS_CONST) {
39892
39893 }
39894 } else {
39895 if (UNEXPECTED(ce->constructor == NULL)) {
39896 zend_throw_error(NULL, "Cannot call constructor");
39897 HANDLE_EXCEPTION();
39898 }
39899 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
39900 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
39901 HANDLE_EXCEPTION();
39902 }
39903 fbc = ce->constructor;
39904 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
39905 init_func_run_time_cache(&fbc->op_array);
39906 }
39907 }
39908
39909 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
39910 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
39911 ce = (zend_class_entry*)Z_OBJ(EX(This));
39912 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
39913 } else {
39914 zend_non_static_method_call(fbc);
39915 HANDLE_EXCEPTION();
39916 }
39917 } else {
39918 /* previous opcode is ZEND_FETCH_CLASS */
39919 if (IS_UNUSED == IS_UNUSED
39920 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
39921 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
39922 if (Z_TYPE(EX(This)) == IS_OBJECT) {
39923 ce = Z_OBJCE(EX(This));
39924 } else {
39925 ce = Z_CE(EX(This));
39926 }
39927 }
39928 call_info = ZEND_CALL_NESTED_FUNCTION;
39929 }
39930
39931 call = zend_vm_stack_push_call_frame(call_info,
39932 fbc, opline->extended_value, ce);
39933 call->prev_execute_data = EX(call);
39934 EX(call) = call;
39935
39936 ZEND_VM_NEXT_OPCODE();
39937 }
39938
ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39939 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39940 {
39941 zval *array;
39942 uint32_t size;
39943 USE_OPLINE
39944
39945 array = EX_VAR(opline->result.var);
39946 if (IS_UNUSED != IS_UNUSED) {
39947 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
39948 ZVAL_ARR(array, zend_new_array(size));
39949 /* Explicitly initialize array as not-packed if flag is set */
39950 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
39951 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
39952 }
39953 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39954 } else {
39955 ZVAL_ARR(array, zend_new_array(0));
39956 ZEND_VM_NEXT_OPCODE();
39957 }
39958 }
39959
ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39960 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39961 {
39962 USE_OPLINE
39963 zval *container;
39964 zval *offset;
39965 zend_string *name, *tmp_name;
39966
39967 SAVE_OPLINE();
39968 container = &EX(This);
39969 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39970
39971 do {
39972 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
39973 if (Z_ISREF_P(container)) {
39974 container = Z_REFVAL_P(container);
39975 if (Z_TYPE_P(container) != IS_OBJECT) {
39976 if (IS_UNUSED == IS_CV
39977 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
39978 ZVAL_UNDEFINED_OP1();
39979 }
39980 break;
39981 }
39982 } else {
39983 break;
39984 }
39985 }
39986 if (IS_CV == IS_CONST) {
39987 name = Z_STR_P(offset);
39988 } else {
39989 name = zval_try_get_tmp_string(offset, &tmp_name);
39990 if (UNEXPECTED(!name)) {
39991 break;
39992 }
39993 }
39994 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
39995 if (IS_CV != IS_CONST) {
39996 zend_tmp_string_release(tmp_name);
39997 }
39998 } while (0);
39999
40000
40001 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40002 }
40003
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40004 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40005 {
40006 USE_OPLINE
40007 zval *container;
40008 int result;
40009 zval *offset;
40010 zend_string *name, *tmp_name;
40011
40012 SAVE_OPLINE();
40013 container = &EX(This);
40014 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
40015
40016 if (IS_UNUSED == IS_CONST ||
40017 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
40018 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
40019 container = Z_REFVAL_P(container);
40020 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
40021 result = (opline->extended_value & ZEND_ISEMPTY);
40022 goto isset_object_finish;
40023 }
40024 } else {
40025 result = (opline->extended_value & ZEND_ISEMPTY);
40026 goto isset_object_finish;
40027 }
40028 }
40029
40030 if (IS_CV == IS_CONST) {
40031 name = Z_STR_P(offset);
40032 } else {
40033 name = zval_try_get_tmp_string(offset, &tmp_name);
40034 if (UNEXPECTED(!name)) {
40035 result = 0;
40036 goto isset_object_finish;
40037 }
40038 }
40039
40040 result =
40041 (opline->extended_value & ZEND_ISEMPTY) ^
40042 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));
40043
40044 if (IS_CV != IS_CONST) {
40045 zend_tmp_string_release(tmp_name);
40046 }
40047
40048 isset_object_finish:
40049
40050
40051 ZEND_VM_SMART_BRANCH(result, 1);
40052 }
40053
ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40054 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40055 {
40056 USE_OPLINE
40057
40058 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
40059
40060 SAVE_OPLINE();
40061 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
40062 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40063 }
40064
40065 /* Destroy the previously yielded value */
40066 zval_ptr_dtor(&generator->value);
40067
40068 /* Destroy the previously yielded key */
40069 zval_ptr_dtor(&generator->key);
40070
40071 /* Set the new yielded value */
40072 if (IS_UNUSED != IS_UNUSED) {
40073 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
40074 /* Constants and temporary variables aren't yieldable by reference,
40075 * but we still allow them with a notice. */
40076 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
40077 zval *value;
40078
40079 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
40080
40081 value = NULL;
40082 ZVAL_COPY_VALUE(&generator->value, value);
40083 if (IS_UNUSED == IS_CONST) {
40084 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
40085 Z_ADDREF(generator->value);
40086 }
40087 }
40088 } else {
40089 zval *value_ptr = NULL;
40090
40091 /* If a function call result is yielded and the function did
40092 * not return by reference we throw a notice. */
40093 do {
40094 if (IS_UNUSED == IS_VAR) {
40095 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
40096 if (opline->extended_value == ZEND_RETURNS_FUNCTION
40097 && !Z_ISREF_P(value_ptr)) {
40098 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
40099 ZVAL_COPY(&generator->value, value_ptr);
40100 break;
40101 }
40102 }
40103 if (Z_ISREF_P(value_ptr)) {
40104 Z_ADDREF_P(value_ptr);
40105 } else {
40106 ZVAL_MAKE_REF_EX(value_ptr, 2);
40107 }
40108 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
40109 } while (0);
40110
40111 }
40112 } else {
40113 zval *value = NULL;
40114
40115 /* Consts, temporary variables and references need copying */
40116 if (IS_UNUSED == IS_CONST) {
40117 ZVAL_COPY_VALUE(&generator->value, value);
40118 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
40119 Z_ADDREF(generator->value);
40120 }
40121 } else if (IS_UNUSED == IS_TMP_VAR) {
40122 ZVAL_COPY_VALUE(&generator->value, value);
40123 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
40124 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
40125
40126 } else {
40127 ZVAL_COPY_VALUE(&generator->value, value);
40128 if (IS_UNUSED == IS_CV) {
40129 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
40130 }
40131 }
40132 }
40133 } else {
40134 /* If no value was specified yield null */
40135 ZVAL_NULL(&generator->value);
40136 }
40137
40138 /* Set the new yielded key */
40139 if (IS_CV != IS_UNUSED) {
40140 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
40141 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
40142 key = Z_REFVAL_P(key);
40143 }
40144 ZVAL_COPY(&generator->key, key);
40145
40146 if (Z_TYPE(generator->key) == IS_LONG
40147 && Z_LVAL(generator->key) > generator->largest_used_integer_key
40148 ) {
40149 generator->largest_used_integer_key = Z_LVAL(generator->key);
40150 }
40151 } else {
40152 /* If no key was specified we use auto-increment keys */
40153 generator->largest_used_integer_key++;
40154 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
40155 }
40156
40157 if (RETURN_VALUE_USED(opline)) {
40158 /* If the return value of yield is used set the send
40159 * target and initialize it to NULL */
40160 generator->send_target = EX_VAR(opline->result.var);
40161 ZVAL_NULL(generator->send_target);
40162 } else {
40163 generator->send_target = NULL;
40164 }
40165
40166 /* The GOTO VM uses a local opline variable. We need to set the opline
40167 * variable in execute_data so we don't resume at an old position. */
40168 SAVE_OPLINE();
40169
40170 ZEND_VM_RETURN();
40171 }
40172
ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40173 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40174 {
40175 USE_OPLINE
40176 zval *val;
40177
40178 val = EX_VAR(opline->op1.var);
40179 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40180 ZVAL_FALSE(EX_VAR(opline->result.var));
40181 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40182 /* The result and op1 can be the same cv zval */
40183 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
40184 ZVAL_TRUE(EX_VAR(opline->result.var));
40185 if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
40186 SAVE_OPLINE();
40187 ZVAL_UNDEFINED_OP1();
40188 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40189 }
40190 } else {
40191 SAVE_OPLINE();
40192 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
40193
40194 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40195 }
40196 ZEND_VM_NEXT_OPCODE();
40197 }
40198
zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)40199 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40200 {
40201 USE_OPLINE
40202 zval *var_ptr;
40203
40204 var_ptr = EX_VAR(opline->op1.var);
40205
40206 SAVE_OPLINE();
40207 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40208 ZVAL_UNDEFINED_OP1();
40209 ZVAL_NULL(var_ptr);
40210 }
40211
40212 do {
40213 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40214 zend_reference *ref = Z_REF_P(var_ptr);
40215 var_ptr = Z_REFVAL_P(var_ptr);
40216 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40217 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
40218 break;
40219 }
40220 }
40221 increment_function(var_ptr);
40222 } while (0);
40223
40224 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
40225 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40226 }
40227
40228 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40229 }
40230
ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40231 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40232 {
40233 USE_OPLINE
40234 zval *var_ptr;
40235
40236 var_ptr = EX_VAR(opline->op1.var);
40237
40238 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40239 fast_long_increment_function(var_ptr);
40240 if (UNEXPECTED(0)) {
40241 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40242 }
40243 ZEND_VM_NEXT_OPCODE();
40244 }
40245
40246 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40247 }
40248
ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40249 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40250 {
40251 USE_OPLINE
40252 zval *var_ptr;
40253
40254 var_ptr = EX_VAR(opline->op1.var);
40255
40256 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40257 fast_long_increment_function(var_ptr);
40258 if (UNEXPECTED(1)) {
40259 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40260 }
40261 ZEND_VM_NEXT_OPCODE();
40262 }
40263
40264 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40265 }
40266
zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)40267 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40268 {
40269 USE_OPLINE
40270 zval *var_ptr;
40271
40272 var_ptr = EX_VAR(opline->op1.var);
40273
40274 SAVE_OPLINE();
40275 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40276 ZVAL_UNDEFINED_OP1();
40277 ZVAL_NULL(var_ptr);
40278 }
40279
40280 do {
40281 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40282 zend_reference *ref = Z_REF_P(var_ptr);
40283 var_ptr = Z_REFVAL_P(var_ptr);
40284
40285 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40286 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
40287 break;
40288 }
40289 }
40290 decrement_function(var_ptr);
40291 } while (0);
40292
40293 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
40294 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40295 }
40296
40297 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40298 }
40299
ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40300 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40301 {
40302 USE_OPLINE
40303 zval *var_ptr;
40304
40305 var_ptr = EX_VAR(opline->op1.var);
40306
40307 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40308 fast_long_decrement_function(var_ptr);
40309 if (UNEXPECTED(0)) {
40310 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40311 }
40312 ZEND_VM_NEXT_OPCODE();
40313 }
40314
40315 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40316 }
40317
ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40318 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40319 {
40320 USE_OPLINE
40321 zval *var_ptr;
40322
40323 var_ptr = EX_VAR(opline->op1.var);
40324
40325 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40326 fast_long_decrement_function(var_ptr);
40327 if (UNEXPECTED(1)) {
40328 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40329 }
40330 ZEND_VM_NEXT_OPCODE();
40331 }
40332
40333 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40334 }
40335
zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)40336 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40337 {
40338 USE_OPLINE
40339 zval *var_ptr;
40340
40341 var_ptr = EX_VAR(opline->op1.var);
40342
40343 SAVE_OPLINE();
40344 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40345 ZVAL_UNDEFINED_OP1();
40346 ZVAL_NULL(var_ptr);
40347 }
40348
40349 do {
40350 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40351 zend_reference *ref = Z_REF_P(var_ptr);
40352 var_ptr = Z_REFVAL_P(var_ptr);
40353
40354 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40355 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
40356 break;
40357 }
40358 }
40359 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40360
40361 increment_function(var_ptr);
40362 } while (0);
40363
40364 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40365 }
40366
ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40367 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40368 {
40369 USE_OPLINE
40370 zval *var_ptr;
40371
40372 var_ptr = EX_VAR(opline->op1.var);
40373
40374 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40375 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40376 fast_long_increment_function(var_ptr);
40377 ZEND_VM_NEXT_OPCODE();
40378 }
40379
40380 ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40381 }
40382
zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)40383 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
40384 {
40385 USE_OPLINE
40386 zval *var_ptr;
40387
40388 var_ptr = EX_VAR(opline->op1.var);
40389
40390 SAVE_OPLINE();
40391 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
40392 ZVAL_UNDEFINED_OP1();
40393 ZVAL_NULL(var_ptr);
40394 }
40395
40396 do {
40397 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
40398 zend_reference *ref = Z_REF_P(var_ptr);
40399 var_ptr = Z_REFVAL_P(var_ptr);
40400
40401 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
40402 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
40403 break;
40404 }
40405 }
40406 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
40407
40408 decrement_function(var_ptr);
40409 } while (0);
40410
40411 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40412 }
40413
ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40414 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40415 {
40416 USE_OPLINE
40417 zval *var_ptr;
40418
40419 var_ptr = EX_VAR(opline->op1.var);
40420
40421 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
40422 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40423 fast_long_decrement_function(var_ptr);
40424 ZEND_VM_NEXT_OPCODE();
40425 }
40426
40427 ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40428 }
40429
ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40430 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40431 {
40432 USE_OPLINE
40433 zval *z;
40434
40435 SAVE_OPLINE();
40436 z = EX_VAR(opline->op1.var);
40437
40438 if (Z_TYPE_P(z) == IS_STRING) {
40439 zend_string *str = Z_STR_P(z);
40440
40441 if (ZSTR_LEN(str) != 0) {
40442 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
40443 }
40444 } else {
40445 zend_string *str = zval_get_string_func(z);
40446
40447 if (ZSTR_LEN(str) != 0) {
40448 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
40449 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
40450 ZVAL_UNDEFINED_OP1();
40451 }
40452 zend_string_release_ex(str, 0);
40453 }
40454
40455 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40456 }
40457
ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40458 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40459 {
40460 USE_OPLINE
40461 zval *val;
40462 uint8_t op1_type;
40463
40464 val = EX_VAR(opline->op1.var);
40465
40466 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40467 ZEND_VM_NEXT_OPCODE();
40468 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40469 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40470 SAVE_OPLINE();
40471 ZVAL_UNDEFINED_OP1();
40472 if (UNEXPECTED(EG(exception))) {
40473 HANDLE_EXCEPTION();
40474 }
40475 }
40476 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40477 }
40478
40479 SAVE_OPLINE();
40480 op1_type = IS_CV;
40481 if (i_zend_is_true(val)) {
40482 opline++;
40483 } else {
40484 opline = OP_JMP_ADDR(opline, opline->op2);
40485 }
40486 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
40487 zval_ptr_dtor_nogc(val);
40488 }
40489 ZEND_VM_JMP(opline);
40490 }
40491
ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40492 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40493 {
40494 USE_OPLINE
40495 zval *val;
40496 uint8_t op1_type;
40497
40498 val = EX_VAR(opline->op1.var);
40499
40500 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40501 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40502 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40503 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40504 SAVE_OPLINE();
40505 ZVAL_UNDEFINED_OP1();
40506 if (UNEXPECTED(EG(exception))) {
40507 HANDLE_EXCEPTION();
40508 }
40509 }
40510 ZEND_VM_NEXT_OPCODE();
40511 }
40512
40513 SAVE_OPLINE();
40514 op1_type = IS_CV;
40515 if (i_zend_is_true(val)) {
40516 opline = OP_JMP_ADDR(opline, opline->op2);
40517 } else {
40518 opline++;
40519 }
40520 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
40521 zval_ptr_dtor_nogc(val);
40522 }
40523 ZEND_VM_JMP(opline);
40524 }
40525
ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40526 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40527 {
40528 USE_OPLINE
40529 zval *val;
40530 bool ret;
40531
40532 val = EX_VAR(opline->op1.var);
40533
40534 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40535 ZVAL_TRUE(EX_VAR(opline->result.var));
40536 ZEND_VM_NEXT_OPCODE();
40537 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40538 ZVAL_FALSE(EX_VAR(opline->result.var));
40539 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40540 SAVE_OPLINE();
40541 ZVAL_UNDEFINED_OP1();
40542 if (UNEXPECTED(EG(exception))) {
40543 HANDLE_EXCEPTION();
40544 }
40545 }
40546 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40547 }
40548
40549 SAVE_OPLINE();
40550 ret = i_zend_is_true(val);
40551
40552 if (ret) {
40553 ZVAL_TRUE(EX_VAR(opline->result.var));
40554 opline++;
40555 } else {
40556 ZVAL_FALSE(EX_VAR(opline->result.var));
40557 opline = OP_JMP_ADDR(opline, opline->op2);
40558 }
40559 ZEND_VM_JMP(opline);
40560 }
40561
ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40562 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40563 {
40564 USE_OPLINE
40565 zval *val;
40566 bool ret;
40567
40568 val = EX_VAR(opline->op1.var);
40569
40570 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40571 ZVAL_TRUE(EX_VAR(opline->result.var));
40572 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40573 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40574 ZVAL_FALSE(EX_VAR(opline->result.var));
40575 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
40576 SAVE_OPLINE();
40577 ZVAL_UNDEFINED_OP1();
40578 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40579 } else {
40580 ZEND_VM_NEXT_OPCODE();
40581 }
40582 }
40583
40584 SAVE_OPLINE();
40585 ret = i_zend_is_true(val);
40586
40587 if (ret) {
40588 ZVAL_TRUE(EX_VAR(opline->result.var));
40589 opline = OP_JMP_ADDR(opline, opline->op2);
40590 } else {
40591 ZVAL_FALSE(EX_VAR(opline->result.var));
40592 opline++;
40593 }
40594 ZEND_VM_JMP(opline);
40595 }
40596
ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40597 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40598 {
40599 USE_OPLINE
40600 zval *retval_ptr;
40601 zval *return_value;
40602
40603 retval_ptr = EX_VAR(opline->op1.var);
40604 return_value = EX(return_value);
40605
40606 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
40607 SAVE_OPLINE();
40608 retval_ptr = ZVAL_UNDEFINED_OP1();
40609 if (return_value) {
40610 ZVAL_NULL(return_value);
40611 }
40612 } else if (!return_value) {
40613 if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
40614 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
40615 SAVE_OPLINE();
40616 rc_dtor_func(Z_COUNTED_P(retval_ptr));
40617 }
40618 }
40619 } else {
40620 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
40621 ZVAL_COPY_VALUE(return_value, retval_ptr);
40622 if (IS_CV == IS_CONST) {
40623 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
40624 Z_ADDREF_P(return_value);
40625 }
40626 }
40627 } else if (IS_CV == IS_CV) {
40628 do {
40629 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40630 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
40631 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
40632 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
40633 ZVAL_COPY_VALUE(return_value, retval_ptr);
40634 if (GC_MAY_LEAK(ref)) {
40635 SAVE_OPLINE();
40636 gc_possible_root(ref);
40637 }
40638 ZVAL_NULL(retval_ptr);
40639 break;
40640 } else {
40641 Z_ADDREF_P(retval_ptr);
40642 }
40643 } else {
40644 retval_ptr = Z_REFVAL_P(retval_ptr);
40645 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40646 Z_ADDREF_P(retval_ptr);
40647 }
40648 }
40649 }
40650 ZVAL_COPY_VALUE(return_value, retval_ptr);
40651 } while (0);
40652 } else /* if (IS_CV == IS_VAR) */ {
40653 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
40654 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
40655
40656 retval_ptr = Z_REFVAL_P(retval_ptr);
40657 ZVAL_COPY_VALUE(return_value, retval_ptr);
40658 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40659 efree_size(ref, sizeof(zend_reference));
40660 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
40661 Z_ADDREF_P(retval_ptr);
40662 }
40663 } else {
40664 ZVAL_COPY_VALUE(return_value, retval_ptr);
40665 }
40666 }
40667 }
40668
40669
40670
40671 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40672 }
40673
ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40674 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40675 {
40676 USE_OPLINE
40677 zval *retval_ptr;
40678 zval *return_value;
40679
40680 SAVE_OPLINE();
40681
40682 return_value = EX(return_value);
40683
40684 do {
40685 if ((IS_CV & (IS_CONST|IS_TMP_VAR)) ||
40686 (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
40687 /* Not supposed to happen, but we'll allow it */
40688 zend_error(E_NOTICE, "Only variable references should be returned by reference");
40689
40690 retval_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40691 if (!return_value) {
40692
40693 } else {
40694 if (IS_CV == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
40695 ZVAL_COPY_VALUE(return_value, retval_ptr);
40696 break;
40697 }
40698
40699 ZVAL_NEW_REF(return_value, retval_ptr);
40700 if (IS_CV == IS_CONST) {
40701 Z_TRY_ADDREF_P(retval_ptr);
40702 }
40703 }
40704 break;
40705 }
40706
40707 retval_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
40708
40709 if (IS_CV == IS_VAR) {
40710 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
40711 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
40712 zend_error(E_NOTICE, "Only variable references should be returned by reference");
40713 if (return_value) {
40714 ZVAL_NEW_REF(return_value, retval_ptr);
40715 } else {
40716
40717 }
40718 break;
40719 }
40720 }
40721
40722 if (return_value) {
40723 if (Z_ISREF_P(retval_ptr)) {
40724 Z_ADDREF_P(retval_ptr);
40725 } else {
40726 ZVAL_MAKE_REF_EX(retval_ptr, 2);
40727 }
40728 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
40729 }
40730
40731 } while (0);
40732
40733
40734 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
40735 }
40736
ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40737 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40738 {
40739 USE_OPLINE
40740 zval *retval;
40741
40742 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
40743
40744 SAVE_OPLINE();
40745 retval = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40746
40747 /* Copy return value into generator->retval */
40748 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
40749 ZVAL_COPY_VALUE(&generator->retval, retval);
40750 if (IS_CV == IS_CONST) {
40751 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
40752 Z_ADDREF(generator->retval);
40753 }
40754 }
40755 } else if (IS_CV == IS_CV) {
40756 ZVAL_COPY_DEREF(&generator->retval, retval);
40757 } else /* if (IS_CV == IS_VAR) */ {
40758 if (UNEXPECTED(Z_ISREF_P(retval))) {
40759 zend_refcounted *ref = Z_COUNTED_P(retval);
40760
40761 retval = Z_REFVAL_P(retval);
40762 ZVAL_COPY_VALUE(&generator->retval, retval);
40763 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40764 efree_size(ref, sizeof(zend_reference));
40765 } else if (Z_OPT_REFCOUNTED_P(retval)) {
40766 Z_ADDREF_P(retval);
40767 }
40768 } else {
40769 ZVAL_COPY_VALUE(&generator->retval, retval);
40770 }
40771 }
40772
40773 EG(current_execute_data) = EX(prev_execute_data);
40774
40775 /* Close the generator to free up resources */
40776 zend_generator_close(generator, 1);
40777
40778 /* Pass execution back to handling code */
40779 ZEND_VM_RETURN();
40780 }
40781
ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40782 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40783 {
40784 USE_OPLINE
40785 zval *value;
40786
40787 SAVE_OPLINE();
40788 value = EX_VAR(opline->op1.var);
40789
40790 do {
40791 if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
40792 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
40793 value = Z_REFVAL_P(value);
40794 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
40795 break;
40796 }
40797 }
40798 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
40799 ZVAL_UNDEFINED_OP1();
40800 if (UNEXPECTED(EG(exception) != NULL)) {
40801 HANDLE_EXCEPTION();
40802 }
40803 }
40804 zend_throw_error(NULL, "Can only throw objects");
40805
40806 HANDLE_EXCEPTION();
40807 }
40808 } while (0);
40809
40810 zend_exception_save();
40811 Z_TRY_ADDREF_P(value);
40812 zend_throw_exception_object(value);
40813 zend_exception_restore();
40814
40815 HANDLE_EXCEPTION();
40816 }
40817
ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40818 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40819 {
40820 USE_OPLINE
40821 zval *arg, *param;
40822
40823 SAVE_OPLINE();
40824
40825 arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40826 param = ZEND_CALL_VAR(EX(call), opline->result.var);
40827 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
40828 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
40829 Z_TRY_ADDREF_P(arg);
40830 ZVAL_NEW_REF(param, arg);
40831 } else {
40832 ZVAL_COPY(param, arg);
40833 }
40834
40835 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40836 }
40837
ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40838 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40839 {
40840 USE_OPLINE
40841 zval *val;
40842
40843 val = EX_VAR(opline->op1.var);
40844 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
40845 ZVAL_TRUE(EX_VAR(opline->result.var));
40846 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
40847 /* The result and op1 can be the same cv zval */
40848 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
40849 ZVAL_FALSE(EX_VAR(opline->result.var));
40850 if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
40851 SAVE_OPLINE();
40852 ZVAL_UNDEFINED_OP1();
40853 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40854 }
40855 } else {
40856 SAVE_OPLINE();
40857 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
40858
40859 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40860 }
40861 ZEND_VM_NEXT_OPCODE();
40862 }
40863
ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40864 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40865 {
40866 USE_OPLINE
40867 zval *obj;
40868 zend_object *zobj;
40869 zend_class_entry *ce, *scope;
40870 zend_function *clone;
40871 zend_object_clone_obj_t clone_call;
40872
40873 SAVE_OPLINE();
40874 obj = EX_VAR(opline->op1.var);
40875
40876 do {
40877 if (IS_CV == IS_CONST ||
40878 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
40879 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
40880 obj = Z_REFVAL_P(obj);
40881 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
40882 break;
40883 }
40884 }
40885 ZVAL_UNDEF(EX_VAR(opline->result.var));
40886 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
40887 ZVAL_UNDEFINED_OP1();
40888 if (UNEXPECTED(EG(exception) != NULL)) {
40889 HANDLE_EXCEPTION();
40890 }
40891 }
40892 zend_throw_error(NULL, "__clone method called on non-object");
40893
40894 HANDLE_EXCEPTION();
40895 }
40896 } while (0);
40897
40898 zobj = Z_OBJ_P(obj);
40899 ce = zobj->ce;
40900 clone = ce->clone;
40901 clone_call = zobj->handlers->clone_obj;
40902 if (UNEXPECTED(clone_call == NULL)) {
40903 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
40904
40905 ZVAL_UNDEF(EX_VAR(opline->result.var));
40906 HANDLE_EXCEPTION();
40907 }
40908
40909 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
40910 scope = EX(func)->op_array.scope;
40911 if (clone->common.scope != scope) {
40912 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
40913 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
40914 zend_wrong_clone_call(clone, scope);
40915
40916 ZVAL_UNDEF(EX_VAR(opline->result.var));
40917 HANDLE_EXCEPTION();
40918 }
40919 }
40920 }
40921
40922 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
40923
40924 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40925 }
40926
ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40927 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40928 {
40929 USE_OPLINE
40930 zval *expr;
40931 zval *result = EX_VAR(opline->result.var);
40932 HashTable *ht;
40933
40934 SAVE_OPLINE();
40935 expr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40936
40937 switch (opline->extended_value) {
40938 case IS_LONG:
40939 ZVAL_LONG(result, zval_get_long(expr));
40940 break;
40941 case IS_DOUBLE:
40942 ZVAL_DOUBLE(result, zval_get_double(expr));
40943 break;
40944 case IS_STRING:
40945 ZVAL_STR(result, zval_get_string(expr));
40946 break;
40947 default:
40948 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
40949 if (IS_CV & (IS_VAR|IS_CV)) {
40950 ZVAL_DEREF(expr);
40951 }
40952 /* If value is already of correct type, return it directly */
40953 if (Z_TYPE_P(expr) == opline->extended_value) {
40954 ZVAL_COPY_VALUE(result, expr);
40955 if (IS_CV == IS_CONST) {
40956 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
40957 } else if (IS_CV != IS_TMP_VAR) {
40958 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
40959 }
40960
40961 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40962 }
40963
40964 if (opline->extended_value == IS_ARRAY) {
40965 if (IS_CV == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
40966 if (Z_TYPE_P(expr) != IS_NULL) {
40967 ZVAL_ARR(result, zend_new_array(1));
40968 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
40969 if (IS_CV == IS_CONST) {
40970 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
40971 } else {
40972 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
40973 }
40974 } else {
40975 ZVAL_EMPTY_ARRAY(result);
40976 }
40977 } else if (ZEND_STD_BUILD_OBJECT_PROPERTIES_ARRAY_COMPATIBLE(expr)) {
40978 /* Optimized version without rebuilding properties HashTable */
40979 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
40980 } else {
40981 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
40982 if (obj_ht) {
40983 /* fast copy */
40984 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
40985 (Z_OBJCE_P(expr)->default_properties_count ||
40986 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
40987 GC_IS_RECURSIVE(obj_ht))));
40988 zend_release_properties(obj_ht);
40989 } else {
40990 ZVAL_EMPTY_ARRAY(result);
40991 }
40992 }
40993 } else {
40994 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
40995 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
40996 if (Z_TYPE_P(expr) == IS_ARRAY) {
40997 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
40998 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
40999 /* TODO: try not to duplicate immutable arrays as well ??? */
41000 ht = zend_array_dup(ht);
41001 }
41002 Z_OBJ_P(result)->properties = ht;
41003 } else if (Z_TYPE_P(expr) != IS_NULL) {
41004 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
41005 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
41006 if (IS_CV == IS_CONST) {
41007 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
41008 } else {
41009 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
41010 }
41011 }
41012 }
41013 }
41014
41015 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41016 }
41017
ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41018 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41019 {
41020 USE_OPLINE
41021 zend_op_array *new_op_array;
41022 zval *inc_filename;
41023
41024 SAVE_OPLINE();
41025 inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41026 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
41027 if (UNEXPECTED(EG(exception) != NULL)) {
41028
41029 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
41030 destroy_op_array(new_op_array);
41031 efree_size(new_op_array, sizeof(zend_op_array));
41032 }
41033 UNDEF_RESULT();
41034 HANDLE_EXCEPTION();
41035 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
41036 if (RETURN_VALUE_USED(opline)) {
41037 ZVAL_TRUE(EX_VAR(opline->result.var));
41038 }
41039 } else if (UNEXPECTED(new_op_array == NULL)) {
41040 if (RETURN_VALUE_USED(opline)) {
41041 ZVAL_FALSE(EX_VAR(opline->result.var));
41042 }
41043 } else if (new_op_array->last == 1
41044 && new_op_array->opcodes[0].opcode == ZEND_RETURN
41045 && new_op_array->opcodes[0].op1_type == IS_CONST
41046 && EXPECTED(zend_execute_ex == execute_ex)) {
41047 if (RETURN_VALUE_USED(opline)) {
41048 const zend_op *op = new_op_array->opcodes;
41049
41050 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
41051 }
41052 zend_destroy_static_vars(new_op_array);
41053 destroy_op_array(new_op_array);
41054 efree_size(new_op_array, sizeof(zend_op_array));
41055 } else {
41056 zval *return_value = NULL;
41057 zend_execute_data *call;
41058 if (RETURN_VALUE_USED(opline)) {
41059 return_value = EX_VAR(opline->result.var);
41060 }
41061
41062 new_op_array->scope = EX(func)->op_array.scope;
41063
41064 call = zend_vm_stack_push_call_frame(
41065 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
41066 (zend_function*)new_op_array, 0,
41067 Z_PTR(EX(This)));
41068
41069 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
41070 call->symbol_table = EX(symbol_table);
41071 } else {
41072 call->symbol_table = zend_rebuild_symbol_table();
41073 }
41074
41075 call->prev_execute_data = execute_data;
41076 i_init_code_execute_data(call, new_op_array, return_value);
41077
41078 if (EXPECTED(zend_execute_ex == execute_ex)) {
41079
41080 ZEND_VM_ENTER();
41081 } else {
41082 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
41083 zend_execute_ex(call);
41084 zend_vm_stack_free_call_frame(call);
41085 }
41086
41087 zend_destroy_static_vars(new_op_array);
41088 destroy_op_array(new_op_array);
41089 efree_size(new_op_array, sizeof(zend_op_array));
41090 if (UNEXPECTED(EG(exception) != NULL)) {
41091 zend_rethrow_exception(execute_data);
41092
41093 UNDEF_RESULT();
41094 HANDLE_EXCEPTION();
41095 }
41096 }
41097
41098 ZEND_VM_NEXT_OPCODE();
41099 }
41100
ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41101 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41102 {
41103 USE_OPLINE
41104 zval *array_ptr, *result;
41105
41106 SAVE_OPLINE();
41107
41108 array_ptr = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41109 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
41110 result = EX_VAR(opline->result.var);
41111 ZVAL_COPY_VALUE(result, array_ptr);
41112 if (IS_CV != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
41113 Z_ADDREF_P(array_ptr);
41114 }
41115 Z_FE_POS_P(result) = 0;
41116
41117 ZEND_VM_NEXT_OPCODE();
41118 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
41119 zend_object *zobj = Z_OBJ_P(array_ptr);
41120 if (!zobj->ce->get_iterator) {
41121 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
41122 zobj = zend_lazy_object_init(zobj);
41123 if (UNEXPECTED(EG(exception))) {
41124 UNDEF_RESULT();
41125
41126 HANDLE_EXCEPTION();
41127 }
41128 }
41129 HashTable *properties = zobj->properties;
41130 if (properties) {
41131 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
41132 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
41133 GC_DELREF(properties);
41134 }
41135 properties = zobj->properties = zend_array_dup(properties);
41136 }
41137 } else {
41138 properties = zobj->handlers->get_properties(zobj);
41139 }
41140
41141 result = EX_VAR(opline->result.var);
41142 ZVAL_COPY_VALUE(result, array_ptr);
41143 if (IS_CV != IS_TMP_VAR) {
41144 Z_ADDREF_P(array_ptr);
41145 }
41146
41147 if (zend_hash_num_elements(properties) == 0) {
41148 Z_FE_ITER_P(result) = (uint32_t) -1;
41149
41150 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41151 }
41152
41153 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
41154
41155 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41156 } else {
41157 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
41158
41159 if (UNEXPECTED(EG(exception))) {
41160 HANDLE_EXCEPTION();
41161 } else if (is_empty) {
41162 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41163 } else {
41164 ZEND_VM_NEXT_OPCODE();
41165 }
41166 }
41167 } else {
41168 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
41169 ZVAL_UNDEF(EX_VAR(opline->result.var));
41170 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
41171
41172 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41173 }
41174 }
41175
ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41176 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41177 {
41178 USE_OPLINE
41179 zval *array_ptr, *array_ref;
41180
41181 SAVE_OPLINE();
41182
41183 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41184 array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41185 if (Z_ISREF_P(array_ref)) {
41186 array_ptr = Z_REFVAL_P(array_ref);
41187 }
41188 } else {
41189 array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41190 }
41191
41192 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
41193 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41194 if (array_ptr == array_ref) {
41195 ZVAL_NEW_REF(array_ref, array_ref);
41196 array_ptr = Z_REFVAL_P(array_ref);
41197 }
41198 Z_ADDREF_P(array_ref);
41199 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
41200 } else {
41201 array_ref = EX_VAR(opline->result.var);
41202 ZVAL_NEW_REF(array_ref, array_ptr);
41203 array_ptr = Z_REFVAL_P(array_ref);
41204 }
41205 if (IS_CV == IS_CONST) {
41206 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
41207 } else {
41208 SEPARATE_ARRAY(array_ptr);
41209 }
41210 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
41211
41212 ZEND_VM_NEXT_OPCODE();
41213 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
41214 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
41215 zend_object *zobj = Z_OBJ_P(array_ptr);
41216 HashTable *properties;
41217 if (UNEXPECTED(zend_object_is_lazy(zobj))) {
41218 zobj = zend_lazy_object_init(zobj);
41219 if (UNEXPECTED(EG(exception))) {
41220 UNDEF_RESULT();
41221
41222 HANDLE_EXCEPTION();
41223 }
41224 }
41225 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
41226 if (array_ptr == array_ref) {
41227 ZVAL_NEW_REF(array_ref, array_ref);
41228 array_ptr = Z_REFVAL_P(array_ref);
41229 }
41230 Z_ADDREF_P(array_ref);
41231 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
41232 } else {
41233 array_ptr = EX_VAR(opline->result.var);
41234 ZVAL_COPY_VALUE(array_ptr, array_ref);
41235 }
41236 if (Z_OBJ_P(array_ptr)->properties
41237 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
41238 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
41239 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
41240 }
41241 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
41242 }
41243
41244 properties = Z_OBJPROP_P(array_ptr);
41245 if (zend_hash_num_elements(properties) == 0) {
41246 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
41247
41248 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41249 }
41250
41251 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
41252
41253 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41254 } else {
41255 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
41256
41257 if (UNEXPECTED(EG(exception))) {
41258 HANDLE_EXCEPTION();
41259 } else if (is_empty) {
41260 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41261 } else {
41262 ZEND_VM_NEXT_OPCODE();
41263 }
41264 }
41265 } else {
41266 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
41267 ZVAL_UNDEF(EX_VAR(opline->result.var));
41268 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
41269
41270 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
41271 }
41272 }
41273
ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41274 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41275 {
41276 USE_OPLINE
41277 zval *value;
41278 zend_reference *ref = NULL;
41279 bool ret;
41280
41281 SAVE_OPLINE();
41282 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41283
41284 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && Z_ISREF_P(value)) {
41285 if (IS_CV == IS_VAR) {
41286 ref = Z_REF_P(value);
41287 }
41288 value = Z_REFVAL_P(value);
41289 }
41290
41291 ret = i_zend_is_true(value);
41292
41293 if (UNEXPECTED(EG(exception))) {
41294
41295 ZVAL_UNDEF(EX_VAR(opline->result.var));
41296 HANDLE_EXCEPTION();
41297 }
41298
41299 if (ret) {
41300 zval *result = EX_VAR(opline->result.var);
41301
41302 ZVAL_COPY_VALUE(result, value);
41303 if (IS_CV == IS_CONST) {
41304 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
41305 } else if (IS_CV == IS_CV) {
41306 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
41307 } else if (IS_CV == IS_VAR && ref) {
41308 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41309 efree_size(ref, sizeof(zend_reference));
41310 } else if (Z_OPT_REFCOUNTED_P(result)) {
41311 Z_ADDREF_P(result);
41312 }
41313 }
41314 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41315 }
41316
41317 ZEND_VM_NEXT_OPCODE();
41318 }
41319
ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41320 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41321 {
41322 USE_OPLINE
41323 zval *value;
41324 zend_reference *ref = NULL;
41325
41326 SAVE_OPLINE();
41327 value = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
41328
41329 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
41330 if (IS_CV & IS_VAR) {
41331 ref = Z_REF_P(value);
41332 }
41333 value = Z_REFVAL_P(value);
41334 }
41335
41336 if (Z_TYPE_P(value) > IS_NULL) {
41337 zval *result = EX_VAR(opline->result.var);
41338 ZVAL_COPY_VALUE(result, value);
41339 if (IS_CV == IS_CONST) {
41340 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
41341 } else if (IS_CV == IS_CV) {
41342 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
41343 } else if ((IS_CV & IS_VAR) && ref) {
41344 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41345 efree_size(ref, sizeof(zend_reference));
41346 } else if (Z_OPT_REFCOUNTED_P(result)) {
41347 Z_ADDREF_P(result);
41348 }
41349 }
41350 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41351 }
41352
41353 if ((IS_CV & IS_VAR) && ref) {
41354 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
41355 efree_size(ref, sizeof(zend_reference));
41356 }
41357 }
41358 ZEND_VM_NEXT_OPCODE();
41359 }
41360
ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41361 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41362 {
41363 USE_OPLINE
41364 zval *val, *result;
41365
41366 val = EX_VAR(opline->op1.var);
41367
41368 if (Z_TYPE_P(val) > IS_NULL) {
41369 do {
41370 if ((IS_CV == IS_CV || IS_CV == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
41371 val = Z_REFVAL_P(val);
41372 if (Z_TYPE_P(val) <= IS_NULL) {
41373
41374 break;
41375 }
41376 }
41377 ZEND_VM_NEXT_OPCODE();
41378 } while (0);
41379 }
41380
41381 result = EX_VAR(opline->result.var);
41382 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
41383 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
41384 ZVAL_NULL(result);
41385 if (IS_CV == IS_CV
41386 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
41387 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
41388 ) {
41389 SAVE_OPLINE();
41390 ZVAL_UNDEFINED_OP1();
41391 if (UNEXPECTED(EG(exception) != NULL)) {
41392 HANDLE_EXCEPTION();
41393 }
41394 }
41395 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
41396 ZVAL_FALSE(result);
41397 } else {
41398 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
41399 ZVAL_TRUE(result);
41400 }
41401
41402 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
41403 }
41404
ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41405 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41406 {
41407 USE_OPLINE
41408 zval *value;
41409 zval *result = EX_VAR(opline->result.var);
41410
41411 value = EX_VAR(opline->op1.var);
41412 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41413 SAVE_OPLINE();
41414 ZVAL_UNDEFINED_OP1();
41415 ZVAL_NULL(result);
41416 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41417 }
41418
41419 if (IS_CV == IS_CV) {
41420 ZVAL_COPY_DEREF(result, value);
41421 } else if (IS_CV == IS_VAR) {
41422 if (UNEXPECTED(Z_ISREF_P(value))) {
41423 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
41424 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
41425 efree_size(Z_REF_P(value), sizeof(zend_reference));
41426 } else if (Z_OPT_REFCOUNTED_P(result)) {
41427 Z_ADDREF_P(result);
41428 }
41429 } else {
41430 ZVAL_COPY_VALUE(result, value);
41431 }
41432 } else {
41433 ZVAL_COPY_VALUE(result, value);
41434 if (IS_CV == IS_CONST) {
41435 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
41436 Z_ADDREF_P(result);
41437 }
41438 }
41439 }
41440 ZEND_VM_NEXT_OPCODE();
41441 }
41442
ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41443 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41444 {
41445 USE_OPLINE
41446 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
41447 zval *val;
41448
41449 SAVE_OPLINE();
41450 val = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41451
41452 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
41453 zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
41454
41455 UNDEF_RESULT();
41456 HANDLE_EXCEPTION();
41457 }
41458
41459 yield_from_try_again:
41460 if (Z_TYPE_P(val) == IS_ARRAY) {
41461 ZVAL_COPY_VALUE(&generator->values, val);
41462 if (Z_OPT_REFCOUNTED_P(val)) {
41463 Z_ADDREF_P(val);
41464 }
41465 Z_FE_POS(generator->values) = 0;
41466
41467 } else if (IS_CV != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
41468 zend_class_entry *ce = Z_OBJCE_P(val);
41469 if (ce == zend_ce_generator) {
41470 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
41471
41472 Z_ADDREF_P(val);
41473
41474 if (UNEXPECTED(new_gen->execute_data == NULL)) {
41475 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
41476 zval_ptr_dtor(val);
41477 UNDEF_RESULT();
41478 HANDLE_EXCEPTION();
41479 } else if (Z_ISUNDEF(new_gen->retval)) {
41480 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
41481 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
41482 zval_ptr_dtor(val);
41483 UNDEF_RESULT();
41484 HANDLE_EXCEPTION();
41485 } else {
41486 zend_generator_yield_from(generator, new_gen);
41487 }
41488 } else {
41489 if (RETURN_VALUE_USED(opline)) {
41490 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
41491 }
41492 ZEND_VM_NEXT_OPCODE();
41493 }
41494 } else {
41495 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
41496
41497 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
41498 if (!EG(exception)) {
41499 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
41500 }
41501 UNDEF_RESULT();
41502 HANDLE_EXCEPTION();
41503 }
41504
41505 iter->index = 0;
41506 if (iter->funcs->rewind) {
41507 iter->funcs->rewind(iter);
41508 if (UNEXPECTED(EG(exception) != NULL)) {
41509 OBJ_RELEASE(&iter->std);
41510 UNDEF_RESULT();
41511 HANDLE_EXCEPTION();
41512 }
41513 }
41514
41515 ZVAL_OBJ(&generator->values, &iter->std);
41516 }
41517 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
41518 val = Z_REFVAL_P(val);
41519 goto yield_from_try_again;
41520 } else {
41521 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
41522
41523 UNDEF_RESULT();
41524 HANDLE_EXCEPTION();
41525 }
41526
41527 /* This is the default return value
41528 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
41529 if (RETURN_VALUE_USED(opline)) {
41530 ZVAL_NULL(EX_VAR(opline->result.var));
41531 }
41532
41533 /* This generator has no send target (though the generator we delegate to might have one) */
41534 generator->send_target = NULL;
41535
41536 /* The GOTO VM uses a local opline variable. We need to set the opline
41537 * variable in execute_data so we don't resume at an old position. */
41538 SAVE_OPLINE();
41539
41540 ZEND_VM_RETURN();
41541 }
41542
ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41543 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41544 {
41545 USE_OPLINE
41546 zval *value;
41547
41548 value = EX_VAR(opline->op1.var);
41549 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
41550 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
41551 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41552 zval_ptr_dtor_str(value);
41553 }
41554 ZEND_VM_NEXT_OPCODE();
41555 } else {
41556 bool strict;
41557
41558 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
41559 value = Z_REFVAL_P(value);
41560 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
41561 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
41562
41563 ZEND_VM_NEXT_OPCODE();
41564 }
41565 }
41566
41567 SAVE_OPLINE();
41568 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41569 value = ZVAL_UNDEFINED_OP1();
41570 }
41571 strict = EX_USES_STRICT_TYPES();
41572 do {
41573 if (EXPECTED(!strict)) {
41574 zend_string *str;
41575 zval tmp;
41576
41577 if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
41578 zend_error(E_DEPRECATED,
41579 "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
41580 ZVAL_LONG(EX_VAR(opline->result.var), 0);
41581 if (UNEXPECTED(EG(exception))) {
41582 HANDLE_EXCEPTION();
41583 }
41584 break;
41585 }
41586
41587 ZVAL_COPY(&tmp, value);
41588 if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
41589 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
41590 zval_ptr_dtor(&tmp);
41591 break;
41592 }
41593 zval_ptr_dtor(&tmp);
41594 }
41595 if (!EG(exception)) {
41596 zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
41597 }
41598 ZVAL_UNDEF(EX_VAR(opline->result.var));
41599 } while (0);
41600 }
41601
41602 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41603 }
41604
ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41605 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41606 {
41607 USE_OPLINE
41608 zval *value;
41609 int result = 0;
41610
41611 value = EX_VAR(opline->op1.var);
41612 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
41613 type_check_resource:
41614 if (opline->extended_value != MAY_BE_RESOURCE
41615 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
41616 result = 1;
41617 }
41618 } else if ((IS_CV & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
41619 value = Z_REFVAL_P(value);
41620 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
41621 goto type_check_resource;
41622 }
41623 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
41624 result = ((1 << IS_NULL) & opline->extended_value) != 0;
41625 SAVE_OPLINE();
41626 ZVAL_UNDEFINED_OP1();
41627 if (UNEXPECTED(EG(exception))) {
41628 ZVAL_UNDEF(EX_VAR(opline->result.var));
41629 HANDLE_EXCEPTION();
41630 }
41631 }
41632 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41633 SAVE_OPLINE();
41634
41635 ZEND_VM_SMART_BRANCH(result, 1);
41636 } else {
41637 ZEND_VM_SMART_BRANCH(result, 0);
41638 }
41639 }
41640
ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41641 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41642 {
41643 uint32_t fetch_type;
41644 zend_class_entry *called_scope, *scope;
41645 USE_OPLINE
41646
41647 if (IS_CV != IS_UNUSED) {
41648 SAVE_OPLINE();
41649 zval *op = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41650 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
41651 ZVAL_DEREF(op);
41652 if (Z_TYPE_P(op) != IS_OBJECT) {
41653 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
41654 ZVAL_UNDEF(EX_VAR(opline->result.var));
41655
41656 HANDLE_EXCEPTION();
41657 }
41658 }
41659
41660 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
41661
41662 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41663 }
41664
41665 fetch_type = opline->op1.num;
41666 scope = EX(func)->op_array.scope;
41667 if (UNEXPECTED(scope == NULL)) {
41668 SAVE_OPLINE();
41669 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
41670 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
41671 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
41672 ZVAL_UNDEF(EX_VAR(opline->result.var));
41673 HANDLE_EXCEPTION();
41674 }
41675
41676 switch (fetch_type) {
41677 case ZEND_FETCH_CLASS_SELF:
41678 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
41679 break;
41680 case ZEND_FETCH_CLASS_PARENT:
41681 if (UNEXPECTED(scope->parent == NULL)) {
41682 SAVE_OPLINE();
41683 zend_throw_error(NULL,
41684 "Cannot use \"parent\" when current class scope has no parent");
41685 ZVAL_UNDEF(EX_VAR(opline->result.var));
41686 HANDLE_EXCEPTION();
41687 }
41688 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
41689 break;
41690 case ZEND_FETCH_CLASS_STATIC:
41691 if (Z_TYPE(EX(This)) == IS_OBJECT) {
41692 called_scope = Z_OBJCE(EX(This));
41693 } else {
41694 called_scope = Z_CE(EX(This));
41695 }
41696 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
41697 break;
41698 EMPTY_SWITCH_DEFAULT_CASE()
41699 }
41700 ZEND_VM_NEXT_OPCODE();
41701 }
41702
ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41703 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41704 {
41705 USE_OPLINE
41706 HashTable *ht;
41707 zval *value;
41708 zval *variable_ptr;
41709
41710 variable_ptr = EX_VAR(opline->op1.var);
41711
41712 SAVE_OPLINE();
41713
41714 ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
41715 if (!ht) {
41716 ht = zend_array_dup(EX(func)->op_array.static_variables);
41717 ZEND_MAP_PTR_SET(EX(func)->op_array.static_variables_ptr, ht);
41718 }
41719 ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
41720
41721 value = (zval*)((char*)ht->arData + (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT|ZEND_BIND_EXPLICIT)));
41722
41723 if (opline->extended_value & ZEND_BIND_REF) {
41724 i_zval_ptr_dtor(variable_ptr);
41725 if (UNEXPECTED(!Z_ISREF_P(value))) {
41726 zend_reference *ref = (zend_reference*)emalloc(sizeof(zend_reference));
41727 GC_SET_REFCOUNT(ref, 2);
41728 GC_TYPE_INFO(ref) = GC_REFERENCE;
41729 if (opline->op2_type == IS_UNUSED) {
41730 ZVAL_COPY_VALUE(&ref->val, value);
41731 } else {
41732 ZEND_ASSERT(!Z_REFCOUNTED_P(value));
41733 ZVAL_COPY(&ref->val, get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R));
41734 FREE_OP(opline->op2_type, opline->op2.var);
41735 }
41736 ref->sources.ptr = NULL;
41737 Z_REF_P(value) = ref;
41738 Z_TYPE_INFO_P(value) = IS_REFERENCE_EX;
41739 ZVAL_REF(variable_ptr, ref);
41740 } else {
41741 Z_ADDREF_P(value);
41742 ZVAL_REF(variable_ptr, Z_REF_P(value));
41743 if (opline->op2_type != IS_UNUSED) {
41744 FREE_OP(opline->op2_type, opline->op2.var);
41745 }
41746 }
41747 } else {
41748 i_zval_ptr_dtor(variable_ptr);
41749 ZVAL_COPY(variable_ptr, value);
41750 }
41751
41752 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41753 }
41754
ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41755 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41756 {
41757 USE_OPLINE
41758 HashTable *ht;
41759 zval *value;
41760 zval *variable_ptr;
41761
41762 variable_ptr = EX_VAR(opline->op1.var);
41763
41764 ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
41765 if (!ht) {
41766 ZEND_VM_NEXT_OPCODE();
41767 }
41768 ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
41769
41770 value = (zval*)((char*)ht->arData + opline->extended_value);
41771 if (Z_TYPE_P(value) == IS_NULL) {
41772 ZEND_VM_NEXT_OPCODE();
41773 } else {
41774 SAVE_OPLINE();
41775 zval_ptr_dtor(variable_ptr);
41776 ZEND_ASSERT(Z_TYPE_P(value) == IS_REFERENCE);
41777 Z_ADDREF_P(value);
41778 ZVAL_REF(variable_ptr, Z_REF_P(value));
41779 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 1);
41780 }
41781 }
41782
ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41783 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41784 {
41785 USE_OPLINE
41786 zval *var_ptr;
41787
41788 var_ptr = EX_VAR(opline->op1.var);
41789 Z_LVAL_P(var_ptr)++;
41790 if (UNEXPECTED(0)) {
41791 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41792 }
41793 ZEND_VM_NEXT_OPCODE();
41794 }
41795
ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41796 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41797 {
41798 USE_OPLINE
41799 zval *var_ptr;
41800
41801 var_ptr = EX_VAR(opline->op1.var);
41802 Z_LVAL_P(var_ptr)++;
41803 if (UNEXPECTED(1)) {
41804 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41805 }
41806 ZEND_VM_NEXT_OPCODE();
41807 }
41808
ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41809 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41810 {
41811 USE_OPLINE
41812 zval *var_ptr;
41813
41814 var_ptr = EX_VAR(opline->op1.var);
41815 fast_long_increment_function(var_ptr);
41816 if (UNEXPECTED(0)) {
41817 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41818 }
41819 ZEND_VM_NEXT_OPCODE();
41820 }
41821
ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41822 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41823 {
41824 USE_OPLINE
41825 zval *var_ptr;
41826
41827 var_ptr = EX_VAR(opline->op1.var);
41828 fast_long_increment_function(var_ptr);
41829 if (UNEXPECTED(1)) {
41830 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41831 }
41832 ZEND_VM_NEXT_OPCODE();
41833 }
41834
ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41835 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41836 {
41837 USE_OPLINE
41838 zval *var_ptr;
41839
41840 var_ptr = EX_VAR(opline->op1.var);
41841 Z_LVAL_P(var_ptr)--;
41842 if (UNEXPECTED(0)) {
41843 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41844 }
41845 ZEND_VM_NEXT_OPCODE();
41846 }
41847
ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41848 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41849 {
41850 USE_OPLINE
41851 zval *var_ptr;
41852
41853 var_ptr = EX_VAR(opline->op1.var);
41854 Z_LVAL_P(var_ptr)--;
41855 if (UNEXPECTED(1)) {
41856 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41857 }
41858 ZEND_VM_NEXT_OPCODE();
41859 }
41860
ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41861 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41862 {
41863 USE_OPLINE
41864 zval *var_ptr;
41865
41866 var_ptr = EX_VAR(opline->op1.var);
41867 fast_long_decrement_function(var_ptr);
41868 if (UNEXPECTED(0)) {
41869 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41870 }
41871 ZEND_VM_NEXT_OPCODE();
41872 }
41873
ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41874 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41875 {
41876 USE_OPLINE
41877 zval *var_ptr;
41878
41879 var_ptr = EX_VAR(opline->op1.var);
41880 fast_long_decrement_function(var_ptr);
41881 if (UNEXPECTED(1)) {
41882 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
41883 }
41884 ZEND_VM_NEXT_OPCODE();
41885 }
41886
ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41887 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41888 {
41889 USE_OPLINE
41890 zval *var_ptr;
41891
41892 var_ptr = EX_VAR(opline->op1.var);
41893 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41894 Z_LVAL_P(var_ptr)++;
41895 ZEND_VM_NEXT_OPCODE();
41896 }
41897
ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41898 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41899 {
41900 USE_OPLINE
41901 zval *var_ptr;
41902
41903 var_ptr = EX_VAR(opline->op1.var);
41904 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41905 fast_long_increment_function(var_ptr);
41906 ZEND_VM_NEXT_OPCODE();
41907 }
41908
ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41909 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41910 {
41911 USE_OPLINE
41912 zval *var_ptr;
41913
41914 var_ptr = EX_VAR(opline->op1.var);
41915 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41916 Z_LVAL_P(var_ptr)--;
41917 ZEND_VM_NEXT_OPCODE();
41918 }
41919
ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41920 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41921 {
41922 USE_OPLINE
41923 zval *var_ptr;
41924
41925 var_ptr = EX_VAR(opline->op1.var);
41926 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
41927 fast_long_decrement_function(var_ptr);
41928 ZEND_VM_NEXT_OPCODE();
41929 }
41930
ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41931 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41932 {
41933 USE_OPLINE
41934 zval *varptr, *arg;
41935
41936 varptr = EX_VAR(opline->op1.var);
41937 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
41938
41939 if (IS_CV == IS_CV) {
41940 ZVAL_COPY(arg, varptr);
41941 } else /* if (IS_CV == IS_VAR) */ {
41942 ZVAL_COPY_VALUE(arg, varptr);
41943 }
41944
41945 ZEND_VM_NEXT_OPCODE();
41946 }
41947
ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41948 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41949 {
41950 USE_OPLINE
41951 zval *op1, *op2;
41952
41953 SAVE_OPLINE();
41954 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41955 op2 = RT_CONSTANT(opline, opline->op2);
41956 div_function(EX_VAR(opline->result.var), op1, op2);
41957
41958
41959 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41960 }
41961
ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41962 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41963 {
41964 USE_OPLINE
41965 zval *op1, *op2;
41966
41967 SAVE_OPLINE();
41968 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41969 op2 = RT_CONSTANT(opline, opline->op2);
41970 pow_function(EX_VAR(opline->result.var), op1, op2);
41971
41972
41973 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41974 }
41975
ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41976 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41977 {
41978 USE_OPLINE
41979 zval *op1, *op2;
41980
41981 op1 = EX_VAR(opline->op1.var);
41982 op2 = RT_CONSTANT(opline, opline->op2);
41983
41984 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
41985 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
41986 zend_string *op1_str = Z_STR_P(op1);
41987 zend_string *op2_str = Z_STR_P(op2);
41988 zend_string *str;
41989 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
41990
41991 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
41992 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
41993 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
41994 } else {
41995 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
41996 }
41997 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41998 zend_string_release_ex(op1_str, 0);
41999 }
42000 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
42001 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
42002 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
42003 } else {
42004 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
42005 }
42006 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42007 zend_string_release_ex(op2_str, 0);
42008 }
42009 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
42010 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
42011 size_t len = ZSTR_LEN(op1_str);
42012
42013 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
42014 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
42015 }
42016 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
42017 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
42018 GC_ADD_FLAGS(str, flags);
42019 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
42020 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42021 zend_string_release_ex(op2_str, 0);
42022 }
42023 } else {
42024 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
42025 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
42026 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
42027 GC_ADD_FLAGS(str, flags);
42028 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
42029 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42030 zend_string_release_ex(op1_str, 0);
42031 }
42032 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42033 zend_string_release_ex(op2_str, 0);
42034 }
42035 }
42036 ZEND_VM_NEXT_OPCODE();
42037 } else {
42038 SAVE_OPLINE();
42039
42040 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
42041 op1 = ZVAL_UNDEFINED_OP1();
42042 }
42043 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
42044 op2 = ZVAL_UNDEFINED_OP2();
42045 }
42046 concat_function(EX_VAR(opline->result.var), op1, op2);
42047
42048
42049 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42050 }
42051 }
42052
ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42053 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42054 {
42055 USE_OPLINE
42056 zval *op1, *op2;
42057 bool result;
42058
42059 SAVE_OPLINE();
42060 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42061 op2 = RT_CONSTANT(opline, opline->op2);
42062 result = fast_is_identical_function(op1, op2);
42063
42064
42065 ZEND_VM_SMART_BRANCH(result, 1);
42066 }
42067
ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42068 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42069 {
42070 USE_OPLINE
42071 zval *op1, *op2;
42072 bool result;
42073
42074 SAVE_OPLINE();
42075 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42076 op2 = RT_CONSTANT(opline, opline->op2);
42077 result = fast_is_not_identical_function(op1, op2);
42078
42079
42080 ZEND_VM_SMART_BRANCH(result, 1);
42081 }
42082
ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42083 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42084 {
42085 USE_OPLINE
42086 zval *op1, *op2;
42087 double d1, d2;
42088
42089 op1 = EX_VAR(opline->op1.var);
42090 op2 = RT_CONSTANT(opline, opline->op2);
42091 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42092 /* pass */
42093 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42094 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42095 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42096 is_equal_true:
42097 ZEND_VM_SMART_BRANCH_TRUE_NONE();
42098 } else {
42099 is_equal_false:
42100 ZEND_VM_SMART_BRANCH_FALSE_NONE();
42101 }
42102 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42103 d1 = (double)Z_LVAL_P(op1);
42104 d2 = Z_DVAL_P(op2);
42105 goto is_equal_double;
42106 }
42107 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42108 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42109 d1 = Z_DVAL_P(op1);
42110 d2 = Z_DVAL_P(op2);
42111 is_equal_double:
42112 if (d1 == d2) {
42113 goto is_equal_true;
42114 } else {
42115 goto is_equal_false;
42116 }
42117 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42118 d1 = Z_DVAL_P(op1);
42119 d2 = (double)Z_LVAL_P(op2);
42120 goto is_equal_double;
42121 }
42122 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42123 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42124 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42125 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42126 zval_ptr_dtor_str(op1);
42127 }
42128 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42129 zval_ptr_dtor_str(op2);
42130 }
42131 if (result) {
42132 goto is_equal_true;
42133 } else {
42134 goto is_equal_false;
42135 }
42136 }
42137 }
42138 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42139 }
42140
ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42141 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42142 {
42143 USE_OPLINE
42144 zval *op1, *op2;
42145 double d1, d2;
42146
42147 op1 = EX_VAR(opline->op1.var);
42148 op2 = RT_CONSTANT(opline, opline->op2);
42149 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42150 /* pass */
42151 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42152 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42153 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42154 is_equal_true:
42155 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
42156 } else {
42157 is_equal_false:
42158 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
42159 }
42160 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42161 d1 = (double)Z_LVAL_P(op1);
42162 d2 = Z_DVAL_P(op2);
42163 goto is_equal_double;
42164 }
42165 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42166 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42167 d1 = Z_DVAL_P(op1);
42168 d2 = Z_DVAL_P(op2);
42169 is_equal_double:
42170 if (d1 == d2) {
42171 goto is_equal_true;
42172 } else {
42173 goto is_equal_false;
42174 }
42175 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42176 d1 = Z_DVAL_P(op1);
42177 d2 = (double)Z_LVAL_P(op2);
42178 goto is_equal_double;
42179 }
42180 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42181 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42182 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42183 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42184 zval_ptr_dtor_str(op1);
42185 }
42186 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42187 zval_ptr_dtor_str(op2);
42188 }
42189 if (result) {
42190 goto is_equal_true;
42191 } else {
42192 goto is_equal_false;
42193 }
42194 }
42195 }
42196 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42197 }
42198
ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42199 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42200 {
42201 USE_OPLINE
42202 zval *op1, *op2;
42203 double d1, d2;
42204
42205 op1 = EX_VAR(opline->op1.var);
42206 op2 = RT_CONSTANT(opline, opline->op2);
42207 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42208 /* pass */
42209 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42210 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42211 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
42212 is_equal_true:
42213 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
42214 } else {
42215 is_equal_false:
42216 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
42217 }
42218 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42219 d1 = (double)Z_LVAL_P(op1);
42220 d2 = Z_DVAL_P(op2);
42221 goto is_equal_double;
42222 }
42223 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42224 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42225 d1 = Z_DVAL_P(op1);
42226 d2 = Z_DVAL_P(op2);
42227 is_equal_double:
42228 if (d1 == d2) {
42229 goto is_equal_true;
42230 } else {
42231 goto is_equal_false;
42232 }
42233 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42234 d1 = Z_DVAL_P(op1);
42235 d2 = (double)Z_LVAL_P(op2);
42236 goto is_equal_double;
42237 }
42238 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42239 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42240 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42241 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42242 zval_ptr_dtor_str(op1);
42243 }
42244 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42245 zval_ptr_dtor_str(op2);
42246 }
42247 if (result) {
42248 goto is_equal_true;
42249 } else {
42250 goto is_equal_false;
42251 }
42252 }
42253 }
42254 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42255 }
42256
ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42257 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42258 {
42259 USE_OPLINE
42260 zval *op1, *op2;
42261 double d1, d2;
42262
42263 op1 = EX_VAR(opline->op1.var);
42264 op2 = RT_CONSTANT(opline, opline->op2);
42265 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42266 /* pass */
42267 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42268 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42269 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42270 is_not_equal_true:
42271 ZEND_VM_SMART_BRANCH_TRUE_NONE();
42272 } else {
42273 is_not_equal_false:
42274 ZEND_VM_SMART_BRANCH_FALSE_NONE();
42275 }
42276 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42277 d1 = (double)Z_LVAL_P(op1);
42278 d2 = Z_DVAL_P(op2);
42279 goto is_not_equal_double;
42280 }
42281 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42282 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42283 d1 = Z_DVAL_P(op1);
42284 d2 = Z_DVAL_P(op2);
42285 is_not_equal_double:
42286 if (d1 != d2) {
42287 goto is_not_equal_true;
42288 } else {
42289 goto is_not_equal_false;
42290 }
42291 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42292 d1 = Z_DVAL_P(op1);
42293 d2 = (double)Z_LVAL_P(op2);
42294 goto is_not_equal_double;
42295 }
42296 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42297 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42298 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42299 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42300 zval_ptr_dtor_str(op1);
42301 }
42302 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42303 zval_ptr_dtor_str(op2);
42304 }
42305 if (!result) {
42306 goto is_not_equal_true;
42307 } else {
42308 goto is_not_equal_false;
42309 }
42310 }
42311 }
42312 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42313 }
42314
ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42315 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42316 {
42317 USE_OPLINE
42318 zval *op1, *op2;
42319 double d1, d2;
42320
42321 op1 = EX_VAR(opline->op1.var);
42322 op2 = RT_CONSTANT(opline, opline->op2);
42323 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42324 /* pass */
42325 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42326 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42327 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42328 is_not_equal_true:
42329 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
42330 } else {
42331 is_not_equal_false:
42332 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
42333 }
42334 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42335 d1 = (double)Z_LVAL_P(op1);
42336 d2 = Z_DVAL_P(op2);
42337 goto is_not_equal_double;
42338 }
42339 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42340 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42341 d1 = Z_DVAL_P(op1);
42342 d2 = Z_DVAL_P(op2);
42343 is_not_equal_double:
42344 if (d1 != d2) {
42345 goto is_not_equal_true;
42346 } else {
42347 goto is_not_equal_false;
42348 }
42349 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42350 d1 = Z_DVAL_P(op1);
42351 d2 = (double)Z_LVAL_P(op2);
42352 goto is_not_equal_double;
42353 }
42354 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42355 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42356 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42357 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42358 zval_ptr_dtor_str(op1);
42359 }
42360 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42361 zval_ptr_dtor_str(op2);
42362 }
42363 if (!result) {
42364 goto is_not_equal_true;
42365 } else {
42366 goto is_not_equal_false;
42367 }
42368 }
42369 }
42370 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42371 }
42372
ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42373 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42374 {
42375 USE_OPLINE
42376 zval *op1, *op2;
42377 double d1, d2;
42378
42379 op1 = EX_VAR(opline->op1.var);
42380 op2 = RT_CONSTANT(opline, opline->op2);
42381 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
42382 /* pass */
42383 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
42384 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42385 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
42386 is_not_equal_true:
42387 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
42388 } else {
42389 is_not_equal_false:
42390 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
42391 }
42392 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42393 d1 = (double)Z_LVAL_P(op1);
42394 d2 = Z_DVAL_P(op2);
42395 goto is_not_equal_double;
42396 }
42397 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
42398 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
42399 d1 = Z_DVAL_P(op1);
42400 d2 = Z_DVAL_P(op2);
42401 is_not_equal_double:
42402 if (d1 != d2) {
42403 goto is_not_equal_true;
42404 } else {
42405 goto is_not_equal_false;
42406 }
42407 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
42408 d1 = Z_DVAL_P(op1);
42409 d2 = (double)Z_LVAL_P(op2);
42410 goto is_not_equal_double;
42411 }
42412 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
42413 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
42414 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
42415 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
42416 zval_ptr_dtor_str(op1);
42417 }
42418 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
42419 zval_ptr_dtor_str(op2);
42420 }
42421 if (!result) {
42422 goto is_not_equal_true;
42423 } else {
42424 goto is_not_equal_false;
42425 }
42426 }
42427 }
42428 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
42429 }
42430
ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42431 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42432 {
42433 USE_OPLINE
42434 zval *op1, *op2;
42435
42436 SAVE_OPLINE();
42437 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42438 op2 = RT_CONSTANT(opline, opline->op2);
42439 compare_function(EX_VAR(opline->result.var), op1, op2);
42440
42441
42442 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42443 }
42444
ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42445 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42446 {
42447 USE_OPLINE
42448 zval *op1, *op2;
42449
42450 SAVE_OPLINE();
42451 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
42452 op2 = RT_CONSTANT(opline, opline->op2);
42453 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
42454
42455
42456 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42457 }
42458
ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42459 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42460 {
42461 USE_OPLINE
42462 zval *object;
42463 zval *property;
42464 zval *value;
42465 zval *zptr;
42466 void *_cache_slot[3] = {0};
42467 void **cache_slot;
42468 zend_property_info *prop_info;
42469 zend_object *zobj;
42470 zend_string *name, *tmp_name;
42471
42472 SAVE_OPLINE();
42473 object = EX_VAR(opline->op1.var);
42474 property = RT_CONSTANT(opline, opline->op2);
42475
42476 do {
42477 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
42478
42479 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42480 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42481 object = Z_REFVAL_P(object);
42482 goto assign_op_object;
42483 }
42484 if (IS_CV == IS_CV
42485 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42486 ZVAL_UNDEFINED_OP1();
42487 }
42488 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42489 break;
42490 }
42491
42492 assign_op_object:
42493 /* here we are sure we are dealing with an object */
42494 zobj = Z_OBJ_P(object);
42495 if (IS_CONST == IS_CONST) {
42496 name = Z_STR_P(property);
42497 } else {
42498 name = zval_try_get_tmp_string(property, &tmp_name);
42499 if (UNEXPECTED(!name)) {
42500 UNDEF_RESULT();
42501 break;
42502 }
42503 }
42504 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
42505 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42506 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42507 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42508 ZVAL_NULL(EX_VAR(opline->result.var));
42509 }
42510 } else {
42511 zend_reference *ref;
42512
42513 do {
42514 if (UNEXPECTED(Z_ISREF_P(zptr))) {
42515 ref = Z_REF_P(zptr);
42516 zptr = Z_REFVAL_P(zptr);
42517 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42518 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42519 break;
42520 }
42521 }
42522
42523 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
42524 if (prop_info) {
42525 /* special case for typed properties */
42526 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
42527 } else {
42528 zend_binary_op(zptr, zptr, value OPLINE_CC);
42529 }
42530 } while (0);
42531
42532 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42533 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
42534 }
42535 }
42536 } else {
42537 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
42538 }
42539 if (IS_CONST != IS_CONST) {
42540 zend_tmp_string_release(tmp_name);
42541 }
42542 } while (0);
42543
42544 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42545
42546
42547 /* assign_obj has two opcodes! */
42548 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42549 }
42550
42551 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42552 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42553 {
42554 USE_OPLINE
42555 zval *var_ptr;
42556 zval *value, *container, *dim;
42557 HashTable *ht;
42558
42559 SAVE_OPLINE();
42560 container = EX_VAR(opline->op1.var);
42561
42562 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42563 assign_dim_op_array:
42564 SEPARATE_ARRAY(container);
42565 ht = Z_ARRVAL_P(container);
42566 assign_dim_op_new_array:
42567 dim = RT_CONSTANT(opline, opline->op2);
42568 if (IS_CONST == IS_UNUSED) {
42569 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
42570 if (UNEXPECTED(!var_ptr)) {
42571 zend_cannot_add_element();
42572 goto assign_dim_op_ret_null;
42573 }
42574 } else {
42575 if (IS_CONST == IS_CONST) {
42576 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
42577 } else {
42578 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
42579 }
42580 if (UNEXPECTED(!var_ptr)) {
42581 goto assign_dim_op_ret_null;
42582 }
42583 }
42584
42585 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
42586
42587 do {
42588 if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
42589 zend_reference *ref = Z_REF_P(var_ptr);
42590 var_ptr = Z_REFVAL_P(var_ptr);
42591 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42592 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42593 break;
42594 }
42595 }
42596 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
42597 } while (0);
42598
42599 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42600 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
42601 }
42602 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42603 } else {
42604 if (EXPECTED(Z_ISREF_P(container))) {
42605 container = Z_REFVAL_P(container);
42606 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42607 goto assign_dim_op_array;
42608 }
42609 }
42610
42611 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
42612 zend_object *obj = Z_OBJ_P(container);
42613
42614 dim = RT_CONSTANT(opline, opline->op2);
42615 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42616 dim++;
42617 }
42618 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
42619 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
42620 uint8_t old_type;
42621
42622 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
42623 ZVAL_UNDEFINED_OP1();
42624 }
42625 ht = zend_new_array(8);
42626 old_type = Z_TYPE_P(container);
42627 ZVAL_ARR(container, ht);
42628 if (UNEXPECTED(old_type == IS_FALSE)) {
42629 GC_ADDREF(ht);
42630 zend_false_to_array_deprecated();
42631 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
42632 zend_array_destroy(ht);
42633 goto assign_dim_op_ret_null;
42634 }
42635 }
42636 goto assign_dim_op_new_array;
42637 } else {
42638 dim = RT_CONSTANT(opline, opline->op2);
42639 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
42640 assign_dim_op_ret_null:
42641 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
42642 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42643 ZVAL_NULL(EX_VAR(opline->result.var));
42644 }
42645 }
42646 }
42647
42648
42649 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42650 }
42651
ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42652 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42653 {
42654 USE_OPLINE
42655 zval *var_ptr;
42656 zval *value;
42657
42658 SAVE_OPLINE();
42659 value = RT_CONSTANT(opline, opline->op2);
42660 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
42661
42662 do {
42663 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
42664 zend_reference *ref = Z_REF_P(var_ptr);
42665 var_ptr = Z_REFVAL_P(var_ptr);
42666 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
42667 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
42668 break;
42669 }
42670 }
42671 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
42672 } while (0);
42673
42674 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42675 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
42676 }
42677
42678
42679 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42680 }
42681
ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42682 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42683 {
42684 USE_OPLINE
42685 zval *object;
42686 zval *property;
42687 zval *zptr;
42688 void *_cache_slot[3] = {0};
42689 void **cache_slot;
42690 zend_property_info *prop_info;
42691 zend_object *zobj;
42692 zend_string *name, *tmp_name;
42693
42694 SAVE_OPLINE();
42695 object = EX_VAR(opline->op1.var);
42696 property = RT_CONSTANT(opline, opline->op2);
42697
42698 do {
42699 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42700 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42701 object = Z_REFVAL_P(object);
42702 goto pre_incdec_object;
42703 }
42704 if (IS_CV == IS_CV
42705 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42706 ZVAL_UNDEFINED_OP1();
42707 }
42708 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42709 break;
42710 }
42711
42712 pre_incdec_object:
42713 /* here we are sure we are dealing with an object */
42714 zobj = Z_OBJ_P(object);
42715 if (IS_CONST == IS_CONST) {
42716 name = Z_STR_P(property);
42717 } else {
42718 name = zval_try_get_tmp_string(property, &tmp_name);
42719 if (UNEXPECTED(!name)) {
42720 UNDEF_RESULT();
42721 break;
42722 }
42723 }
42724 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
42725 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42726 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42727 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42728 ZVAL_NULL(EX_VAR(opline->result.var));
42729 }
42730 } else {
42731 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
42732 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
42733 }
42734 } else {
42735 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
42736 }
42737 if (IS_CONST != IS_CONST) {
42738 zend_tmp_string_release(tmp_name);
42739 }
42740 } while (0);
42741
42742
42743 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42744 }
42745
ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42746 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42747 {
42748 USE_OPLINE
42749 zval *object;
42750 zval *property;
42751 zval *zptr;
42752 void *_cache_slot[3] = {0};
42753 void **cache_slot;
42754 zend_property_info *prop_info;
42755 zend_object *zobj;
42756 zend_string *name, *tmp_name;
42757
42758 SAVE_OPLINE();
42759 object = EX_VAR(opline->op1.var);
42760 property = RT_CONSTANT(opline, opline->op2);
42761
42762 do {
42763 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42764 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42765 object = Z_REFVAL_P(object);
42766 goto post_incdec_object;
42767 }
42768 if (IS_CV == IS_CV
42769 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
42770 ZVAL_UNDEFINED_OP1();
42771 }
42772 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
42773 break;
42774 }
42775
42776 post_incdec_object:
42777 /* here we are sure we are dealing with an object */
42778 zobj = Z_OBJ_P(object);
42779 if (IS_CONST == IS_CONST) {
42780 name = Z_STR_P(property);
42781 } else {
42782 name = zval_try_get_tmp_string(property, &tmp_name);
42783 if (UNEXPECTED(!name)) {
42784 ZVAL_UNDEF(EX_VAR(opline->result.var));
42785 break;
42786 }
42787 }
42788 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
42789 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
42790 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
42791 ZVAL_NULL(EX_VAR(opline->result.var));
42792 } else {
42793 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
42794 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
42795 }
42796 } else {
42797 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
42798 }
42799 if (IS_CONST != IS_CONST) {
42800 zend_tmp_string_release(tmp_name);
42801 }
42802 } while (0);
42803
42804
42805 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42806 }
42807
ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42808 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42809 {
42810 USE_OPLINE
42811 zval *container, *dim, *value;
42812
42813 SAVE_OPLINE();
42814 container = EX_VAR(opline->op1.var);
42815 dim = RT_CONSTANT(opline, opline->op2);
42816 if (IS_CV != IS_CONST) {
42817 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42818 fetch_dim_r_array:
42819 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
42820 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42821 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
42822 container = Z_REFVAL_P(container);
42823 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
42824 goto fetch_dim_r_array;
42825 } else {
42826 goto fetch_dim_r_slow;
42827 }
42828 } else {
42829 fetch_dim_r_slow:
42830 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42831 dim++;
42832 }
42833 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
42834 }
42835 } else {
42836 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42837 }
42838
42839
42840 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42841 }
42842
ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42843 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42844 {
42845 USE_OPLINE
42846 zval *container;
42847
42848 SAVE_OPLINE();
42849 container = EX_VAR(opline->op1.var);
42850 zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42851
42852 if (IS_CV == IS_VAR) {
42853 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42854 }
42855 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42856 }
42857
ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42858 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42859 {
42860 USE_OPLINE
42861 zval *container;
42862
42863 SAVE_OPLINE();
42864 container = EX_VAR(opline->op1.var);
42865 zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42866
42867 if (IS_CV == IS_VAR) {
42868 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42869 }
42870 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42871 }
42872
ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42873 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42874 {
42875 USE_OPLINE
42876 zval *container;
42877
42878 SAVE_OPLINE();
42879 container = EX_VAR(opline->op1.var);
42880 zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
42881
42882
42883 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42884 }
42885
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42886 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42887 {
42888 #if 0
42889 USE_OPLINE
42890 #endif
42891
42892 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
42893 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
42894 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42895 }
42896 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42897 } else {
42898 if (IS_CONST == IS_UNUSED) {
42899 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42900 }
42901 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42902 }
42903 }
42904
ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42905 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_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_UNSET(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
ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42920 static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42921 {
42922 USE_OPLINE
42923 zval *container;
42924 void **cache_slot = NULL;
42925
42926 SAVE_OPLINE();
42927 container = EX_VAR(opline->op1.var);
42928
42929 if (IS_CV == IS_CONST ||
42930 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
42931 do {
42932 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
42933 container = Z_REFVAL_P(container);
42934 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
42935 break;
42936 }
42937 }
42938 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
42939 ZVAL_UNDEFINED_OP1();
42940 }
42941 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
42942 ZVAL_NULL(EX_VAR(opline->result.var));
42943 goto fetch_obj_r_finish;
42944 } while (0);
42945 }
42946
42947 /* here we are sure we are dealing with an object */
42948 do {
42949 zend_object *zobj = Z_OBJ_P(container);
42950 zend_string *name, *tmp_name;
42951 zval *retval;
42952
42953 if (IS_CONST == IS_CONST) {
42954 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
42955
42956 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
42957 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
42958
42959 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
42960 fetch_obj_r_simple:
42961 retval = OBJ_PROP(zobj, prop_offset);
42962 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
42963 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
42964 goto fetch_obj_r_copy;
42965 } else {
42966 fetch_obj_r_fast_copy:
42967 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
42968 ZEND_VM_NEXT_OPCODE();
42969 }
42970 }
42971 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
42972 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
42973 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
42974 prop_offset = prop_info->offset;
42975 goto fetch_obj_r_simple;
42976 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
42977 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
42978 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
42979 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
42980
42981 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
42982 if (IS_CV & IS_CV) {
42983 GC_ADDREF(zobj);
42984 }
42985 if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
42986 call_info |= ZEND_CALL_RELEASE_THIS;
42987 }
42988 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
42989 call->prev_execute_data = execute_data;
42990 call->call = NULL;
42991 call->return_value = EX_VAR(opline->result.var);
42992 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
42993
42994 execute_data = call;
42995 EG(current_execute_data) = execute_data;
42996 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
42997
42998 #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
42999 opline = hook->op_array.opcodes;
43000 #else
43001 EX(opline) = hook->op_array.opcodes;
43002 #endif
43003 LOAD_OPLINE_EX();
43004
43005
43006 ZEND_VM_ENTER_EX();
43007 }
43008 /* Fall through to read_property for hooks. */
43009 } else if (EXPECTED(zobj->properties != NULL)) {
43010 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
43011 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43012 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
43013 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
43014
43015 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
43016 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
43017
43018 if (EXPECTED(p->key == name) ||
43019 (EXPECTED(p->h == ZSTR_H(name)) &&
43020 EXPECTED(p->key != NULL) &&
43021 EXPECTED(zend_string_equal_content(p->key, name)))) {
43022 retval = &p->val;
43023 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43024 goto fetch_obj_r_copy;
43025 } else {
43026 goto fetch_obj_r_fast_copy;
43027 }
43028 }
43029 }
43030 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
43031 }
43032 retval = zend_hash_find_known_hash(zobj->properties, name);
43033 if (EXPECTED(retval)) {
43034 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
43035 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
43036 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43037 goto fetch_obj_r_copy;
43038 } else {
43039 goto fetch_obj_r_fast_copy;
43040 }
43041 }
43042 }
43043 }
43044 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43045 } else {
43046 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43047 if (UNEXPECTED(!name)) {
43048 ZVAL_UNDEF(EX_VAR(opline->result.var));
43049 break;
43050 }
43051 }
43052
43053 #if ZEND_DEBUG
43054 /* For non-standard object handlers, verify a declared property type in debug builds.
43055 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
43056 zend_property_info *prop_info = NULL;
43057 if (zobj->handlers->read_property != zend_std_read_property) {
43058 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
43059 }
43060 #endif
43061 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
43062 #if ZEND_DEBUG
43063 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
43064 && ZEND_TYPE_IS_SET(prop_info->type)) {
43065 ZVAL_OPT_DEREF(retval);
43066 zend_verify_property_type(prop_info, retval, /* strict */ true);
43067 }
43068 #endif
43069
43070 if (IS_CONST != IS_CONST) {
43071 zend_tmp_string_release(tmp_name);
43072 }
43073
43074 if (retval != EX_VAR(opline->result.var)) {
43075 fetch_obj_r_copy:
43076 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43077 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
43078 zend_unwrap_reference(retval);
43079 }
43080 } while (0);
43081
43082 fetch_obj_r_finish:
43083
43084
43085 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43086 }
43087
ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43088 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43089 {
43090 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43091 }
43092
ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43093 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43094 {
43095 USE_OPLINE
43096 zval *property, *container, *result;
43097
43098 SAVE_OPLINE();
43099
43100 container = EX_VAR(opline->op1.var);
43101 property = RT_CONSTANT(opline, opline->op2);
43102 result = EX_VAR(opline->result.var);
43103 zend_fetch_property_address(
43104 result, container, IS_CV, property, IS_CONST,
43105 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
43106 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
43107
43108 if (IS_CV == IS_VAR) {
43109 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43110 }
43111 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43112 }
43113
ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43114 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43115 {
43116 USE_OPLINE
43117 zval *property, *container, *result;
43118
43119 SAVE_OPLINE();
43120 container = EX_VAR(opline->op1.var);
43121 property = RT_CONSTANT(opline, opline->op2);
43122 result = EX_VAR(opline->result.var);
43123 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);
43124
43125 if (IS_CV == IS_VAR) {
43126 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43127 }
43128 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43129 }
43130
ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43131 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43132 {
43133 USE_OPLINE
43134 zval *container;
43135 void **cache_slot = NULL;
43136
43137 SAVE_OPLINE();
43138 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
43139
43140 if (IS_CV == IS_CONST ||
43141 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
43142 do {
43143 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
43144 container = Z_REFVAL_P(container);
43145 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
43146 break;
43147 }
43148 }
43149 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
43150 ZVAL_UNDEFINED_OP2();
43151 }
43152 ZVAL_NULL(EX_VAR(opline->result.var));
43153 goto fetch_obj_is_finish;
43154 } while (0);
43155 }
43156
43157 /* here we are sure we are dealing with an object */
43158 do {
43159 zend_object *zobj = Z_OBJ_P(container);
43160 zend_string *name, *tmp_name;
43161 zval *retval;
43162
43163 if (IS_CONST == IS_CONST) {
43164 cache_slot = CACHE_ADDR(opline->extended_value);
43165
43166 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
43167 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43168
43169 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43170 fetch_obj_is_simple:
43171 retval = OBJ_PROP(zobj, prop_offset);
43172 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
43173 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43174 goto fetch_obj_is_copy;
43175 } else {
43176 fetch_obj_is_fast_copy:
43177 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43178 ZEND_VM_NEXT_OPCODE();
43179 }
43180 }
43181 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
43182 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
43183 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
43184 prop_offset = prop_info->offset;
43185 goto fetch_obj_is_simple;
43186 }
43187 /* Fall through to read_property for hooks. */
43188 } else if (EXPECTED(zobj->properties != NULL)) {
43189 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
43190 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43191 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
43192 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
43193
43194 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
43195 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
43196
43197 if (EXPECTED(p->key == name) ||
43198 (EXPECTED(p->h == ZSTR_H(name)) &&
43199 EXPECTED(p->key != NULL) &&
43200 EXPECTED(zend_string_equal_content(p->key, name)))) {
43201 retval = &p->val;
43202 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43203 goto fetch_obj_is_copy;
43204 } else {
43205 goto fetch_obj_is_fast_copy;
43206 }
43207 }
43208 }
43209 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
43210 }
43211 retval = zend_hash_find_known_hash(zobj->properties, name);
43212 if (EXPECTED(retval)) {
43213 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
43214 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
43215 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
43216 goto fetch_obj_is_copy;
43217 } else {
43218 goto fetch_obj_is_fast_copy;
43219 }
43220 }
43221 }
43222 }
43223 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43224 } else {
43225 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43226 if (UNEXPECTED(!name)) {
43227 ZVAL_UNDEF(EX_VAR(opline->result.var));
43228 break;
43229 }
43230 }
43231
43232 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
43233
43234 if (IS_CONST != IS_CONST) {
43235 zend_tmp_string_release(tmp_name);
43236 }
43237
43238 if (retval != EX_VAR(opline->result.var)) {
43239 fetch_obj_is_copy:
43240 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
43241 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
43242 zend_unwrap_reference(retval);
43243 }
43244 } while (0);
43245
43246 fetch_obj_is_finish:
43247
43248
43249 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43250 }
43251
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43252 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43253 {
43254 #if 0
43255 USE_OPLINE
43256 #endif
43257
43258 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
43259 /* Behave like FETCH_OBJ_W */
43260 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
43261 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43262 }
43263 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43264 } else {
43265 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43266 }
43267 }
43268
ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43269 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43270 {
43271 USE_OPLINE
43272 zval *container, *property, *result;
43273
43274 SAVE_OPLINE();
43275 container = EX_VAR(opline->op1.var);
43276 property = RT_CONSTANT(opline, opline->op2);
43277 result = EX_VAR(opline->result.var);
43278 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);
43279
43280 if (IS_CV == IS_VAR) {
43281 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
43282 }
43283 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43284 }
43285
ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43286 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43287 {
43288 USE_OPLINE
43289 zval *object, *value, tmp;
43290 zend_object *zobj;
43291 zend_string *name, *tmp_name;
43292 zend_refcounted *garbage = NULL;
43293
43294 SAVE_OPLINE();
43295 object = EX_VAR(opline->op1.var);
43296 value = RT_CONSTANT((opline+1), (opline+1)->op1);
43297
43298 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43299 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43300 object = Z_REFVAL_P(object);
43301 goto assign_object;
43302 }
43303 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43304 value = &EG(uninitialized_zval);
43305 goto free_and_exit_assign_obj;
43306 }
43307
43308 assign_object:
43309 zobj = Z_OBJ_P(object);
43310 if (IS_CONST == IS_CONST) {
43311 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43312 void **cache_slot = CACHE_ADDR(opline->extended_value);
43313 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43314 zval *property_val;
43315
43316 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43317 property_val = OBJ_PROP(zobj, prop_offset);
43318 if (Z_TYPE_P(property_val) != IS_UNDEF) {
43319 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43320
43321 if (prop_info != NULL) {
43322 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43323 goto free_and_exit_assign_obj;
43324 } else {
43325 fast_assign_obj:
43326 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
43327 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43328 ZVAL_COPY(EX_VAR(opline->result.var), value);
43329 }
43330 goto exit_assign_obj;
43331 }
43332 }
43333 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43334 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43335 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43336 zobj = zend_lazy_object_init(zobj);
43337 if (!zobj) {
43338 value = &EG(uninitialized_zval);
43339 goto free_and_exit_assign_obj;
43340 }
43341 }
43342 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43343 rebuild_object_properties_internal(zobj);
43344 }
43345 if (EXPECTED(zobj->properties != NULL)) {
43346 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43347 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43348 GC_DELREF(zobj->properties);
43349 }
43350 zobj->properties = zend_array_dup(zobj->properties);
43351 }
43352 property_val = zend_hash_find_known_hash(zobj->properties, name);
43353 if (property_val) {
43354 goto fast_assign_obj;
43355 }
43356 }
43357
43358 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43359 if (IS_CONST == IS_CONST) {
43360 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43361 Z_ADDREF_P(value);
43362 }
43363 } else if (IS_CONST != IS_TMP_VAR) {
43364 if (Z_ISREF_P(value)) {
43365 if (IS_CONST == IS_VAR) {
43366 zend_reference *ref = Z_REF_P(value);
43367 if (GC_DELREF(ref) == 0) {
43368 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43369 efree_size(ref, sizeof(zend_reference));
43370 value = &tmp;
43371 } else {
43372 value = Z_REFVAL_P(value);
43373 Z_TRY_ADDREF_P(value);
43374 }
43375 } else {
43376 value = Z_REFVAL_P(value);
43377 Z_TRY_ADDREF_P(value);
43378 }
43379 } else if (IS_CONST == IS_CV) {
43380 Z_TRY_ADDREF_P(value);
43381 }
43382 }
43383 zend_hash_add_new(zobj->properties, name, value);
43384 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43385 ZVAL_COPY(EX_VAR(opline->result.var), value);
43386 }
43387 goto exit_assign_obj;
43388 }
43389 } else {
43390 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43391 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43392 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
43393 property_val = OBJ_PROP(zobj, prop_info->offset);
43394 if (ZEND_TYPE_IS_SET(prop_info->type)) {
43395 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43396 goto free_and_exit_assign_obj;
43397 } else {
43398 goto fast_assign_obj;
43399 }
43400 }
43401 /* Fall through to write_property for hooks. */
43402 }
43403 }
43404 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43405 } else {
43406 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43407 if (UNEXPECTED(!name)) {
43408
43409 UNDEF_RESULT();
43410 goto exit_assign_obj;
43411 }
43412 }
43413
43414 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
43415 ZVAL_DEREF(value);
43416 }
43417
43418 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43419
43420 if (IS_CONST != IS_CONST) {
43421 zend_tmp_string_release(tmp_name);
43422 }
43423
43424 free_and_exit_assign_obj:
43425 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43426 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43427 }
43428
43429 exit_assign_obj:
43430 if (garbage) {
43431 GC_DTOR_NO_REF(garbage);
43432 }
43433
43434
43435 /* assign_obj has two opcodes! */
43436 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43437 }
43438
43439 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43440 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43441 {
43442 USE_OPLINE
43443 zval *object, *value, tmp;
43444 zend_object *zobj;
43445 zend_string *name, *tmp_name;
43446 zend_refcounted *garbage = NULL;
43447
43448 SAVE_OPLINE();
43449 object = EX_VAR(opline->op1.var);
43450 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
43451
43452 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43453 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43454 object = Z_REFVAL_P(object);
43455 goto assign_object;
43456 }
43457 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43458 value = &EG(uninitialized_zval);
43459 goto free_and_exit_assign_obj;
43460 }
43461
43462 assign_object:
43463 zobj = Z_OBJ_P(object);
43464 if (IS_CONST == IS_CONST) {
43465 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43466 void **cache_slot = CACHE_ADDR(opline->extended_value);
43467 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43468 zval *property_val;
43469
43470 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43471 property_val = OBJ_PROP(zobj, prop_offset);
43472 if (Z_TYPE_P(property_val) != IS_UNDEF) {
43473 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43474
43475 if (prop_info != NULL) {
43476 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43477 goto free_and_exit_assign_obj;
43478 } else {
43479 fast_assign_obj:
43480 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
43481 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43482 ZVAL_COPY(EX_VAR(opline->result.var), value);
43483 }
43484 goto exit_assign_obj;
43485 }
43486 }
43487 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43488 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43489 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43490 zobj = zend_lazy_object_init(zobj);
43491 if (!zobj) {
43492 value = &EG(uninitialized_zval);
43493 goto free_and_exit_assign_obj;
43494 }
43495 }
43496 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43497 rebuild_object_properties_internal(zobj);
43498 }
43499 if (EXPECTED(zobj->properties != NULL)) {
43500 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43501 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43502 GC_DELREF(zobj->properties);
43503 }
43504 zobj->properties = zend_array_dup(zobj->properties);
43505 }
43506 property_val = zend_hash_find_known_hash(zobj->properties, name);
43507 if (property_val) {
43508 goto fast_assign_obj;
43509 }
43510 }
43511
43512 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43513 if (IS_TMP_VAR == IS_CONST) {
43514 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43515 Z_ADDREF_P(value);
43516 }
43517 } else if (IS_TMP_VAR != IS_TMP_VAR) {
43518 if (Z_ISREF_P(value)) {
43519 if (IS_TMP_VAR == IS_VAR) {
43520 zend_reference *ref = Z_REF_P(value);
43521 if (GC_DELREF(ref) == 0) {
43522 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43523 efree_size(ref, sizeof(zend_reference));
43524 value = &tmp;
43525 } else {
43526 value = Z_REFVAL_P(value);
43527 Z_TRY_ADDREF_P(value);
43528 }
43529 } else {
43530 value = Z_REFVAL_P(value);
43531 Z_TRY_ADDREF_P(value);
43532 }
43533 } else if (IS_TMP_VAR == IS_CV) {
43534 Z_TRY_ADDREF_P(value);
43535 }
43536 }
43537 zend_hash_add_new(zobj->properties, name, value);
43538 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43539 ZVAL_COPY(EX_VAR(opline->result.var), value);
43540 }
43541 goto exit_assign_obj;
43542 }
43543 } else {
43544 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43545 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43546 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
43547 property_val = OBJ_PROP(zobj, prop_info->offset);
43548 if (ZEND_TYPE_IS_SET(prop_info->type)) {
43549 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43550 goto free_and_exit_assign_obj;
43551 } else {
43552 goto fast_assign_obj;
43553 }
43554 }
43555 /* Fall through to write_property for hooks. */
43556 }
43557 }
43558 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43559 } else {
43560 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43561 if (UNEXPECTED(!name)) {
43562 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43563 UNDEF_RESULT();
43564 goto exit_assign_obj;
43565 }
43566 }
43567
43568 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
43569 ZVAL_DEREF(value);
43570 }
43571
43572 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43573
43574 if (IS_CONST != IS_CONST) {
43575 zend_tmp_string_release(tmp_name);
43576 }
43577
43578 free_and_exit_assign_obj:
43579 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43580 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43581 }
43582 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43583 exit_assign_obj:
43584 if (garbage) {
43585 GC_DTOR_NO_REF(garbage);
43586 }
43587
43588
43589 /* assign_obj has two opcodes! */
43590 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43591 }
43592
43593 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43594 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43595 {
43596 USE_OPLINE
43597 zval *object, *value, tmp;
43598 zend_object *zobj;
43599 zend_string *name, *tmp_name;
43600 zend_refcounted *garbage = NULL;
43601
43602 SAVE_OPLINE();
43603 object = EX_VAR(opline->op1.var);
43604 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43605
43606 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43607 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43608 object = Z_REFVAL_P(object);
43609 goto assign_object;
43610 }
43611 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43612 value = &EG(uninitialized_zval);
43613 goto free_and_exit_assign_obj;
43614 }
43615
43616 assign_object:
43617 zobj = Z_OBJ_P(object);
43618 if (IS_CONST == IS_CONST) {
43619 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43620 void **cache_slot = CACHE_ADDR(opline->extended_value);
43621 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43622 zval *property_val;
43623
43624 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43625 property_val = OBJ_PROP(zobj, prop_offset);
43626 if (Z_TYPE_P(property_val) != IS_UNDEF) {
43627 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43628
43629 if (prop_info != NULL) {
43630 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43631 goto free_and_exit_assign_obj;
43632 } else {
43633 fast_assign_obj:
43634 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
43635 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43636 ZVAL_COPY(EX_VAR(opline->result.var), value);
43637 }
43638 goto exit_assign_obj;
43639 }
43640 }
43641 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43642 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43643 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43644 zobj = zend_lazy_object_init(zobj);
43645 if (!zobj) {
43646 value = &EG(uninitialized_zval);
43647 goto free_and_exit_assign_obj;
43648 }
43649 }
43650 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43651 rebuild_object_properties_internal(zobj);
43652 }
43653 if (EXPECTED(zobj->properties != NULL)) {
43654 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43655 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43656 GC_DELREF(zobj->properties);
43657 }
43658 zobj->properties = zend_array_dup(zobj->properties);
43659 }
43660 property_val = zend_hash_find_known_hash(zobj->properties, name);
43661 if (property_val) {
43662 goto fast_assign_obj;
43663 }
43664 }
43665
43666 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43667 if (IS_VAR == IS_CONST) {
43668 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43669 Z_ADDREF_P(value);
43670 }
43671 } else if (IS_VAR != IS_TMP_VAR) {
43672 if (Z_ISREF_P(value)) {
43673 if (IS_VAR == IS_VAR) {
43674 zend_reference *ref = Z_REF_P(value);
43675 if (GC_DELREF(ref) == 0) {
43676 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43677 efree_size(ref, sizeof(zend_reference));
43678 value = &tmp;
43679 } else {
43680 value = Z_REFVAL_P(value);
43681 Z_TRY_ADDREF_P(value);
43682 }
43683 } else {
43684 value = Z_REFVAL_P(value);
43685 Z_TRY_ADDREF_P(value);
43686 }
43687 } else if (IS_VAR == IS_CV) {
43688 Z_TRY_ADDREF_P(value);
43689 }
43690 }
43691 zend_hash_add_new(zobj->properties, name, value);
43692 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43693 ZVAL_COPY(EX_VAR(opline->result.var), value);
43694 }
43695 goto exit_assign_obj;
43696 }
43697 } else {
43698 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43699 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43700 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
43701 property_val = OBJ_PROP(zobj, prop_info->offset);
43702 if (ZEND_TYPE_IS_SET(prop_info->type)) {
43703 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43704 goto free_and_exit_assign_obj;
43705 } else {
43706 goto fast_assign_obj;
43707 }
43708 }
43709 /* Fall through to write_property for hooks. */
43710 }
43711 }
43712 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43713 } else {
43714 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43715 if (UNEXPECTED(!name)) {
43716 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43717 UNDEF_RESULT();
43718 goto exit_assign_obj;
43719 }
43720 }
43721
43722 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
43723 ZVAL_DEREF(value);
43724 }
43725
43726 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43727
43728 if (IS_CONST != IS_CONST) {
43729 zend_tmp_string_release(tmp_name);
43730 }
43731
43732 free_and_exit_assign_obj:
43733 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43734 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43735 }
43736 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43737 exit_assign_obj:
43738 if (garbage) {
43739 GC_DTOR_NO_REF(garbage);
43740 }
43741
43742
43743 /* assign_obj has two opcodes! */
43744 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43745 }
43746
43747 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43748 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43749 {
43750 USE_OPLINE
43751 zval *object, *value, tmp;
43752 zend_object *zobj;
43753 zend_string *name, *tmp_name;
43754 zend_refcounted *garbage = NULL;
43755
43756 SAVE_OPLINE();
43757 object = EX_VAR(opline->op1.var);
43758 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
43759
43760 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
43761 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
43762 object = Z_REFVAL_P(object);
43763 goto assign_object;
43764 }
43765 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
43766 value = &EG(uninitialized_zval);
43767 goto free_and_exit_assign_obj;
43768 }
43769
43770 assign_object:
43771 zobj = Z_OBJ_P(object);
43772 if (IS_CONST == IS_CONST) {
43773 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
43774 void **cache_slot = CACHE_ADDR(opline->extended_value);
43775 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
43776 zval *property_val;
43777
43778 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
43779 property_val = OBJ_PROP(zobj, prop_offset);
43780 if (Z_TYPE_P(property_val) != IS_UNDEF) {
43781 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
43782
43783 if (prop_info != NULL) {
43784 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43785 goto free_and_exit_assign_obj;
43786 } else {
43787 fast_assign_obj:
43788 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
43789 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43790 ZVAL_COPY(EX_VAR(opline->result.var), value);
43791 }
43792 goto exit_assign_obj;
43793 }
43794 }
43795 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
43796 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43797 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
43798 zobj = zend_lazy_object_init(zobj);
43799 if (!zobj) {
43800 value = &EG(uninitialized_zval);
43801 goto free_and_exit_assign_obj;
43802 }
43803 }
43804 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43805 rebuild_object_properties_internal(zobj);
43806 }
43807 if (EXPECTED(zobj->properties != NULL)) {
43808 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
43809 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
43810 GC_DELREF(zobj->properties);
43811 }
43812 zobj->properties = zend_array_dup(zobj->properties);
43813 }
43814 property_val = zend_hash_find_known_hash(zobj->properties, name);
43815 if (property_val) {
43816 goto fast_assign_obj;
43817 }
43818 }
43819
43820 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
43821 if (IS_CV == IS_CONST) {
43822 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
43823 Z_ADDREF_P(value);
43824 }
43825 } else if (IS_CV != IS_TMP_VAR) {
43826 if (Z_ISREF_P(value)) {
43827 if (IS_CV == IS_VAR) {
43828 zend_reference *ref = Z_REF_P(value);
43829 if (GC_DELREF(ref) == 0) {
43830 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
43831 efree_size(ref, sizeof(zend_reference));
43832 value = &tmp;
43833 } else {
43834 value = Z_REFVAL_P(value);
43835 Z_TRY_ADDREF_P(value);
43836 }
43837 } else {
43838 value = Z_REFVAL_P(value);
43839 Z_TRY_ADDREF_P(value);
43840 }
43841 } else if (IS_CV == IS_CV) {
43842 Z_TRY_ADDREF_P(value);
43843 }
43844 }
43845 zend_hash_add_new(zobj->properties, name, value);
43846 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43847 ZVAL_COPY(EX_VAR(opline->result.var), value);
43848 }
43849 goto exit_assign_obj;
43850 }
43851 } else {
43852 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
43853 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
43854 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
43855 property_val = OBJ_PROP(zobj, prop_info->offset);
43856 if (ZEND_TYPE_IS_SET(prop_info->type)) {
43857 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
43858 goto free_and_exit_assign_obj;
43859 } else {
43860 goto fast_assign_obj;
43861 }
43862 }
43863 /* Fall through to write_property for hooks. */
43864 }
43865 }
43866 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43867 } else {
43868 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
43869 if (UNEXPECTED(!name)) {
43870
43871 UNDEF_RESULT();
43872 goto exit_assign_obj;
43873 }
43874 }
43875
43876 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
43877 ZVAL_DEREF(value);
43878 }
43879
43880 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
43881
43882 if (IS_CONST != IS_CONST) {
43883 zend_tmp_string_release(tmp_name);
43884 }
43885
43886 free_and_exit_assign_obj:
43887 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
43888 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
43889 }
43890
43891 exit_assign_obj:
43892 if (garbage) {
43893 GC_DTOR_NO_REF(garbage);
43894 }
43895
43896
43897 /* assign_obj has two opcodes! */
43898 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43899 }
43900
43901 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43902 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43903 {
43904 USE_OPLINE
43905 zval *object_ptr, *orig_object_ptr;
43906 zval *value;
43907 zval *variable_ptr;
43908 zval *dim;
43909 zend_refcounted *garbage = NULL;
43910
43911 SAVE_OPLINE();
43912 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
43913
43914 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
43915 try_assign_dim_array:
43916 SEPARATE_ARRAY(object_ptr);
43917 if (IS_CONST == IS_UNUSED) {
43918 value = RT_CONSTANT((opline+1), (opline+1)->op1);
43919 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
43920 HashTable *ht = Z_ARRVAL_P(object_ptr);
43921 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
43922 GC_ADDREF(ht);
43923 }
43924 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
43925 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
43926 zend_array_destroy(ht);
43927 goto assign_dim_error;
43928 }
43929 }
43930 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
43931 ZVAL_DEREF(value);
43932 }
43933 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
43934 if (UNEXPECTED(value == NULL)) {
43935 zend_cannot_add_element();
43936 goto assign_dim_error;
43937 } else if (IS_CONST == IS_CV) {
43938 if (Z_REFCOUNTED_P(value)) {
43939 Z_ADDREF_P(value);
43940 }
43941 } else if (IS_CONST == IS_VAR) {
43942 zval *free_op_data = EX_VAR((opline+1)->op1.var);
43943 if (Z_ISREF_P(free_op_data)) {
43944 if (Z_REFCOUNTED_P(value)) {
43945 Z_ADDREF_P(value);
43946 }
43947 zval_ptr_dtor_nogc(free_op_data);
43948 }
43949 } else if (IS_CONST == IS_CONST) {
43950 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
43951 Z_ADDREF_P(value);
43952 }
43953 }
43954 } else {
43955 dim = RT_CONSTANT(opline, opline->op2);
43956 if (IS_CONST == IS_CONST) {
43957 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
43958 } else {
43959 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
43960 }
43961 if (UNEXPECTED(variable_ptr == NULL)) {
43962 goto assign_dim_error;
43963 }
43964 value = RT_CONSTANT((opline+1), (opline+1)->op1);
43965 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
43966 }
43967 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43968 ZVAL_COPY(EX_VAR(opline->result.var), value);
43969 }
43970 if (garbage) {
43971 GC_DTOR_NO_REF(garbage);
43972 }
43973 } else {
43974 if (EXPECTED(Z_ISREF_P(object_ptr))) {
43975 object_ptr = Z_REFVAL_P(object_ptr);
43976 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
43977 goto try_assign_dim_array;
43978 }
43979 }
43980 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
43981 zend_object *obj = Z_OBJ_P(object_ptr);
43982
43983 GC_ADDREF(obj);
43984 dim = RT_CONSTANT(opline, opline->op2);
43985 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
43986 dim = ZVAL_UNDEFINED_OP2();
43987 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
43988 dim++;
43989 }
43990
43991 value = RT_CONSTANT((opline+1), (opline+1)->op1);
43992 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
43993 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
43994 } else if (IS_CONST & (IS_CV|IS_VAR)) {
43995 ZVAL_DEREF(value);
43996 }
43997
43998 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
43999
44000 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44001 zend_objects_store_del(obj);
44002 }
44003 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44004 if (IS_CONST == IS_UNUSED) {
44005 zend_use_new_element_for_string();
44006
44007 UNDEF_RESULT();
44008 } else {
44009 dim = RT_CONSTANT(opline, opline->op2);
44010 value = RT_CONSTANT((opline+1), (opline+1)->op1);
44011 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44012
44013 }
44014 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44015 if (Z_ISREF_P(orig_object_ptr)
44016 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44017 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44018 dim = RT_CONSTANT(opline, opline->op2);
44019
44020 UNDEF_RESULT();
44021 } else {
44022 HashTable *ht = zend_new_array(8);
44023 uint8_t old_type = Z_TYPE_P(object_ptr);
44024
44025 ZVAL_ARR(object_ptr, ht);
44026 if (UNEXPECTED(old_type == IS_FALSE)) {
44027 GC_ADDREF(ht);
44028 zend_false_to_array_deprecated();
44029 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44030 zend_array_destroy(ht);
44031 goto assign_dim_error;
44032 }
44033 }
44034 goto try_assign_dim_array;
44035 }
44036 } else {
44037 zend_use_scalar_as_array();
44038 dim = RT_CONSTANT(opline, opline->op2);
44039 assign_dim_error:
44040
44041 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44042 ZVAL_NULL(EX_VAR(opline->result.var));
44043 }
44044 }
44045 }
44046 if (IS_CONST != IS_UNUSED) {
44047
44048 }
44049
44050 /* assign_dim has two opcodes! */
44051 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44052 }
44053
ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44054 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44055 {
44056 USE_OPLINE
44057 zval *object_ptr, *orig_object_ptr;
44058 zval *value;
44059 zval *variable_ptr;
44060 zval *dim;
44061 zend_refcounted *garbage = NULL;
44062
44063 SAVE_OPLINE();
44064 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44065
44066 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44067 try_assign_dim_array:
44068 SEPARATE_ARRAY(object_ptr);
44069 if (IS_CONST == IS_UNUSED) {
44070 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44071 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44072 HashTable *ht = Z_ARRVAL_P(object_ptr);
44073 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44074 GC_ADDREF(ht);
44075 }
44076 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44077 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44078 zend_array_destroy(ht);
44079 goto assign_dim_error;
44080 }
44081 }
44082 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
44083 ZVAL_DEREF(value);
44084 }
44085 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44086 if (UNEXPECTED(value == NULL)) {
44087 zend_cannot_add_element();
44088 goto assign_dim_error;
44089 } else if (IS_TMP_VAR == IS_CV) {
44090 if (Z_REFCOUNTED_P(value)) {
44091 Z_ADDREF_P(value);
44092 }
44093 } else if (IS_TMP_VAR == IS_VAR) {
44094 zval *free_op_data = EX_VAR((opline+1)->op1.var);
44095 if (Z_ISREF_P(free_op_data)) {
44096 if (Z_REFCOUNTED_P(value)) {
44097 Z_ADDREF_P(value);
44098 }
44099 zval_ptr_dtor_nogc(free_op_data);
44100 }
44101 } else if (IS_TMP_VAR == IS_CONST) {
44102 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44103 Z_ADDREF_P(value);
44104 }
44105 }
44106 } else {
44107 dim = RT_CONSTANT(opline, opline->op2);
44108 if (IS_CONST == IS_CONST) {
44109 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44110 } else {
44111 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44112 }
44113 if (UNEXPECTED(variable_ptr == NULL)) {
44114 goto assign_dim_error;
44115 }
44116 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44117 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
44118 }
44119 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44120 ZVAL_COPY(EX_VAR(opline->result.var), value);
44121 }
44122 if (garbage) {
44123 GC_DTOR_NO_REF(garbage);
44124 }
44125 } else {
44126 if (EXPECTED(Z_ISREF_P(object_ptr))) {
44127 object_ptr = Z_REFVAL_P(object_ptr);
44128 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44129 goto try_assign_dim_array;
44130 }
44131 }
44132 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44133 zend_object *obj = Z_OBJ_P(object_ptr);
44134
44135 GC_ADDREF(obj);
44136 dim = RT_CONSTANT(opline, opline->op2);
44137 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44138 dim = ZVAL_UNDEFINED_OP2();
44139 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44140 dim++;
44141 }
44142
44143 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44144 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44145 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44146 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
44147 ZVAL_DEREF(value);
44148 }
44149
44150 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44151
44152 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44153 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44154 zend_objects_store_del(obj);
44155 }
44156 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44157 if (IS_CONST == IS_UNUSED) {
44158 zend_use_new_element_for_string();
44159 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44160 UNDEF_RESULT();
44161 } else {
44162 dim = RT_CONSTANT(opline, opline->op2);
44163 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
44164 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44165 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44166 }
44167 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44168 if (Z_ISREF_P(orig_object_ptr)
44169 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44170 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44171 dim = RT_CONSTANT(opline, opline->op2);
44172 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44173 UNDEF_RESULT();
44174 } else {
44175 HashTable *ht = zend_new_array(8);
44176 uint8_t old_type = Z_TYPE_P(object_ptr);
44177
44178 ZVAL_ARR(object_ptr, ht);
44179 if (UNEXPECTED(old_type == IS_FALSE)) {
44180 GC_ADDREF(ht);
44181 zend_false_to_array_deprecated();
44182 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44183 zend_array_destroy(ht);
44184 goto assign_dim_error;
44185 }
44186 }
44187 goto try_assign_dim_array;
44188 }
44189 } else {
44190 zend_use_scalar_as_array();
44191 dim = RT_CONSTANT(opline, opline->op2);
44192 assign_dim_error:
44193 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44194 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44195 ZVAL_NULL(EX_VAR(opline->result.var));
44196 }
44197 }
44198 }
44199 if (IS_CONST != IS_UNUSED) {
44200
44201 }
44202
44203 /* assign_dim has two opcodes! */
44204 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44205 }
44206
ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44207 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44208 {
44209 USE_OPLINE
44210 zval *object_ptr, *orig_object_ptr;
44211 zval *value;
44212 zval *variable_ptr;
44213 zval *dim;
44214 zend_refcounted *garbage = NULL;
44215
44216 SAVE_OPLINE();
44217 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44218
44219 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44220 try_assign_dim_array:
44221 SEPARATE_ARRAY(object_ptr);
44222 if (IS_CONST == IS_UNUSED) {
44223 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44224 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44225 HashTable *ht = Z_ARRVAL_P(object_ptr);
44226 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44227 GC_ADDREF(ht);
44228 }
44229 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44230 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44231 zend_array_destroy(ht);
44232 goto assign_dim_error;
44233 }
44234 }
44235 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
44236 ZVAL_DEREF(value);
44237 }
44238 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44239 if (UNEXPECTED(value == NULL)) {
44240 zend_cannot_add_element();
44241 goto assign_dim_error;
44242 } else if (IS_VAR == IS_CV) {
44243 if (Z_REFCOUNTED_P(value)) {
44244 Z_ADDREF_P(value);
44245 }
44246 } else if (IS_VAR == IS_VAR) {
44247 zval *free_op_data = EX_VAR((opline+1)->op1.var);
44248 if (Z_ISREF_P(free_op_data)) {
44249 if (Z_REFCOUNTED_P(value)) {
44250 Z_ADDREF_P(value);
44251 }
44252 zval_ptr_dtor_nogc(free_op_data);
44253 }
44254 } else if (IS_VAR == IS_CONST) {
44255 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44256 Z_ADDREF_P(value);
44257 }
44258 }
44259 } else {
44260 dim = RT_CONSTANT(opline, opline->op2);
44261 if (IS_CONST == IS_CONST) {
44262 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44263 } else {
44264 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44265 }
44266 if (UNEXPECTED(variable_ptr == NULL)) {
44267 goto assign_dim_error;
44268 }
44269 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44270 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
44271 }
44272 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44273 ZVAL_COPY(EX_VAR(opline->result.var), value);
44274 }
44275 if (garbage) {
44276 GC_DTOR_NO_REF(garbage);
44277 }
44278 } else {
44279 if (EXPECTED(Z_ISREF_P(object_ptr))) {
44280 object_ptr = Z_REFVAL_P(object_ptr);
44281 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44282 goto try_assign_dim_array;
44283 }
44284 }
44285 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44286 zend_object *obj = Z_OBJ_P(object_ptr);
44287
44288 GC_ADDREF(obj);
44289 dim = RT_CONSTANT(opline, opline->op2);
44290 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44291 dim = ZVAL_UNDEFINED_OP2();
44292 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44293 dim++;
44294 }
44295
44296 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44297 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44298 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44299 } else if (IS_VAR & (IS_CV|IS_VAR)) {
44300 ZVAL_DEREF(value);
44301 }
44302
44303 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44304
44305 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44306 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44307 zend_objects_store_del(obj);
44308 }
44309 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44310 if (IS_CONST == IS_UNUSED) {
44311 zend_use_new_element_for_string();
44312 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44313 UNDEF_RESULT();
44314 } else {
44315 dim = RT_CONSTANT(opline, opline->op2);
44316 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44317 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44318 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44319 }
44320 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44321 if (Z_ISREF_P(orig_object_ptr)
44322 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44323 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44324 dim = RT_CONSTANT(opline, opline->op2);
44325 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44326 UNDEF_RESULT();
44327 } else {
44328 HashTable *ht = zend_new_array(8);
44329 uint8_t old_type = Z_TYPE_P(object_ptr);
44330
44331 ZVAL_ARR(object_ptr, ht);
44332 if (UNEXPECTED(old_type == IS_FALSE)) {
44333 GC_ADDREF(ht);
44334 zend_false_to_array_deprecated();
44335 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44336 zend_array_destroy(ht);
44337 goto assign_dim_error;
44338 }
44339 }
44340 goto try_assign_dim_array;
44341 }
44342 } else {
44343 zend_use_scalar_as_array();
44344 dim = RT_CONSTANT(opline, opline->op2);
44345 assign_dim_error:
44346 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44347 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44348 ZVAL_NULL(EX_VAR(opline->result.var));
44349 }
44350 }
44351 }
44352 if (IS_CONST != IS_UNUSED) {
44353
44354 }
44355
44356 /* assign_dim has two opcodes! */
44357 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44358 }
44359
ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44360 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44361 {
44362 USE_OPLINE
44363 zval *object_ptr, *orig_object_ptr;
44364 zval *value;
44365 zval *variable_ptr;
44366 zval *dim;
44367 zend_refcounted *garbage = NULL;
44368
44369 SAVE_OPLINE();
44370 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
44371
44372 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44373 try_assign_dim_array:
44374 SEPARATE_ARRAY(object_ptr);
44375 if (IS_CONST == IS_UNUSED) {
44376 value = EX_VAR((opline+1)->op1.var);
44377 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44378 HashTable *ht = Z_ARRVAL_P(object_ptr);
44379 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
44380 GC_ADDREF(ht);
44381 }
44382 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44383 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
44384 zend_array_destroy(ht);
44385 goto assign_dim_error;
44386 }
44387 }
44388 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
44389 ZVAL_DEREF(value);
44390 }
44391 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
44392 if (UNEXPECTED(value == NULL)) {
44393 zend_cannot_add_element();
44394 goto assign_dim_error;
44395 } else if (IS_CV == IS_CV) {
44396 if (Z_REFCOUNTED_P(value)) {
44397 Z_ADDREF_P(value);
44398 }
44399 } else if (IS_CV == IS_VAR) {
44400 zval *free_op_data = EX_VAR((opline+1)->op1.var);
44401 if (Z_ISREF_P(free_op_data)) {
44402 if (Z_REFCOUNTED_P(value)) {
44403 Z_ADDREF_P(value);
44404 }
44405 zval_ptr_dtor_nogc(free_op_data);
44406 }
44407 } else if (IS_CV == IS_CONST) {
44408 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
44409 Z_ADDREF_P(value);
44410 }
44411 }
44412 } else {
44413 dim = RT_CONSTANT(opline, opline->op2);
44414 if (IS_CONST == IS_CONST) {
44415 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44416 } else {
44417 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
44418 }
44419 if (UNEXPECTED(variable_ptr == NULL)) {
44420 goto assign_dim_error;
44421 }
44422 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
44423 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
44424 }
44425 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44426 ZVAL_COPY(EX_VAR(opline->result.var), value);
44427 }
44428 if (garbage) {
44429 GC_DTOR_NO_REF(garbage);
44430 }
44431 } else {
44432 if (EXPECTED(Z_ISREF_P(object_ptr))) {
44433 object_ptr = Z_REFVAL_P(object_ptr);
44434 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
44435 goto try_assign_dim_array;
44436 }
44437 }
44438 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
44439 zend_object *obj = Z_OBJ_P(object_ptr);
44440
44441 GC_ADDREF(obj);
44442 dim = RT_CONSTANT(opline, opline->op2);
44443 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
44444 dim = ZVAL_UNDEFINED_OP2();
44445 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44446 dim++;
44447 }
44448
44449 value = EX_VAR((opline+1)->op1.var);
44450 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
44451 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
44452 } else if (IS_CV & (IS_CV|IS_VAR)) {
44453 ZVAL_DEREF(value);
44454 }
44455
44456 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
44457
44458 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
44459 zend_objects_store_del(obj);
44460 }
44461 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
44462 if (IS_CONST == IS_UNUSED) {
44463 zend_use_new_element_for_string();
44464
44465 UNDEF_RESULT();
44466 } else {
44467 dim = RT_CONSTANT(opline, opline->op2);
44468 value = EX_VAR((opline+1)->op1.var);
44469 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
44470
44471 }
44472 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
44473 if (Z_ISREF_P(orig_object_ptr)
44474 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
44475 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
44476 dim = RT_CONSTANT(opline, opline->op2);
44477
44478 UNDEF_RESULT();
44479 } else {
44480 HashTable *ht = zend_new_array(8);
44481 uint8_t old_type = Z_TYPE_P(object_ptr);
44482
44483 ZVAL_ARR(object_ptr, ht);
44484 if (UNEXPECTED(old_type == IS_FALSE)) {
44485 GC_ADDREF(ht);
44486 zend_false_to_array_deprecated();
44487 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
44488 zend_array_destroy(ht);
44489 goto assign_dim_error;
44490 }
44491 }
44492 goto try_assign_dim_array;
44493 }
44494 } else {
44495 zend_use_scalar_as_array();
44496 dim = RT_CONSTANT(opline, opline->op2);
44497 assign_dim_error:
44498
44499 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
44500 ZVAL_NULL(EX_VAR(opline->result.var));
44501 }
44502 }
44503 }
44504 if (IS_CONST != IS_UNUSED) {
44505
44506 }
44507
44508 /* assign_dim has two opcodes! */
44509 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44510 }
44511
ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44512 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44513 {
44514 USE_OPLINE
44515 zval *value;
44516 zval *variable_ptr;
44517
44518 SAVE_OPLINE();
44519 value = RT_CONSTANT(opline, opline->op2);
44520 variable_ptr = EX_VAR(opline->op1.var);
44521
44522 if (0 || UNEXPECTED(0)) {
44523 zend_refcounted *garbage = NULL;
44524
44525 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
44526 if (UNEXPECTED(0)) {
44527 ZVAL_COPY(EX_VAR(opline->result.var), value);
44528 }
44529 if (garbage) {
44530 GC_DTOR_NO_REF(garbage);
44531 }
44532 } else {
44533 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
44534 }
44535
44536 /* zend_assign_to_variable() always takes care of op2, never free it! */
44537
44538 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44539 }
44540
ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44541 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44542 {
44543 USE_OPLINE
44544 zval *value;
44545 zval *variable_ptr;
44546
44547 SAVE_OPLINE();
44548 value = RT_CONSTANT(opline, opline->op2);
44549 variable_ptr = EX_VAR(opline->op1.var);
44550
44551 if (0 || UNEXPECTED(1)) {
44552 zend_refcounted *garbage = NULL;
44553
44554 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
44555 if (UNEXPECTED(1)) {
44556 ZVAL_COPY(EX_VAR(opline->result.var), value);
44557 }
44558 if (garbage) {
44559 GC_DTOR_NO_REF(garbage);
44560 }
44561 } else {
44562 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
44563 }
44564
44565 /* zend_assign_to_variable() always takes care of op2, never free it! */
44566
44567 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44568 }
44569
ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44570 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44571 {
44572 USE_OPLINE
44573 zval *property, *container, *value_ptr;
44574
44575 SAVE_OPLINE();
44576
44577 container = EX_VAR(opline->op1.var);
44578 property = RT_CONSTANT(opline, opline->op2);
44579
44580 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
44581
44582 if (1) {
44583 if (IS_CV == IS_UNUSED) {
44584 if (IS_CONST == IS_CONST) {
44585 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44586 } else {
44587 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44588 }
44589 } else {
44590 if (IS_CONST == IS_CONST) {
44591 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44592 } else {
44593 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44594 }
44595 }
44596 } else {
44597 zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44598 }
44599
44600
44601 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
44602 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44603 }
44604
44605 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44606 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44607 {
44608 USE_OPLINE
44609 zval *property, *container, *value_ptr;
44610
44611 SAVE_OPLINE();
44612
44613 container = EX_VAR(opline->op1.var);
44614 property = RT_CONSTANT(opline, opline->op2);
44615
44616 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
44617
44618 if (1) {
44619 if (IS_CV == IS_UNUSED) {
44620 if (IS_CONST == IS_CONST) {
44621 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44622 } else {
44623 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44624 }
44625 } else {
44626 if (IS_CONST == IS_CONST) {
44627 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44628 } else {
44629 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44630 }
44631 }
44632 } else {
44633 zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
44634 }
44635
44636
44637
44638 ZEND_VM_NEXT_OPCODE_EX(1, 2);
44639 }
44640
44641 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44642 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44643 {
44644 USE_OPLINE
44645 zval *op1, *op2;
44646 zend_string *op1_str, *op2_str, *str;
44647
44648
44649 op1 = EX_VAR(opline->op1.var);
44650 op2 = RT_CONSTANT(opline, opline->op2);
44651 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
44652 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
44653 zend_string *op1_str = Z_STR_P(op1);
44654 zend_string *op2_str = Z_STR_P(op2);
44655 zend_string *str;
44656 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
44657
44658 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
44659 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
44660 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
44661 } else {
44662 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
44663 }
44664 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44665 zend_string_release_ex(op1_str, 0);
44666 }
44667 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
44668 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
44669 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
44670 } else {
44671 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
44672 }
44673 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44674 zend_string_release_ex(op2_str, 0);
44675 }
44676 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
44677 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
44678 size_t len = ZSTR_LEN(op1_str);
44679
44680 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
44681 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44682 GC_ADD_FLAGS(str, flags);
44683 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44684 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44685 zend_string_release_ex(op2_str, 0);
44686 }
44687 } else {
44688 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
44689 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
44690 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44691 GC_ADD_FLAGS(str, flags);
44692 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44693 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44694 zend_string_release_ex(op1_str, 0);
44695 }
44696 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
44697 zend_string_release_ex(op2_str, 0);
44698 }
44699 }
44700 ZEND_VM_NEXT_OPCODE();
44701 }
44702
44703 SAVE_OPLINE();
44704 if (IS_CV == IS_CONST) {
44705 op1_str = Z_STR_P(op1);
44706 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44707 op1_str = zend_string_copy(Z_STR_P(op1));
44708 } else {
44709 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
44710 ZVAL_UNDEFINED_OP1();
44711 }
44712 op1_str = zval_get_string_func(op1);
44713 }
44714 if (IS_CONST == IS_CONST) {
44715 op2_str = Z_STR_P(op2);
44716 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
44717 op2_str = zend_string_copy(Z_STR_P(op2));
44718 } else {
44719 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
44720 ZVAL_UNDEFINED_OP2();
44721 }
44722 op2_str = zval_get_string_func(op2);
44723 }
44724 do {
44725 if (IS_CV != IS_CONST) {
44726 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
44727 if (IS_CONST == IS_CONST) {
44728 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
44729 GC_ADDREF(op2_str);
44730 }
44731 }
44732 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
44733 zend_string_release_ex(op1_str, 0);
44734 break;
44735 }
44736 }
44737 if (IS_CONST != IS_CONST) {
44738 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
44739 if (IS_CV == IS_CONST) {
44740 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
44741 GC_ADDREF(op1_str);
44742 }
44743 }
44744 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
44745 zend_string_release_ex(op2_str, 0);
44746 break;
44747 }
44748 }
44749 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
44750 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
44751 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44752
44753 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
44754 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44755 if (IS_CV != IS_CONST) {
44756 zend_string_release_ex(op1_str, 0);
44757 }
44758 if (IS_CONST != IS_CONST) {
44759 zend_string_release_ex(op2_str, 0);
44760 }
44761 } while (0);
44762
44763
44764 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44765 }
44766
ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44767 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44768 {
44769 USE_OPLINE
44770 zval *function_name;
44771 zval *object;
44772 zend_function *fbc;
44773 zend_class_entry *called_scope;
44774 zend_object *obj;
44775 zend_execute_data *call;
44776 uint32_t call_info;
44777
44778 SAVE_OPLINE();
44779
44780 object = EX_VAR(opline->op1.var);
44781
44782 if (IS_CONST != IS_CONST) {
44783 function_name = RT_CONSTANT(opline, opline->op2);
44784 }
44785
44786 if (IS_CONST != IS_CONST &&
44787 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
44788 do {
44789 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
44790 function_name = Z_REFVAL_P(function_name);
44791 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
44792 break;
44793 }
44794 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
44795 ZVAL_UNDEFINED_OP2();
44796 if (UNEXPECTED(EG(exception) != NULL)) {
44797
44798 HANDLE_EXCEPTION();
44799 }
44800 }
44801 zend_throw_error(NULL, "Method name must be a string");
44802
44803
44804 HANDLE_EXCEPTION();
44805 } while (0);
44806 }
44807
44808 if (IS_CV == IS_UNUSED) {
44809 obj = Z_OBJ_P(object);
44810 } else {
44811 do {
44812 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
44813 obj = Z_OBJ_P(object);
44814 } else {
44815 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
44816 zend_reference *ref = Z_REF_P(object);
44817
44818 object = &ref->val;
44819 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
44820 obj = Z_OBJ_P(object);
44821 if (IS_CV & IS_VAR) {
44822 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
44823 efree_size(ref, sizeof(zend_reference));
44824 } else {
44825 Z_ADDREF_P(object);
44826 }
44827 }
44828 break;
44829 }
44830 }
44831 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
44832 object = ZVAL_UNDEFINED_OP1();
44833 if (UNEXPECTED(EG(exception) != NULL)) {
44834 if (IS_CONST != IS_CONST) {
44835
44836 }
44837 HANDLE_EXCEPTION();
44838 }
44839 }
44840 if (IS_CONST == IS_CONST) {
44841 function_name = RT_CONSTANT(opline, opline->op2);
44842 }
44843 zend_invalid_method_call(object, function_name);
44844
44845
44846 HANDLE_EXCEPTION();
44847 }
44848 } while (0);
44849 }
44850
44851 called_scope = obj->ce;
44852
44853 if (IS_CONST == IS_CONST &&
44854 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
44855 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
44856 } else {
44857 zend_object *orig_obj = obj;
44858
44859 if (IS_CONST == IS_CONST) {
44860 function_name = RT_CONSTANT(opline, opline->op2);
44861 }
44862
44863 /* First, locate the function. */
44864 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
44865 if (UNEXPECTED(fbc == NULL)) {
44866 if (EXPECTED(!EG(exception))) {
44867 zend_undefined_method(obj->ce, Z_STR_P(function_name));
44868 }
44869
44870 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
44871 zend_objects_store_del(orig_obj);
44872 }
44873 HANDLE_EXCEPTION();
44874 }
44875 if (IS_CONST == IS_CONST &&
44876 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
44877 EXPECTED(obj == orig_obj)) {
44878 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
44879 }
44880 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
44881 GC_ADDREF(obj); /* For $this pointer */
44882 if (GC_DELREF(orig_obj) == 0) {
44883 zend_objects_store_del(orig_obj);
44884 }
44885 }
44886 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
44887 init_func_run_time_cache(&fbc->op_array);
44888 }
44889 }
44890
44891 if (IS_CONST != IS_CONST) {
44892
44893 }
44894
44895 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
44896 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
44897 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
44898 zend_objects_store_del(obj);
44899 if (UNEXPECTED(EG(exception))) {
44900 HANDLE_EXCEPTION();
44901 }
44902 }
44903 /* call static method */
44904 obj = (zend_object*)called_scope;
44905 call_info = ZEND_CALL_NESTED_FUNCTION;
44906 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
44907 if (IS_CV == IS_CV) {
44908 GC_ADDREF(obj); /* For $this pointer */
44909 }
44910 /* CV may be changed indirectly (e.g. when it's a reference) */
44911 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
44912 }
44913
44914 call = zend_vm_stack_push_call_frame(call_info,
44915 fbc, opline->extended_value, obj);
44916 call->prev_execute_data = EX(call);
44917 EX(call) = call;
44918
44919 ZEND_VM_NEXT_OPCODE();
44920 }
44921
ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44922 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44923 {
44924 USE_OPLINE
44925 zval *varptr, *arg;
44926
44927 if (IS_CONST == IS_CONST) {
44928 SAVE_OPLINE();
44929 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
44930 uint32_t arg_num;
44931 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
44932 if (UNEXPECTED(!arg)) {
44933
44934 HANDLE_EXCEPTION();
44935 }
44936 } else {
44937 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
44938 }
44939
44940 varptr = EX_VAR(opline->op1.var);
44941 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
44942 SAVE_OPLINE();
44943 ZVAL_UNDEFINED_OP1();
44944 ZVAL_NULL(arg);
44945 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44946 }
44947
44948 if (IS_CV == IS_CV) {
44949 ZVAL_COPY_DEREF(arg, varptr);
44950 } else /* if (IS_CV == IS_VAR) */ {
44951 if (UNEXPECTED(Z_ISREF_P(varptr))) {
44952 zend_refcounted *ref = Z_COUNTED_P(varptr);
44953
44954 varptr = Z_REFVAL_P(varptr);
44955 ZVAL_COPY_VALUE(arg, varptr);
44956 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
44957 efree_size(ref, sizeof(zend_reference));
44958 } else if (Z_OPT_REFCOUNTED_P(arg)) {
44959 Z_ADDREF_P(arg);
44960 }
44961 } else {
44962 ZVAL_COPY_VALUE(arg, varptr);
44963 }
44964 }
44965
44966 ZEND_VM_NEXT_OPCODE();
44967 }
44968
ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44969 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44970 {
44971 USE_OPLINE
44972 zval *varptr, *arg;
44973
44974 SAVE_OPLINE();
44975 if (IS_CONST == IS_CONST) {
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 = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
44988 if (Z_ISREF_P(varptr)) {
44989 Z_ADDREF_P(varptr);
44990 } else {
44991 ZVAL_MAKE_REF_EX(varptr, 2);
44992 }
44993 ZVAL_REF(arg, Z_REF_P(varptr));
44994
44995 ZEND_VM_NEXT_OPCODE();
44996 }
44997
ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44998 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44999 {
45000 USE_OPLINE
45001 zval *varptr, *arg;
45002 uint32_t arg_num;
45003
45004 if (IS_CONST == IS_CONST) {
45005 SAVE_OPLINE();
45006 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45007 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
45008 if (UNEXPECTED(!arg)) {
45009
45010 HANDLE_EXCEPTION();
45011 }
45012 } else {
45013 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
45014 arg_num = opline->op2.num;
45015 }
45016
45017 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
45018 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
45019 goto send_var_by_ref;
45020 }
45021 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
45022 send_var_by_ref:
45023 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45024 if (Z_ISREF_P(varptr)) {
45025 Z_ADDREF_P(varptr);
45026 } else {
45027 ZVAL_MAKE_REF_EX(varptr, 2);
45028 }
45029 ZVAL_REF(arg, Z_REF_P(varptr));
45030
45031 ZEND_VM_NEXT_OPCODE();
45032 }
45033
45034 varptr = EX_VAR(opline->op1.var);
45035 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
45036 SAVE_OPLINE();
45037 ZVAL_UNDEFINED_OP1();
45038 ZVAL_NULL(arg);
45039 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45040 }
45041
45042 if (IS_CV == IS_CV) {
45043 ZVAL_COPY_DEREF(arg, varptr);
45044 } else /* if (IS_CV == IS_VAR) */ {
45045 if (UNEXPECTED(Z_ISREF_P(varptr))) {
45046 zend_refcounted *ref = Z_COUNTED_P(varptr);
45047
45048 varptr = Z_REFVAL_P(varptr);
45049 ZVAL_COPY_VALUE(arg, varptr);
45050 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
45051 efree_size(ref, sizeof(zend_reference));
45052 } else if (Z_OPT_REFCOUNTED_P(arg)) {
45053 Z_ADDREF_P(arg);
45054 }
45055 } else {
45056 ZVAL_COPY_VALUE(arg, varptr);
45057 }
45058 }
45059
45060 ZEND_VM_NEXT_OPCODE();
45061 }
45062
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45063 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45064 {
45065 USE_OPLINE
45066 zval *expr_ptr, new_expr;
45067
45068 SAVE_OPLINE();
45069 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
45070 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
45071 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45072 if (Z_ISREF_P(expr_ptr)) {
45073 Z_ADDREF_P(expr_ptr);
45074 } else {
45075 ZVAL_MAKE_REF_EX(expr_ptr, 2);
45076 }
45077
45078 } else {
45079 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45080 if (IS_CV == IS_TMP_VAR) {
45081 /* pass */
45082 } else if (IS_CV == IS_CONST) {
45083 Z_TRY_ADDREF_P(expr_ptr);
45084 } else if (IS_CV == IS_CV) {
45085 ZVAL_DEREF(expr_ptr);
45086 Z_TRY_ADDREF_P(expr_ptr);
45087 } else /* if (IS_CV == IS_VAR) */ {
45088 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
45089 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
45090
45091 expr_ptr = Z_REFVAL_P(expr_ptr);
45092 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
45093 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
45094 expr_ptr = &new_expr;
45095 efree_size(ref, sizeof(zend_reference));
45096 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
45097 Z_ADDREF_P(expr_ptr);
45098 }
45099 }
45100 }
45101 }
45102
45103 if (IS_CONST != IS_UNUSED) {
45104 zval *offset = RT_CONSTANT(opline, opline->op2);
45105 zend_string *str;
45106 zend_ulong hval;
45107
45108 add_again:
45109 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45110 str = Z_STR_P(offset);
45111 if (IS_CONST != IS_CONST) {
45112 if (ZEND_HANDLE_NUMERIC(str, hval)) {
45113 goto num_index;
45114 }
45115 }
45116 str_index:
45117 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
45118 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45119 hval = Z_LVAL_P(offset);
45120 num_index:
45121 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
45122 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
45123 offset = Z_REFVAL_P(offset);
45124 goto add_again;
45125 } else if (Z_TYPE_P(offset) == IS_NULL) {
45126 str = ZSTR_EMPTY_ALLOC();
45127 goto str_index;
45128 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
45129 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
45130 goto num_index;
45131 } else if (Z_TYPE_P(offset) == IS_FALSE) {
45132 hval = 0;
45133 goto num_index;
45134 } else if (Z_TYPE_P(offset) == IS_TRUE) {
45135 hval = 1;
45136 goto num_index;
45137 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
45138 zend_use_resource_as_offset(offset);
45139 hval = Z_RES_HANDLE_P(offset);
45140 goto num_index;
45141 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
45142 ZVAL_UNDEFINED_OP2();
45143 str = ZSTR_EMPTY_ALLOC();
45144 goto str_index;
45145 } else {
45146 zend_illegal_array_offset_access(offset);
45147 zval_ptr_dtor_nogc(expr_ptr);
45148 }
45149
45150 } else {
45151 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
45152 zend_cannot_add_element();
45153 zval_ptr_dtor_nogc(expr_ptr);
45154 }
45155 }
45156 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45157 }
45158
ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45159 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45160 {
45161 zval *array;
45162 uint32_t size;
45163 USE_OPLINE
45164
45165 array = EX_VAR(opline->result.var);
45166 if (IS_CV != IS_UNUSED) {
45167 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
45168 ZVAL_ARR(array, zend_new_array(size));
45169 /* Explicitly initialize array as not-packed if flag is set */
45170 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
45171 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
45172 }
45173 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45174 } else {
45175 ZVAL_ARR(array, zend_new_array(0));
45176 ZEND_VM_NEXT_OPCODE();
45177 }
45178 }
45179
ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45180 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45181 {
45182 USE_OPLINE
45183 zval *container;
45184 zval *offset;
45185 zend_ulong hval;
45186 zend_string *key;
45187
45188 SAVE_OPLINE();
45189 container = EX_VAR(opline->op1.var);
45190 offset = RT_CONSTANT(opline, opline->op2);
45191
45192 do {
45193 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45194 HashTable *ht;
45195
45196 unset_dim_array:
45197 SEPARATE_ARRAY(container);
45198 ht = Z_ARRVAL_P(container);
45199 offset_again:
45200 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45201 key = Z_STR_P(offset);
45202 if (IS_CONST != IS_CONST) {
45203 if (ZEND_HANDLE_NUMERIC(key, hval)) {
45204 goto num_index_dim;
45205 }
45206 }
45207 str_index_dim:
45208 ZEND_ASSERT(ht != &EG(symbol_table));
45209 zend_hash_del(ht, key);
45210 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45211 hval = Z_LVAL_P(offset);
45212 num_index_dim:
45213 zend_hash_index_del(ht, hval);
45214 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
45215 offset = Z_REFVAL_P(offset);
45216 goto offset_again;
45217 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
45218 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
45219 goto num_index_dim;
45220 } else if (Z_TYPE_P(offset) == IS_NULL) {
45221 key = ZSTR_EMPTY_ALLOC();
45222 goto str_index_dim;
45223 } else if (Z_TYPE_P(offset) == IS_FALSE) {
45224 hval = 0;
45225 goto num_index_dim;
45226 } else if (Z_TYPE_P(offset) == IS_TRUE) {
45227 hval = 1;
45228 goto num_index_dim;
45229 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
45230 zend_use_resource_as_offset(offset);
45231 hval = Z_RES_HANDLE_P(offset);
45232 goto num_index_dim;
45233 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
45234 ZVAL_UNDEFINED_OP2();
45235 key = ZSTR_EMPTY_ALLOC();
45236 goto str_index_dim;
45237 } else {
45238 zend_illegal_array_offset_unset(offset);
45239 }
45240 break;
45241 } else if (Z_ISREF_P(container)) {
45242 container = Z_REFVAL_P(container);
45243 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45244 goto unset_dim_array;
45245 }
45246 }
45247 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
45248 container = ZVAL_UNDEFINED_OP1();
45249 }
45250 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
45251 offset = ZVAL_UNDEFINED_OP2();
45252 }
45253 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
45254 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
45255 offset++;
45256 }
45257 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
45258 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
45259 zend_throw_error(NULL, "Cannot unset string offsets");
45260 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
45261 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
45262 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
45263 zend_false_to_array_deprecated();
45264 }
45265 } while (0);
45266
45267
45268 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45269 }
45270
ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45271 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45272 {
45273 USE_OPLINE
45274 zval *container;
45275 zval *offset;
45276 zend_string *name, *tmp_name;
45277
45278 SAVE_OPLINE();
45279 container = EX_VAR(opline->op1.var);
45280 offset = RT_CONSTANT(opline, opline->op2);
45281
45282 do {
45283 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
45284 if (Z_ISREF_P(container)) {
45285 container = Z_REFVAL_P(container);
45286 if (Z_TYPE_P(container) != IS_OBJECT) {
45287 if (IS_CV == IS_CV
45288 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
45289 ZVAL_UNDEFINED_OP1();
45290 }
45291 break;
45292 }
45293 } else {
45294 break;
45295 }
45296 }
45297 if (IS_CONST == IS_CONST) {
45298 name = Z_STR_P(offset);
45299 } else {
45300 name = zval_try_get_tmp_string(offset, &tmp_name);
45301 if (UNEXPECTED(!name)) {
45302 break;
45303 }
45304 }
45305 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
45306 if (IS_CONST != IS_CONST) {
45307 zend_tmp_string_release(tmp_name);
45308 }
45309 } while (0);
45310
45311
45312 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45313 }
45314
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45315 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45316 {
45317 USE_OPLINE
45318 zval *container;
45319 bool result;
45320 zend_ulong hval;
45321 zval *offset;
45322
45323 SAVE_OPLINE();
45324 container = EX_VAR(opline->op1.var);
45325 offset = RT_CONSTANT(opline, opline->op2);
45326
45327 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45328 HashTable *ht;
45329 zval *value;
45330 zend_string *str;
45331
45332 isset_dim_obj_array:
45333 ht = Z_ARRVAL_P(container);
45334 isset_again:
45335 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
45336 str = Z_STR_P(offset);
45337 if (IS_CONST != IS_CONST) {
45338 if (ZEND_HANDLE_NUMERIC(str, hval)) {
45339 goto num_index_prop;
45340 }
45341 }
45342 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
45343 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
45344 hval = Z_LVAL_P(offset);
45345 num_index_prop:
45346 value = zend_hash_index_find(ht, hval);
45347 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
45348 offset = Z_REFVAL_P(offset);
45349 goto isset_again;
45350 } else {
45351 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
45352 if (UNEXPECTED(EG(exception))) {
45353 result = 0;
45354 goto isset_dim_obj_exit;
45355 }
45356 }
45357
45358 if (!(opline->extended_value & ZEND_ISEMPTY)) {
45359 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
45360 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
45361 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
45362
45363 if (IS_CV & (IS_CONST|IS_CV)) {
45364 /* avoid exception check */
45365
45366 ZEND_VM_SMART_BRANCH(result, 0);
45367 }
45368 } else {
45369 result = (value == NULL || !i_zend_is_true(value));
45370 }
45371 goto isset_dim_obj_exit;
45372 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
45373 container = Z_REFVAL_P(container);
45374 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45375 goto isset_dim_obj_array;
45376 }
45377 }
45378
45379 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
45380 offset++;
45381 }
45382 if (!(opline->extended_value & ZEND_ISEMPTY)) {
45383 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
45384 } else {
45385 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
45386 }
45387
45388 isset_dim_obj_exit:
45389
45390
45391 ZEND_VM_SMART_BRANCH(result, 1);
45392 }
45393
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45394 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45395 {
45396 USE_OPLINE
45397 zval *container;
45398 int result;
45399 zval *offset;
45400 zend_string *name, *tmp_name;
45401
45402 SAVE_OPLINE();
45403 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
45404 offset = RT_CONSTANT(opline, opline->op2);
45405
45406 if (IS_CV == IS_CONST ||
45407 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
45408 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
45409 container = Z_REFVAL_P(container);
45410 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
45411 result = (opline->extended_value & ZEND_ISEMPTY);
45412 goto isset_object_finish;
45413 }
45414 } else {
45415 result = (opline->extended_value & ZEND_ISEMPTY);
45416 goto isset_object_finish;
45417 }
45418 }
45419
45420 if (IS_CONST == IS_CONST) {
45421 name = Z_STR_P(offset);
45422 } else {
45423 name = zval_try_get_tmp_string(offset, &tmp_name);
45424 if (UNEXPECTED(!name)) {
45425 result = 0;
45426 goto isset_object_finish;
45427 }
45428 }
45429
45430 result =
45431 (opline->extended_value & ZEND_ISEMPTY) ^
45432 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));
45433
45434 if (IS_CONST != IS_CONST) {
45435 zend_tmp_string_release(tmp_name);
45436 }
45437
45438 isset_object_finish:
45439
45440
45441 ZEND_VM_SMART_BRANCH(result, 1);
45442 }
45443
ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45444 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45445 {
45446 USE_OPLINE
45447
45448 zval *key, *subject;
45449 HashTable *ht;
45450 bool result;
45451
45452 SAVE_OPLINE();
45453
45454 key = EX_VAR(opline->op1.var);
45455 subject = RT_CONSTANT(opline, opline->op2);
45456
45457 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
45458 array_key_exists_array:
45459 ht = Z_ARRVAL_P(subject);
45460 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
45461 } else {
45462 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
45463 subject = Z_REFVAL_P(subject);
45464 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
45465 goto array_key_exists_array;
45466 }
45467 }
45468 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
45469 result = 0;
45470 }
45471
45472
45473 ZEND_VM_SMART_BRANCH(result, 1);
45474 }
45475
ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45476 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45477 {
45478 USE_OPLINE
45479 zval *expr;
45480 bool result;
45481
45482 SAVE_OPLINE();
45483 expr = EX_VAR(opline->op1.var);
45484
45485 try_instanceof:
45486 if (Z_TYPE_P(expr) == IS_OBJECT) {
45487 zend_class_entry *ce;
45488
45489 if (IS_CONST == IS_CONST) {
45490 ce = CACHED_PTR(opline->extended_value);
45491 if (UNEXPECTED(ce == NULL)) {
45492 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);
45493 if (EXPECTED(ce)) {
45494 CACHE_PTR(opline->extended_value, ce);
45495 }
45496 }
45497 } else if (IS_CONST == IS_UNUSED) {
45498 ce = zend_fetch_class(NULL, opline->op2.num);
45499 if (UNEXPECTED(ce == NULL)) {
45500
45501 ZVAL_UNDEF(EX_VAR(opline->result.var));
45502 HANDLE_EXCEPTION();
45503 }
45504 } else {
45505 ce = Z_CE_P(EX_VAR(opline->op2.var));
45506 }
45507 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
45508 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
45509 expr = Z_REFVAL_P(expr);
45510 goto try_instanceof;
45511 } else {
45512 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
45513 ZVAL_UNDEFINED_OP1();
45514 }
45515 result = 0;
45516 }
45517
45518 ZEND_VM_SMART_BRANCH(result, 1);
45519 }
45520
ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45521 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45522 {
45523 USE_OPLINE
45524
45525 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
45526
45527 SAVE_OPLINE();
45528 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
45529 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45530 }
45531
45532 /* Destroy the previously yielded value */
45533 zval_ptr_dtor(&generator->value);
45534
45535 /* Destroy the previously yielded key */
45536 zval_ptr_dtor(&generator->key);
45537
45538 /* Set the new yielded value */
45539 if (IS_CV != IS_UNUSED) {
45540 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
45541 /* Constants and temporary variables aren't yieldable by reference,
45542 * but we still allow them with a notice. */
45543 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
45544 zval *value;
45545
45546 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
45547
45548 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45549 ZVAL_COPY_VALUE(&generator->value, value);
45550 if (IS_CV == IS_CONST) {
45551 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
45552 Z_ADDREF(generator->value);
45553 }
45554 }
45555 } else {
45556 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
45557
45558 /* If a function call result is yielded and the function did
45559 * not return by reference we throw a notice. */
45560 do {
45561 if (IS_CV == IS_VAR) {
45562 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
45563 if (opline->extended_value == ZEND_RETURNS_FUNCTION
45564 && !Z_ISREF_P(value_ptr)) {
45565 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
45566 ZVAL_COPY(&generator->value, value_ptr);
45567 break;
45568 }
45569 }
45570 if (Z_ISREF_P(value_ptr)) {
45571 Z_ADDREF_P(value_ptr);
45572 } else {
45573 ZVAL_MAKE_REF_EX(value_ptr, 2);
45574 }
45575 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
45576 } while (0);
45577
45578 }
45579 } else {
45580 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45581
45582 /* Consts, temporary variables and references need copying */
45583 if (IS_CV == IS_CONST) {
45584 ZVAL_COPY_VALUE(&generator->value, value);
45585 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
45586 Z_ADDREF(generator->value);
45587 }
45588 } else if (IS_CV == IS_TMP_VAR) {
45589 ZVAL_COPY_VALUE(&generator->value, value);
45590 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
45591 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
45592
45593 } else {
45594 ZVAL_COPY_VALUE(&generator->value, value);
45595 if (IS_CV == IS_CV) {
45596 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
45597 }
45598 }
45599 }
45600 } else {
45601 /* If no value was specified yield null */
45602 ZVAL_NULL(&generator->value);
45603 }
45604
45605 /* Set the new yielded key */
45606 if (IS_CONST != IS_UNUSED) {
45607 zval *key = RT_CONSTANT(opline, opline->op2);
45608 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
45609 key = Z_REFVAL_P(key);
45610 }
45611 ZVAL_COPY(&generator->key, key);
45612
45613 if (Z_TYPE(generator->key) == IS_LONG
45614 && Z_LVAL(generator->key) > generator->largest_used_integer_key
45615 ) {
45616 generator->largest_used_integer_key = Z_LVAL(generator->key);
45617 }
45618 } else {
45619 /* If no key was specified we use auto-increment keys */
45620 generator->largest_used_integer_key++;
45621 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
45622 }
45623
45624 if (RETURN_VALUE_USED(opline)) {
45625 /* If the return value of yield is used set the send
45626 * target and initialize it to NULL */
45627 generator->send_target = EX_VAR(opline->result.var);
45628 ZVAL_NULL(generator->send_target);
45629 } else {
45630 generator->send_target = NULL;
45631 }
45632
45633 /* The GOTO VM uses a local opline variable. We need to set the opline
45634 * variable in execute_data so we don't resume at an old position. */
45635 SAVE_OPLINE();
45636
45637 ZEND_VM_RETURN();
45638 }
45639
ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45640 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45641 {
45642 USE_OPLINE
45643 zend_string *varname;
45644 zval *value;
45645 zval *variable_ptr;
45646 uintptr_t idx;
45647 zend_reference *ref;
45648
45649 ZEND_VM_REPEATABLE_OPCODE
45650
45651 varname = Z_STR_P(RT_CONSTANT(opline, opline->op2));
45652
45653 /* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45654 idx = (uintptr_t)CACHED_PTR(opline->extended_value) - 1;
45655 if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket))) {
45656 Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
45657
45658 if (EXPECTED(p->key == varname) ||
45659 (EXPECTED(p->h == ZSTR_H(varname)) &&
45660 EXPECTED(p->key != NULL) &&
45661 EXPECTED(zend_string_equal_content(p->key, varname)))) {
45662
45663 value = (zval*)p; /* value = &p->val; */
45664 goto check_indirect;
45665 }
45666 }
45667
45668 value = zend_hash_find_known_hash(&EG(symbol_table), varname);
45669 if (UNEXPECTED(value == NULL)) {
45670 value = zend_hash_add_new(&EG(symbol_table), varname, &EG(uninitialized_zval));
45671 idx = (char*)value - (char*)EG(symbol_table).arData;
45672 /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45673 CACHE_PTR(opline->extended_value, (void*)(idx + 1));
45674 } else {
45675 idx = (char*)value - (char*)EG(symbol_table).arData;
45676 /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
45677 CACHE_PTR(opline->extended_value, (void*)(idx + 1));
45678 check_indirect:
45679 /* GLOBAL variable may be an INDIRECT pointer to CV */
45680 if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
45681 value = Z_INDIRECT_P(value);
45682 if (UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
45683 ZVAL_NULL(value);
45684 }
45685 }
45686 }
45687
45688 if (UNEXPECTED(!Z_ISREF_P(value))) {
45689 ZVAL_MAKE_REF_EX(value, 2);
45690 ref = Z_REF_P(value);
45691 } else {
45692 ref = Z_REF_P(value);
45693 GC_ADDREF(ref);
45694 }
45695
45696 variable_ptr = EX_VAR(opline->op1.var);
45697
45698 if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr))) {
45699 zend_refcounted *garbage = Z_COUNTED_P(variable_ptr);
45700
45701 ZVAL_REF(variable_ptr, ref);
45702 SAVE_OPLINE();
45703 if (GC_DELREF(garbage) == 0) {
45704 rc_dtor_func(garbage);
45705 if (UNEXPECTED(EG(exception))) {
45706 ZVAL_NULL(variable_ptr);
45707 HANDLE_EXCEPTION();
45708 }
45709 } else {
45710 gc_check_possible_root(garbage);
45711 }
45712 } else {
45713 ZVAL_REF(variable_ptr, ref);
45714 }
45715
45716 ZEND_VM_REPEAT_OPCODE(ZEND_BIND_GLOBAL);
45717 ZEND_VM_NEXT_OPCODE();
45718 }
45719
ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45720 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45721 {
45722 USE_OPLINE
45723 zval *op1;
45724 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
45725 zval *result;
45726
45727 op1 = EX_VAR(opline->op1.var);
45728 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45729 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CV == IS_CONST);
45730 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45731 zval_ptr_dtor_str(op1);
45732 }
45733 ZEND_VM_SMART_BRANCH(result, 0);
45734 }
45735
45736 if (opline->extended_value) {
45737 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45738 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
45739 ZEND_VM_SMART_BRANCH(result, 0);
45740 }
45741 SAVE_OPLINE();
45742 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
45743 op1 = Z_REFVAL_P(op1);
45744 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45745 result = zend_hash_find(ht, Z_STR_P(op1));
45746
45747 ZEND_VM_SMART_BRANCH(result, 0);
45748 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45749 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
45750
45751 ZEND_VM_SMART_BRANCH(result, 0);
45752 }
45753 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
45754 ZVAL_UNDEFINED_OP1();
45755 }
45756 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
45757 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
45758 SAVE_OPLINE();
45759 ZVAL_UNDEFINED_OP1();
45760 if (UNEXPECTED(EG(exception) != NULL)) {
45761 HANDLE_EXCEPTION();
45762 }
45763 }
45764 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
45765 ZEND_VM_SMART_BRANCH(result, 0);
45766 } else {
45767 zend_string *key;
45768 zval key_tmp;
45769
45770 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
45771 op1 = Z_REFVAL_P(op1);
45772 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45773 result = zend_hash_find(ht, Z_STR_P(op1));
45774
45775 ZEND_VM_SMART_BRANCH(result, 0);
45776 }
45777 }
45778
45779 SAVE_OPLINE();
45780 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
45781 ZVAL_STR(&key_tmp, key);
45782 if (zend_compare(op1, &key_tmp) == 0) {
45783
45784 ZEND_VM_SMART_BRANCH(1, 1);
45785 }
45786 } ZEND_HASH_FOREACH_END();
45787 }
45788
45789 ZEND_VM_SMART_BRANCH(0, 1);
45790 }
45791
ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45792 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45793 {
45794 /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
45795 /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
45796 /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
45797 USE_OPLINE
45798 zval *op1, *op2;
45799 bool result;
45800
45801 op1 = EX_VAR(opline->op1.var);
45802 op2 = RT_CONSTANT(opline, opline->op2);
45803 result = fast_is_identical_function(op1, op2);
45804 /* Free is a no-op for const/cv */
45805 ZEND_VM_SMART_BRANCH(result, 0);
45806 }
45807
ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45808 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45809 {
45810 USE_OPLINE
45811 zval *op1, *op2;
45812 bool result;
45813
45814 op1 = EX_VAR(opline->op1.var);
45815 op2 = RT_CONSTANT(opline, opline->op2);
45816 result = fast_is_identical_function(op1, op2);
45817 /* Free is a no-op for const/cv */
45818 ZEND_VM_SMART_BRANCH(!result, 0);
45819 }
45820
ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45821 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45822 {
45823 USE_OPLINE
45824 zval *container, *dim, *value;
45825 zend_long offset;
45826 HashTable *ht;
45827
45828 container = EX_VAR(opline->op1.var);
45829 dim = RT_CONSTANT(opline, opline->op2);
45830 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45831 fetch_dim_r_index_array:
45832 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
45833 offset = Z_LVAL_P(dim);
45834 } else {
45835 SAVE_OPLINE();
45836 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
45837
45838 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45839 }
45840 ht = Z_ARRVAL_P(container);
45841 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
45842 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
45843 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45844 SAVE_OPLINE();
45845
45846 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45847 } else {
45848 ZEND_VM_NEXT_OPCODE();
45849 }
45850 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
45851 container = Z_REFVAL_P(container);
45852 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45853 goto fetch_dim_r_index_array;
45854 } else {
45855 goto fetch_dim_r_index_slow;
45856 }
45857 } else {
45858 fetch_dim_r_index_slow:
45859 SAVE_OPLINE();
45860 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
45861 dim++;
45862 }
45863 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
45864
45865 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45866 }
45867
45868 fetch_dim_r_index_undef:
45869 ZVAL_NULL(EX_VAR(opline->result.var));
45870 SAVE_OPLINE();
45871 zend_undefined_offset(offset);
45872
45873 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45874 }
45875
ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45876 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45877 {
45878 USE_OPLINE
45879 zval *container, *dim, *value;
45880 zend_long offset;
45881 HashTable *ht;
45882
45883 container = EX_VAR(opline->op1.var);
45884 dim = EX_VAR(opline->op2.var);
45885 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45886 fetch_dim_r_index_array:
45887 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
45888 offset = Z_LVAL_P(dim);
45889 } else {
45890 SAVE_OPLINE();
45891 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
45892
45893 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45894 }
45895 ht = Z_ARRVAL_P(container);
45896 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
45897 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
45898 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45899 SAVE_OPLINE();
45900
45901 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45902 } else {
45903 ZEND_VM_NEXT_OPCODE();
45904 }
45905 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
45906 container = Z_REFVAL_P(container);
45907 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45908 goto fetch_dim_r_index_array;
45909 } else {
45910 goto fetch_dim_r_index_slow;
45911 }
45912 } else {
45913 fetch_dim_r_index_slow:
45914 SAVE_OPLINE();
45915 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
45916 dim++;
45917 }
45918 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
45919
45920 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45921 }
45922
45923 fetch_dim_r_index_undef:
45924 ZVAL_NULL(EX_VAR(opline->result.var));
45925 SAVE_OPLINE();
45926 zend_undefined_offset(offset);
45927
45928 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45929 }
45930
ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45931 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45932 {
45933 USE_OPLINE
45934 zval *op1, *op2;
45935
45936 SAVE_OPLINE();
45937 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45938 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45939 div_function(EX_VAR(opline->result.var), op1, op2);
45940
45941 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45942 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45943 }
45944
ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45945 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45946 {
45947 USE_OPLINE
45948 zval *op1, *op2;
45949
45950 SAVE_OPLINE();
45951 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45952 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45953 pow_function(EX_VAR(opline->result.var), op1, op2);
45954
45955 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45956 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45957 }
45958
ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45959 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45960 {
45961 USE_OPLINE
45962 zval *op1, *op2;
45963
45964 op1 = EX_VAR(opline->op1.var);
45965 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45966
45967 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
45968 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
45969 zend_string *op1_str = Z_STR_P(op1);
45970 zend_string *op2_str = Z_STR_P(op2);
45971 zend_string *str;
45972 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
45973
45974 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
45975 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
45976 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
45977 } else {
45978 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
45979 }
45980 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45981 zend_string_release_ex(op1_str, 0);
45982 }
45983 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
45984 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
45985 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
45986 } else {
45987 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
45988 }
45989 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
45990 zend_string_release_ex(op2_str, 0);
45991 }
45992 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
45993 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
45994 size_t len = ZSTR_LEN(op1_str);
45995
45996 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
45997 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
45998 }
45999 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
46000 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
46001 GC_ADD_FLAGS(str, flags);
46002 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
46003 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46004 zend_string_release_ex(op2_str, 0);
46005 }
46006 } else {
46007 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
46008 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
46009 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
46010 GC_ADD_FLAGS(str, flags);
46011 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
46012 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46013 zend_string_release_ex(op1_str, 0);
46014 }
46015 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46016 zend_string_release_ex(op2_str, 0);
46017 }
46018 }
46019 ZEND_VM_NEXT_OPCODE();
46020 } else {
46021 SAVE_OPLINE();
46022
46023 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
46024 op1 = ZVAL_UNDEFINED_OP1();
46025 }
46026 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
46027 op2 = ZVAL_UNDEFINED_OP2();
46028 }
46029 concat_function(EX_VAR(opline->result.var), op1, op2);
46030
46031 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46032 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46033 }
46034 }
46035
ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46036 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46037 {
46038 USE_OPLINE
46039 zval *op1, *op2;
46040 double d1, d2;
46041
46042 op1 = EX_VAR(opline->op1.var);
46043 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46044 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46045 /* pass */
46046 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46047 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46048 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46049 is_equal_true:
46050 ZEND_VM_SMART_BRANCH_TRUE_NONE();
46051 } else {
46052 is_equal_false:
46053 ZEND_VM_SMART_BRANCH_FALSE_NONE();
46054 }
46055 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46056 d1 = (double)Z_LVAL_P(op1);
46057 d2 = Z_DVAL_P(op2);
46058 goto is_equal_double;
46059 }
46060 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46061 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46062 d1 = Z_DVAL_P(op1);
46063 d2 = Z_DVAL_P(op2);
46064 is_equal_double:
46065 if (d1 == d2) {
46066 goto is_equal_true;
46067 } else {
46068 goto is_equal_false;
46069 }
46070 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46071 d1 = Z_DVAL_P(op1);
46072 d2 = (double)Z_LVAL_P(op2);
46073 goto is_equal_double;
46074 }
46075 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46076 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46077 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46078 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46079 zval_ptr_dtor_str(op1);
46080 }
46081 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46082 zval_ptr_dtor_str(op2);
46083 }
46084 if (result) {
46085 goto is_equal_true;
46086 } else {
46087 goto is_equal_false;
46088 }
46089 }
46090 }
46091 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46092 }
46093
ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46094 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46095 {
46096 USE_OPLINE
46097 zval *op1, *op2;
46098 double d1, d2;
46099
46100 op1 = EX_VAR(opline->op1.var);
46101 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46102 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46103 /* pass */
46104 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46105 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46106 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46107 is_equal_true:
46108 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
46109 } else {
46110 is_equal_false:
46111 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
46112 }
46113 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46114 d1 = (double)Z_LVAL_P(op1);
46115 d2 = Z_DVAL_P(op2);
46116 goto is_equal_double;
46117 }
46118 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46119 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46120 d1 = Z_DVAL_P(op1);
46121 d2 = Z_DVAL_P(op2);
46122 is_equal_double:
46123 if (d1 == d2) {
46124 goto is_equal_true;
46125 } else {
46126 goto is_equal_false;
46127 }
46128 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46129 d1 = Z_DVAL_P(op1);
46130 d2 = (double)Z_LVAL_P(op2);
46131 goto is_equal_double;
46132 }
46133 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46134 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46135 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46136 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46137 zval_ptr_dtor_str(op1);
46138 }
46139 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46140 zval_ptr_dtor_str(op2);
46141 }
46142 if (result) {
46143 goto is_equal_true;
46144 } else {
46145 goto is_equal_false;
46146 }
46147 }
46148 }
46149 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46150 }
46151
ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46152 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46153 {
46154 USE_OPLINE
46155 zval *op1, *op2;
46156 double d1, d2;
46157
46158 op1 = EX_VAR(opline->op1.var);
46159 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46160 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46161 /* pass */
46162 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46163 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46164 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
46165 is_equal_true:
46166 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
46167 } else {
46168 is_equal_false:
46169 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
46170 }
46171 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46172 d1 = (double)Z_LVAL_P(op1);
46173 d2 = Z_DVAL_P(op2);
46174 goto is_equal_double;
46175 }
46176 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46177 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46178 d1 = Z_DVAL_P(op1);
46179 d2 = Z_DVAL_P(op2);
46180 is_equal_double:
46181 if (d1 == d2) {
46182 goto is_equal_true;
46183 } else {
46184 goto is_equal_false;
46185 }
46186 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46187 d1 = Z_DVAL_P(op1);
46188 d2 = (double)Z_LVAL_P(op2);
46189 goto is_equal_double;
46190 }
46191 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46192 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46193 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46194 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46195 zval_ptr_dtor_str(op1);
46196 }
46197 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46198 zval_ptr_dtor_str(op2);
46199 }
46200 if (result) {
46201 goto is_equal_true;
46202 } else {
46203 goto is_equal_false;
46204 }
46205 }
46206 }
46207 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46208 }
46209
ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46210 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46211 {
46212 USE_OPLINE
46213 zval *op1, *op2;
46214 double d1, d2;
46215
46216 op1 = EX_VAR(opline->op1.var);
46217 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46218 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46219 /* pass */
46220 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46221 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46222 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46223 is_not_equal_true:
46224 ZEND_VM_SMART_BRANCH_TRUE_NONE();
46225 } else {
46226 is_not_equal_false:
46227 ZEND_VM_SMART_BRANCH_FALSE_NONE();
46228 }
46229 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46230 d1 = (double)Z_LVAL_P(op1);
46231 d2 = Z_DVAL_P(op2);
46232 goto is_not_equal_double;
46233 }
46234 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46235 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46236 d1 = Z_DVAL_P(op1);
46237 d2 = Z_DVAL_P(op2);
46238 is_not_equal_double:
46239 if (d1 != d2) {
46240 goto is_not_equal_true;
46241 } else {
46242 goto is_not_equal_false;
46243 }
46244 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46245 d1 = Z_DVAL_P(op1);
46246 d2 = (double)Z_LVAL_P(op2);
46247 goto is_not_equal_double;
46248 }
46249 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46250 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46251 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46252 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46253 zval_ptr_dtor_str(op1);
46254 }
46255 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46256 zval_ptr_dtor_str(op2);
46257 }
46258 if (!result) {
46259 goto is_not_equal_true;
46260 } else {
46261 goto is_not_equal_false;
46262 }
46263 }
46264 }
46265 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46266 }
46267
ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46268 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46269 {
46270 USE_OPLINE
46271 zval *op1, *op2;
46272 double d1, d2;
46273
46274 op1 = EX_VAR(opline->op1.var);
46275 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46276 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46277 /* pass */
46278 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46279 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46280 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46281 is_not_equal_true:
46282 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
46283 } else {
46284 is_not_equal_false:
46285 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
46286 }
46287 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46288 d1 = (double)Z_LVAL_P(op1);
46289 d2 = Z_DVAL_P(op2);
46290 goto is_not_equal_double;
46291 }
46292 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46293 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46294 d1 = Z_DVAL_P(op1);
46295 d2 = Z_DVAL_P(op2);
46296 is_not_equal_double:
46297 if (d1 != d2) {
46298 goto is_not_equal_true;
46299 } else {
46300 goto is_not_equal_false;
46301 }
46302 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46303 d1 = Z_DVAL_P(op1);
46304 d2 = (double)Z_LVAL_P(op2);
46305 goto is_not_equal_double;
46306 }
46307 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46308 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46309 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46310 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46311 zval_ptr_dtor_str(op1);
46312 }
46313 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46314 zval_ptr_dtor_str(op2);
46315 }
46316 if (!result) {
46317 goto is_not_equal_true;
46318 } else {
46319 goto is_not_equal_false;
46320 }
46321 }
46322 }
46323 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46324 }
46325
ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46326 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46327 {
46328 USE_OPLINE
46329 zval *op1, *op2;
46330 double d1, d2;
46331
46332 op1 = EX_VAR(opline->op1.var);
46333 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46334 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
46335 /* pass */
46336 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
46337 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46338 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
46339 is_not_equal_true:
46340 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
46341 } else {
46342 is_not_equal_false:
46343 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
46344 }
46345 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46346 d1 = (double)Z_LVAL_P(op1);
46347 d2 = Z_DVAL_P(op2);
46348 goto is_not_equal_double;
46349 }
46350 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
46351 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
46352 d1 = Z_DVAL_P(op1);
46353 d2 = Z_DVAL_P(op2);
46354 is_not_equal_double:
46355 if (d1 != d2) {
46356 goto is_not_equal_true;
46357 } else {
46358 goto is_not_equal_false;
46359 }
46360 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
46361 d1 = Z_DVAL_P(op1);
46362 d2 = (double)Z_LVAL_P(op2);
46363 goto is_not_equal_double;
46364 }
46365 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
46366 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
46367 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
46368 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
46369 zval_ptr_dtor_str(op1);
46370 }
46371 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
46372 zval_ptr_dtor_str(op2);
46373 }
46374 if (!result) {
46375 goto is_not_equal_true;
46376 } else {
46377 goto is_not_equal_false;
46378 }
46379 }
46380 }
46381 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
46382 }
46383
ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46384 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46385 {
46386 USE_OPLINE
46387 zval *op1, *op2;
46388
46389 SAVE_OPLINE();
46390 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46391 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46392 compare_function(EX_VAR(opline->result.var), op1, op2);
46393
46394 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46395 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46396 }
46397
ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46398 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46399 {
46400 USE_OPLINE
46401 zval *op1, *op2;
46402
46403 SAVE_OPLINE();
46404 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
46405 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46406 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
46407
46408 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46409 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46410 }
46411
ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46412 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46413 {
46414 USE_OPLINE
46415 zval *object;
46416 zval *property;
46417 zval *value;
46418 zval *zptr;
46419 void *_cache_slot[3] = {0};
46420 void **cache_slot;
46421 zend_property_info *prop_info;
46422 zend_object *zobj;
46423 zend_string *name, *tmp_name;
46424
46425 SAVE_OPLINE();
46426 object = EX_VAR(opline->op1.var);
46427 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46428
46429 do {
46430 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
46431
46432 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46433 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46434 object = Z_REFVAL_P(object);
46435 goto assign_op_object;
46436 }
46437 if (IS_CV == IS_CV
46438 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46439 ZVAL_UNDEFINED_OP1();
46440 }
46441 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46442 break;
46443 }
46444
46445 assign_op_object:
46446 /* here we are sure we are dealing with an object */
46447 zobj = Z_OBJ_P(object);
46448 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46449 name = Z_STR_P(property);
46450 } else {
46451 name = zval_try_get_tmp_string(property, &tmp_name);
46452 if (UNEXPECTED(!name)) {
46453 UNDEF_RESULT();
46454 break;
46455 }
46456 }
46457 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
46458 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46459 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46460 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46461 ZVAL_NULL(EX_VAR(opline->result.var));
46462 }
46463 } else {
46464 zend_reference *ref;
46465
46466 do {
46467 if (UNEXPECTED(Z_ISREF_P(zptr))) {
46468 ref = Z_REF_P(zptr);
46469 zptr = Z_REFVAL_P(zptr);
46470 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46471 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46472 break;
46473 }
46474 }
46475
46476 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
46477 if (prop_info) {
46478 /* special case for typed properties */
46479 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
46480 } else {
46481 zend_binary_op(zptr, zptr, value OPLINE_CC);
46482 }
46483 } while (0);
46484
46485 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46486 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
46487 }
46488 }
46489 } else {
46490 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
46491 }
46492 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46493 zend_tmp_string_release(tmp_name);
46494 }
46495 } while (0);
46496
46497 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46498 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46499
46500 /* assign_obj has two opcodes! */
46501 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46502 }
46503
46504 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46505 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46506 {
46507 USE_OPLINE
46508 zval *var_ptr;
46509 zval *value, *container, *dim;
46510 HashTable *ht;
46511
46512 SAVE_OPLINE();
46513 container = EX_VAR(opline->op1.var);
46514
46515 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46516 assign_dim_op_array:
46517 SEPARATE_ARRAY(container);
46518 ht = Z_ARRVAL_P(container);
46519 assign_dim_op_new_array:
46520 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46521 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46522 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
46523 if (UNEXPECTED(!var_ptr)) {
46524 zend_cannot_add_element();
46525 goto assign_dim_op_ret_null;
46526 }
46527 } else {
46528 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46529 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
46530 } else {
46531 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
46532 }
46533 if (UNEXPECTED(!var_ptr)) {
46534 goto assign_dim_op_ret_null;
46535 }
46536 }
46537
46538 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
46539
46540 do {
46541 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
46542 zend_reference *ref = Z_REF_P(var_ptr);
46543 var_ptr = Z_REFVAL_P(var_ptr);
46544 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46545 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46546 break;
46547 }
46548 }
46549 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
46550 } while (0);
46551
46552 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46553 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
46554 }
46555 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46556 } else {
46557 if (EXPECTED(Z_ISREF_P(container))) {
46558 container = Z_REFVAL_P(container);
46559 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46560 goto assign_dim_op_array;
46561 }
46562 }
46563
46564 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
46565 zend_object *obj = Z_OBJ_P(container);
46566
46567 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46568 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46569 dim++;
46570 }
46571 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
46572 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
46573 uint8_t old_type;
46574
46575 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
46576 ZVAL_UNDEFINED_OP1();
46577 }
46578 ht = zend_new_array(8);
46579 old_type = Z_TYPE_P(container);
46580 ZVAL_ARR(container, ht);
46581 if (UNEXPECTED(old_type == IS_FALSE)) {
46582 GC_ADDREF(ht);
46583 zend_false_to_array_deprecated();
46584 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
46585 zend_array_destroy(ht);
46586 goto assign_dim_op_ret_null;
46587 }
46588 }
46589 goto assign_dim_op_new_array;
46590 } else {
46591 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46592 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
46593 assign_dim_op_ret_null:
46594 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
46595 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46596 ZVAL_NULL(EX_VAR(opline->result.var));
46597 }
46598 }
46599 }
46600
46601 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46602
46603 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46604 }
46605
ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46606 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46607 {
46608 USE_OPLINE
46609 zval *var_ptr;
46610 zval *value;
46611
46612 SAVE_OPLINE();
46613 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46614 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
46615
46616 do {
46617 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
46618 zend_reference *ref = Z_REF_P(var_ptr);
46619 var_ptr = Z_REFVAL_P(var_ptr);
46620 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
46621 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
46622 break;
46623 }
46624 }
46625 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
46626 } while (0);
46627
46628 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46629 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
46630 }
46631
46632 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46633
46634 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46635 }
46636
ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46637 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46638 {
46639 USE_OPLINE
46640 zval *object;
46641 zval *property;
46642 zval *zptr;
46643 void *_cache_slot[3] = {0};
46644 void **cache_slot;
46645 zend_property_info *prop_info;
46646 zend_object *zobj;
46647 zend_string *name, *tmp_name;
46648
46649 SAVE_OPLINE();
46650 object = EX_VAR(opline->op1.var);
46651 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46652
46653 do {
46654 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46655 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46656 object = Z_REFVAL_P(object);
46657 goto pre_incdec_object;
46658 }
46659 if (IS_CV == IS_CV
46660 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46661 ZVAL_UNDEFINED_OP1();
46662 }
46663 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46664 break;
46665 }
46666
46667 pre_incdec_object:
46668 /* here we are sure we are dealing with an object */
46669 zobj = Z_OBJ_P(object);
46670 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46671 name = Z_STR_P(property);
46672 } else {
46673 name = zval_try_get_tmp_string(property, &tmp_name);
46674 if (UNEXPECTED(!name)) {
46675 UNDEF_RESULT();
46676 break;
46677 }
46678 }
46679 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
46680 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46681 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46682 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46683 ZVAL_NULL(EX_VAR(opline->result.var));
46684 }
46685 } else {
46686 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
46687 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
46688 }
46689 } else {
46690 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
46691 }
46692 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46693 zend_tmp_string_release(tmp_name);
46694 }
46695 } while (0);
46696
46697 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46698
46699 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46700 }
46701
ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46702 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46703 {
46704 USE_OPLINE
46705 zval *object;
46706 zval *property;
46707 zval *zptr;
46708 void *_cache_slot[3] = {0};
46709 void **cache_slot;
46710 zend_property_info *prop_info;
46711 zend_object *zobj;
46712 zend_string *name, *tmp_name;
46713
46714 SAVE_OPLINE();
46715 object = EX_VAR(opline->op1.var);
46716 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46717
46718 do {
46719 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46720 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46721 object = Z_REFVAL_P(object);
46722 goto post_incdec_object;
46723 }
46724 if (IS_CV == IS_CV
46725 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
46726 ZVAL_UNDEFINED_OP1();
46727 }
46728 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
46729 break;
46730 }
46731
46732 post_incdec_object:
46733 /* here we are sure we are dealing with an object */
46734 zobj = Z_OBJ_P(object);
46735 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46736 name = Z_STR_P(property);
46737 } else {
46738 name = zval_try_get_tmp_string(property, &tmp_name);
46739 if (UNEXPECTED(!name)) {
46740 ZVAL_UNDEF(EX_VAR(opline->result.var));
46741 break;
46742 }
46743 }
46744 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
46745 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
46746 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
46747 ZVAL_NULL(EX_VAR(opline->result.var));
46748 } else {
46749 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
46750 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
46751 }
46752 } else {
46753 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
46754 }
46755 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46756 zend_tmp_string_release(tmp_name);
46757 }
46758 } while (0);
46759
46760 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46761
46762 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46763 }
46764
ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46765 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46766 {
46767 USE_OPLINE
46768 zval *container, *dim, *value;
46769
46770 SAVE_OPLINE();
46771 container = EX_VAR(opline->op1.var);
46772 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46773 if (IS_CV != IS_CONST) {
46774 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46775 fetch_dim_r_array:
46776 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
46777 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46778 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
46779 container = Z_REFVAL_P(container);
46780 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
46781 goto fetch_dim_r_array;
46782 } else {
46783 goto fetch_dim_r_slow;
46784 }
46785 } else {
46786 fetch_dim_r_slow:
46787 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46788 dim++;
46789 }
46790 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
46791 }
46792 } else {
46793 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
46794 }
46795 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46796
46797 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46798 }
46799
ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46800 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46801 {
46802 USE_OPLINE
46803 zval *container;
46804
46805 SAVE_OPLINE();
46806 container = EX_VAR(opline->op1.var);
46807 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);
46808 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46809 if (IS_CV == IS_VAR) {
46810 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
46811 }
46812 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46813 }
46814
ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46815 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46816 {
46817 USE_OPLINE
46818 zval *container;
46819
46820 SAVE_OPLINE();
46821 container = EX_VAR(opline->op1.var);
46822 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);
46823 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46824 if (IS_CV == IS_VAR) {
46825 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
46826 }
46827 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46828 }
46829
ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46830 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46831 {
46832 USE_OPLINE
46833 zval *container;
46834
46835 SAVE_OPLINE();
46836 container = EX_VAR(opline->op1.var);
46837 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);
46838 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46839
46840 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46841 }
46842
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46843 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46844 {
46845 #if 0
46846 USE_OPLINE
46847 #endif
46848
46849 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
46850 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
46851 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46852 }
46853 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46854 } else {
46855 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46856 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46857 }
46858 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
46859 }
46860 }
46861
ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46862 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46863 {
46864 USE_OPLINE
46865 zval *container;
46866
46867 SAVE_OPLINE();
46868 container = EX_VAR(opline->op1.var);
46869 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);
46870 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46871 if (IS_CV == IS_VAR) {
46872 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
46873 }
46874 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
46875 }
46876
ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46877 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46878 {
46879 USE_OPLINE
46880 zval *container;
46881 void **cache_slot = NULL;
46882
46883 SAVE_OPLINE();
46884 container = EX_VAR(opline->op1.var);
46885
46886 if (IS_CV == IS_CONST ||
46887 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
46888 do {
46889 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
46890 container = Z_REFVAL_P(container);
46891 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
46892 break;
46893 }
46894 }
46895 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
46896 ZVAL_UNDEFINED_OP1();
46897 }
46898 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46899 ZVAL_NULL(EX_VAR(opline->result.var));
46900 goto fetch_obj_r_finish;
46901 } while (0);
46902 }
46903
46904 /* here we are sure we are dealing with an object */
46905 do {
46906 zend_object *zobj = Z_OBJ_P(container);
46907 zend_string *name, *tmp_name;
46908 zval *retval;
46909
46910 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46911 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
46912
46913 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
46914 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
46915
46916 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
46917 fetch_obj_r_simple:
46918 retval = OBJ_PROP(zobj, prop_offset);
46919 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
46920 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
46921 goto fetch_obj_r_copy;
46922 } else {
46923 fetch_obj_r_fast_copy:
46924 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
46925 ZEND_VM_NEXT_OPCODE();
46926 }
46927 }
46928 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
46929 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
46930 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
46931 prop_offset = prop_info->offset;
46932 goto fetch_obj_r_simple;
46933 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
46934 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
46935 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
46936 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
46937
46938 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
46939 if (IS_CV & IS_CV) {
46940 GC_ADDREF(zobj);
46941 }
46942 if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
46943 call_info |= ZEND_CALL_RELEASE_THIS;
46944 }
46945 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
46946 call->prev_execute_data = execute_data;
46947 call->call = NULL;
46948 call->return_value = EX_VAR(opline->result.var);
46949 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
46950
46951 execute_data = call;
46952 EG(current_execute_data) = execute_data;
46953 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
46954
46955 #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
46956 opline = hook->op_array.opcodes;
46957 #else
46958 EX(opline) = hook->op_array.opcodes;
46959 #endif
46960 LOAD_OPLINE_EX();
46961
46962
46963 ZEND_VM_ENTER_EX();
46964 }
46965 /* Fall through to read_property for hooks. */
46966 } else if (EXPECTED(zobj->properties != NULL)) {
46967 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
46968 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46969 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
46970 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
46971
46972 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
46973 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
46974
46975 if (EXPECTED(p->key == name) ||
46976 (EXPECTED(p->h == ZSTR_H(name)) &&
46977 EXPECTED(p->key != NULL) &&
46978 EXPECTED(zend_string_equal_content(p->key, name)))) {
46979 retval = &p->val;
46980 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
46981 goto fetch_obj_r_copy;
46982 } else {
46983 goto fetch_obj_r_fast_copy;
46984 }
46985 }
46986 }
46987 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
46988 }
46989 retval = zend_hash_find_known_hash(zobj->properties, name);
46990 if (EXPECTED(retval)) {
46991 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
46992 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
46993 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
46994 goto fetch_obj_r_copy;
46995 } else {
46996 goto fetch_obj_r_fast_copy;
46997 }
46998 }
46999 }
47000 }
47001 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47002 } else {
47003 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47004 if (UNEXPECTED(!name)) {
47005 ZVAL_UNDEF(EX_VAR(opline->result.var));
47006 break;
47007 }
47008 }
47009
47010 #if ZEND_DEBUG
47011 /* For non-standard object handlers, verify a declared property type in debug builds.
47012 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
47013 zend_property_info *prop_info = NULL;
47014 if (zobj->handlers->read_property != zend_std_read_property) {
47015 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
47016 }
47017 #endif
47018 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
47019 #if ZEND_DEBUG
47020 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
47021 && ZEND_TYPE_IS_SET(prop_info->type)) {
47022 ZVAL_OPT_DEREF(retval);
47023 zend_verify_property_type(prop_info, retval, /* strict */ true);
47024 }
47025 #endif
47026
47027 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47028 zend_tmp_string_release(tmp_name);
47029 }
47030
47031 if (retval != EX_VAR(opline->result.var)) {
47032 fetch_obj_r_copy:
47033 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47034 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
47035 zend_unwrap_reference(retval);
47036 }
47037 } while (0);
47038
47039 fetch_obj_r_finish:
47040 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47041
47042 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47043 }
47044
ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47045 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47046 {
47047 USE_OPLINE
47048 zval *property, *container, *result;
47049
47050 SAVE_OPLINE();
47051
47052 container = EX_VAR(opline->op1.var);
47053 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47054 result = EX_VAR(opline->result.var);
47055 zend_fetch_property_address(
47056 result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR),
47057 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
47058 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
47059 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47060 if (IS_CV == IS_VAR) {
47061 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47062 }
47063 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47064 }
47065
ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47066 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47067 {
47068 USE_OPLINE
47069 zval *property, *container, *result;
47070
47071 SAVE_OPLINE();
47072 container = EX_VAR(opline->op1.var);
47073 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47074 result = EX_VAR(opline->result.var);
47075 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);
47076 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47077 if (IS_CV == IS_VAR) {
47078 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47079 }
47080 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47081 }
47082
ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47083 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47084 {
47085 USE_OPLINE
47086 zval *container;
47087 void **cache_slot = NULL;
47088
47089 SAVE_OPLINE();
47090 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
47091
47092 if (IS_CV == IS_CONST ||
47093 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
47094 do {
47095 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
47096 container = Z_REFVAL_P(container);
47097 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
47098 break;
47099 }
47100 }
47101 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
47102 ZVAL_UNDEFINED_OP2();
47103 }
47104 ZVAL_NULL(EX_VAR(opline->result.var));
47105 goto fetch_obj_is_finish;
47106 } while (0);
47107 }
47108
47109 /* here we are sure we are dealing with an object */
47110 do {
47111 zend_object *zobj = Z_OBJ_P(container);
47112 zend_string *name, *tmp_name;
47113 zval *retval;
47114
47115 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47116 cache_slot = CACHE_ADDR(opline->extended_value);
47117
47118 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
47119 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47120
47121 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47122 fetch_obj_is_simple:
47123 retval = OBJ_PROP(zobj, prop_offset);
47124 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
47125 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47126 goto fetch_obj_is_copy;
47127 } else {
47128 fetch_obj_is_fast_copy:
47129 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47130 ZEND_VM_NEXT_OPCODE();
47131 }
47132 }
47133 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
47134 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
47135 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
47136 prop_offset = prop_info->offset;
47137 goto fetch_obj_is_simple;
47138 }
47139 /* Fall through to read_property for hooks. */
47140 } else if (EXPECTED(zobj->properties != NULL)) {
47141 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
47142 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47143 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
47144 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
47145
47146 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
47147 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
47148
47149 if (EXPECTED(p->key == name) ||
47150 (EXPECTED(p->h == ZSTR_H(name)) &&
47151 EXPECTED(p->key != NULL) &&
47152 EXPECTED(zend_string_equal_content(p->key, name)))) {
47153 retval = &p->val;
47154 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47155 goto fetch_obj_is_copy;
47156 } else {
47157 goto fetch_obj_is_fast_copy;
47158 }
47159 }
47160 }
47161 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
47162 }
47163 retval = zend_hash_find_known_hash(zobj->properties, name);
47164 if (EXPECTED(retval)) {
47165 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
47166 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
47167 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
47168 goto fetch_obj_is_copy;
47169 } else {
47170 goto fetch_obj_is_fast_copy;
47171 }
47172 }
47173 }
47174 }
47175 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47176 } else {
47177 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47178 if (UNEXPECTED(!name)) {
47179 ZVAL_UNDEF(EX_VAR(opline->result.var));
47180 break;
47181 }
47182 }
47183
47184 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
47185
47186 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47187 zend_tmp_string_release(tmp_name);
47188 }
47189
47190 if (retval != EX_VAR(opline->result.var)) {
47191 fetch_obj_is_copy:
47192 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
47193 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
47194 zend_unwrap_reference(retval);
47195 }
47196 } while (0);
47197
47198 fetch_obj_is_finish:
47199 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47200
47201 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47202 }
47203
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47204 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47205 {
47206 #if 0
47207 USE_OPLINE
47208 #endif
47209
47210 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
47211 /* Behave like FETCH_OBJ_W */
47212 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
47213 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47214 }
47215 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47216 } else {
47217 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47218 }
47219 }
47220
ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47221 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47222 {
47223 USE_OPLINE
47224 zval *container, *property, *result;
47225
47226 SAVE_OPLINE();
47227 container = EX_VAR(opline->op1.var);
47228 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47229 result = EX_VAR(opline->result.var);
47230 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);
47231 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47232 if (IS_CV == IS_VAR) {
47233 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
47234 }
47235 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47236 }
47237
ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47238 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47239 {
47240 USE_OPLINE
47241 zval *object, *value, tmp;
47242 zend_object *zobj;
47243 zend_string *name, *tmp_name;
47244 zend_refcounted *garbage = NULL;
47245
47246 SAVE_OPLINE();
47247 object = EX_VAR(opline->op1.var);
47248 value = RT_CONSTANT((opline+1), (opline+1)->op1);
47249
47250 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47251 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47252 object = Z_REFVAL_P(object);
47253 goto assign_object;
47254 }
47255 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47256 value = &EG(uninitialized_zval);
47257 goto free_and_exit_assign_obj;
47258 }
47259
47260 assign_object:
47261 zobj = Z_OBJ_P(object);
47262 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47263 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47264 void **cache_slot = CACHE_ADDR(opline->extended_value);
47265 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47266 zval *property_val;
47267
47268 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47269 property_val = OBJ_PROP(zobj, prop_offset);
47270 if (Z_TYPE_P(property_val) != IS_UNDEF) {
47271 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47272
47273 if (prop_info != NULL) {
47274 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47275 goto free_and_exit_assign_obj;
47276 } else {
47277 fast_assign_obj:
47278 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
47279 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47280 ZVAL_COPY(EX_VAR(opline->result.var), value);
47281 }
47282 goto exit_assign_obj;
47283 }
47284 }
47285 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47286 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47287 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47288 zobj = zend_lazy_object_init(zobj);
47289 if (!zobj) {
47290 value = &EG(uninitialized_zval);
47291 goto free_and_exit_assign_obj;
47292 }
47293 }
47294 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47295 rebuild_object_properties_internal(zobj);
47296 }
47297 if (EXPECTED(zobj->properties != NULL)) {
47298 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47299 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47300 GC_DELREF(zobj->properties);
47301 }
47302 zobj->properties = zend_array_dup(zobj->properties);
47303 }
47304 property_val = zend_hash_find_known_hash(zobj->properties, name);
47305 if (property_val) {
47306 goto fast_assign_obj;
47307 }
47308 }
47309
47310 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47311 if (IS_CONST == IS_CONST) {
47312 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47313 Z_ADDREF_P(value);
47314 }
47315 } else if (IS_CONST != IS_TMP_VAR) {
47316 if (Z_ISREF_P(value)) {
47317 if (IS_CONST == IS_VAR) {
47318 zend_reference *ref = Z_REF_P(value);
47319 if (GC_DELREF(ref) == 0) {
47320 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47321 efree_size(ref, sizeof(zend_reference));
47322 value = &tmp;
47323 } else {
47324 value = Z_REFVAL_P(value);
47325 Z_TRY_ADDREF_P(value);
47326 }
47327 } else {
47328 value = Z_REFVAL_P(value);
47329 Z_TRY_ADDREF_P(value);
47330 }
47331 } else if (IS_CONST == IS_CV) {
47332 Z_TRY_ADDREF_P(value);
47333 }
47334 }
47335 zend_hash_add_new(zobj->properties, name, value);
47336 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47337 ZVAL_COPY(EX_VAR(opline->result.var), value);
47338 }
47339 goto exit_assign_obj;
47340 }
47341 } else {
47342 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47343 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47344 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
47345 property_val = OBJ_PROP(zobj, prop_info->offset);
47346 if (ZEND_TYPE_IS_SET(prop_info->type)) {
47347 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47348 goto free_and_exit_assign_obj;
47349 } else {
47350 goto fast_assign_obj;
47351 }
47352 }
47353 /* Fall through to write_property for hooks. */
47354 }
47355 }
47356 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47357 } else {
47358 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47359 if (UNEXPECTED(!name)) {
47360
47361 UNDEF_RESULT();
47362 goto exit_assign_obj;
47363 }
47364 }
47365
47366 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
47367 ZVAL_DEREF(value);
47368 }
47369
47370 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47371
47372 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47373 zend_tmp_string_release(tmp_name);
47374 }
47375
47376 free_and_exit_assign_obj:
47377 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47378 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47379 }
47380
47381 exit_assign_obj:
47382 if (garbage) {
47383 GC_DTOR_NO_REF(garbage);
47384 }
47385 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47386
47387 /* assign_obj has two opcodes! */
47388 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47389 }
47390
47391 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47392 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47393 {
47394 USE_OPLINE
47395 zval *object, *value, tmp;
47396 zend_object *zobj;
47397 zend_string *name, *tmp_name;
47398 zend_refcounted *garbage = NULL;
47399
47400 SAVE_OPLINE();
47401 object = EX_VAR(opline->op1.var);
47402 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
47403
47404 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47405 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47406 object = Z_REFVAL_P(object);
47407 goto assign_object;
47408 }
47409 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47410 value = &EG(uninitialized_zval);
47411 goto free_and_exit_assign_obj;
47412 }
47413
47414 assign_object:
47415 zobj = Z_OBJ_P(object);
47416 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47417 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47418 void **cache_slot = CACHE_ADDR(opline->extended_value);
47419 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47420 zval *property_val;
47421
47422 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47423 property_val = OBJ_PROP(zobj, prop_offset);
47424 if (Z_TYPE_P(property_val) != IS_UNDEF) {
47425 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47426
47427 if (prop_info != NULL) {
47428 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47429 goto free_and_exit_assign_obj;
47430 } else {
47431 fast_assign_obj:
47432 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
47433 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47434 ZVAL_COPY(EX_VAR(opline->result.var), value);
47435 }
47436 goto exit_assign_obj;
47437 }
47438 }
47439 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47440 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47441 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47442 zobj = zend_lazy_object_init(zobj);
47443 if (!zobj) {
47444 value = &EG(uninitialized_zval);
47445 goto free_and_exit_assign_obj;
47446 }
47447 }
47448 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47449 rebuild_object_properties_internal(zobj);
47450 }
47451 if (EXPECTED(zobj->properties != NULL)) {
47452 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47453 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47454 GC_DELREF(zobj->properties);
47455 }
47456 zobj->properties = zend_array_dup(zobj->properties);
47457 }
47458 property_val = zend_hash_find_known_hash(zobj->properties, name);
47459 if (property_val) {
47460 goto fast_assign_obj;
47461 }
47462 }
47463
47464 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47465 if (IS_TMP_VAR == IS_CONST) {
47466 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47467 Z_ADDREF_P(value);
47468 }
47469 } else if (IS_TMP_VAR != IS_TMP_VAR) {
47470 if (Z_ISREF_P(value)) {
47471 if (IS_TMP_VAR == IS_VAR) {
47472 zend_reference *ref = Z_REF_P(value);
47473 if (GC_DELREF(ref) == 0) {
47474 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47475 efree_size(ref, sizeof(zend_reference));
47476 value = &tmp;
47477 } else {
47478 value = Z_REFVAL_P(value);
47479 Z_TRY_ADDREF_P(value);
47480 }
47481 } else {
47482 value = Z_REFVAL_P(value);
47483 Z_TRY_ADDREF_P(value);
47484 }
47485 } else if (IS_TMP_VAR == IS_CV) {
47486 Z_TRY_ADDREF_P(value);
47487 }
47488 }
47489 zend_hash_add_new(zobj->properties, name, value);
47490 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47491 ZVAL_COPY(EX_VAR(opline->result.var), value);
47492 }
47493 goto exit_assign_obj;
47494 }
47495 } else {
47496 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47497 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47498 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
47499 property_val = OBJ_PROP(zobj, prop_info->offset);
47500 if (ZEND_TYPE_IS_SET(prop_info->type)) {
47501 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47502 goto free_and_exit_assign_obj;
47503 } else {
47504 goto fast_assign_obj;
47505 }
47506 }
47507 /* Fall through to write_property for hooks. */
47508 }
47509 }
47510 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47511 } else {
47512 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47513 if (UNEXPECTED(!name)) {
47514 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47515 UNDEF_RESULT();
47516 goto exit_assign_obj;
47517 }
47518 }
47519
47520 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
47521 ZVAL_DEREF(value);
47522 }
47523
47524 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47525
47526 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47527 zend_tmp_string_release(tmp_name);
47528 }
47529
47530 free_and_exit_assign_obj:
47531 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47532 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47533 }
47534 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47535 exit_assign_obj:
47536 if (garbage) {
47537 GC_DTOR_NO_REF(garbage);
47538 }
47539 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47540
47541 /* assign_obj has two opcodes! */
47542 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47543 }
47544
47545 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47546 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47547 {
47548 USE_OPLINE
47549 zval *object, *value, tmp;
47550 zend_object *zobj;
47551 zend_string *name, *tmp_name;
47552 zend_refcounted *garbage = NULL;
47553
47554 SAVE_OPLINE();
47555 object = EX_VAR(opline->op1.var);
47556 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
47557
47558 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47559 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47560 object = Z_REFVAL_P(object);
47561 goto assign_object;
47562 }
47563 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47564 value = &EG(uninitialized_zval);
47565 goto free_and_exit_assign_obj;
47566 }
47567
47568 assign_object:
47569 zobj = Z_OBJ_P(object);
47570 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47571 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47572 void **cache_slot = CACHE_ADDR(opline->extended_value);
47573 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47574 zval *property_val;
47575
47576 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47577 property_val = OBJ_PROP(zobj, prop_offset);
47578 if (Z_TYPE_P(property_val) != IS_UNDEF) {
47579 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47580
47581 if (prop_info != NULL) {
47582 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47583 goto free_and_exit_assign_obj;
47584 } else {
47585 fast_assign_obj:
47586 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
47587 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47588 ZVAL_COPY(EX_VAR(opline->result.var), value);
47589 }
47590 goto exit_assign_obj;
47591 }
47592 }
47593 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47594 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47595 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47596 zobj = zend_lazy_object_init(zobj);
47597 if (!zobj) {
47598 value = &EG(uninitialized_zval);
47599 goto free_and_exit_assign_obj;
47600 }
47601 }
47602 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47603 rebuild_object_properties_internal(zobj);
47604 }
47605 if (EXPECTED(zobj->properties != NULL)) {
47606 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47607 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47608 GC_DELREF(zobj->properties);
47609 }
47610 zobj->properties = zend_array_dup(zobj->properties);
47611 }
47612 property_val = zend_hash_find_known_hash(zobj->properties, name);
47613 if (property_val) {
47614 goto fast_assign_obj;
47615 }
47616 }
47617
47618 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47619 if (IS_VAR == IS_CONST) {
47620 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47621 Z_ADDREF_P(value);
47622 }
47623 } else if (IS_VAR != IS_TMP_VAR) {
47624 if (Z_ISREF_P(value)) {
47625 if (IS_VAR == IS_VAR) {
47626 zend_reference *ref = Z_REF_P(value);
47627 if (GC_DELREF(ref) == 0) {
47628 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47629 efree_size(ref, sizeof(zend_reference));
47630 value = &tmp;
47631 } else {
47632 value = Z_REFVAL_P(value);
47633 Z_TRY_ADDREF_P(value);
47634 }
47635 } else {
47636 value = Z_REFVAL_P(value);
47637 Z_TRY_ADDREF_P(value);
47638 }
47639 } else if (IS_VAR == IS_CV) {
47640 Z_TRY_ADDREF_P(value);
47641 }
47642 }
47643 zend_hash_add_new(zobj->properties, name, value);
47644 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47645 ZVAL_COPY(EX_VAR(opline->result.var), value);
47646 }
47647 goto exit_assign_obj;
47648 }
47649 } else {
47650 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47651 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47652 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
47653 property_val = OBJ_PROP(zobj, prop_info->offset);
47654 if (ZEND_TYPE_IS_SET(prop_info->type)) {
47655 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47656 goto free_and_exit_assign_obj;
47657 } else {
47658 goto fast_assign_obj;
47659 }
47660 }
47661 /* Fall through to write_property for hooks. */
47662 }
47663 }
47664 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47665 } else {
47666 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47667 if (UNEXPECTED(!name)) {
47668 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47669 UNDEF_RESULT();
47670 goto exit_assign_obj;
47671 }
47672 }
47673
47674 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
47675 ZVAL_DEREF(value);
47676 }
47677
47678 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47679
47680 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47681 zend_tmp_string_release(tmp_name);
47682 }
47683
47684 free_and_exit_assign_obj:
47685 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47686 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47687 }
47688 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47689 exit_assign_obj:
47690 if (garbage) {
47691 GC_DTOR_NO_REF(garbage);
47692 }
47693 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47694
47695 /* assign_obj has two opcodes! */
47696 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47697 }
47698
47699 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47700 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47701 {
47702 USE_OPLINE
47703 zval *object, *value, tmp;
47704 zend_object *zobj;
47705 zend_string *name, *tmp_name;
47706 zend_refcounted *garbage = NULL;
47707
47708 SAVE_OPLINE();
47709 object = EX_VAR(opline->op1.var);
47710 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
47711
47712 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
47713 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
47714 object = Z_REFVAL_P(object);
47715 goto assign_object;
47716 }
47717 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
47718 value = &EG(uninitialized_zval);
47719 goto free_and_exit_assign_obj;
47720 }
47721
47722 assign_object:
47723 zobj = Z_OBJ_P(object);
47724 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47725 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
47726 void **cache_slot = CACHE_ADDR(opline->extended_value);
47727 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
47728 zval *property_val;
47729
47730 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
47731 property_val = OBJ_PROP(zobj, prop_offset);
47732 if (Z_TYPE_P(property_val) != IS_UNDEF) {
47733 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
47734
47735 if (prop_info != NULL) {
47736 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47737 goto free_and_exit_assign_obj;
47738 } else {
47739 fast_assign_obj:
47740 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
47741 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47742 ZVAL_COPY(EX_VAR(opline->result.var), value);
47743 }
47744 goto exit_assign_obj;
47745 }
47746 }
47747 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
47748 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47749 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
47750 zobj = zend_lazy_object_init(zobj);
47751 if (!zobj) {
47752 value = &EG(uninitialized_zval);
47753 goto free_and_exit_assign_obj;
47754 }
47755 }
47756 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47757 rebuild_object_properties_internal(zobj);
47758 }
47759 if (EXPECTED(zobj->properties != NULL)) {
47760 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
47761 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
47762 GC_DELREF(zobj->properties);
47763 }
47764 zobj->properties = zend_array_dup(zobj->properties);
47765 }
47766 property_val = zend_hash_find_known_hash(zobj->properties, name);
47767 if (property_val) {
47768 goto fast_assign_obj;
47769 }
47770 }
47771
47772 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
47773 if (IS_CV == IS_CONST) {
47774 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
47775 Z_ADDREF_P(value);
47776 }
47777 } else if (IS_CV != IS_TMP_VAR) {
47778 if (Z_ISREF_P(value)) {
47779 if (IS_CV == IS_VAR) {
47780 zend_reference *ref = Z_REF_P(value);
47781 if (GC_DELREF(ref) == 0) {
47782 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
47783 efree_size(ref, sizeof(zend_reference));
47784 value = &tmp;
47785 } else {
47786 value = Z_REFVAL_P(value);
47787 Z_TRY_ADDREF_P(value);
47788 }
47789 } else {
47790 value = Z_REFVAL_P(value);
47791 Z_TRY_ADDREF_P(value);
47792 }
47793 } else if (IS_CV == IS_CV) {
47794 Z_TRY_ADDREF_P(value);
47795 }
47796 }
47797 zend_hash_add_new(zobj->properties, name, value);
47798 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47799 ZVAL_COPY(EX_VAR(opline->result.var), value);
47800 }
47801 goto exit_assign_obj;
47802 }
47803 } else {
47804 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
47805 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
47806 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
47807 property_val = OBJ_PROP(zobj, prop_info->offset);
47808 if (ZEND_TYPE_IS_SET(prop_info->type)) {
47809 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
47810 goto free_and_exit_assign_obj;
47811 } else {
47812 goto fast_assign_obj;
47813 }
47814 }
47815 /* Fall through to write_property for hooks. */
47816 }
47817 }
47818 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
47819 } else {
47820 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
47821 if (UNEXPECTED(!name)) {
47822
47823 UNDEF_RESULT();
47824 goto exit_assign_obj;
47825 }
47826 }
47827
47828 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
47829 ZVAL_DEREF(value);
47830 }
47831
47832 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
47833
47834 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47835 zend_tmp_string_release(tmp_name);
47836 }
47837
47838 free_and_exit_assign_obj:
47839 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
47840 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
47841 }
47842
47843 exit_assign_obj:
47844 if (garbage) {
47845 GC_DTOR_NO_REF(garbage);
47846 }
47847 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47848
47849 /* assign_obj has two opcodes! */
47850 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47851 }
47852
47853 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47854 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47855 {
47856 USE_OPLINE
47857 zval *object_ptr, *orig_object_ptr;
47858 zval *value;
47859 zval *variable_ptr;
47860 zval *dim;
47861 zend_refcounted *garbage = NULL;
47862
47863 SAVE_OPLINE();
47864 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
47865
47866 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
47867 try_assign_dim_array:
47868 SEPARATE_ARRAY(object_ptr);
47869 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
47870 value = RT_CONSTANT((opline+1), (opline+1)->op1);
47871 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
47872 HashTable *ht = Z_ARRVAL_P(object_ptr);
47873 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
47874 GC_ADDREF(ht);
47875 }
47876 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
47877 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
47878 zend_array_destroy(ht);
47879 goto assign_dim_error;
47880 }
47881 }
47882 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
47883 ZVAL_DEREF(value);
47884 }
47885 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
47886 if (UNEXPECTED(value == NULL)) {
47887 zend_cannot_add_element();
47888 goto assign_dim_error;
47889 } else if (IS_CONST == IS_CV) {
47890 if (Z_REFCOUNTED_P(value)) {
47891 Z_ADDREF_P(value);
47892 }
47893 } else if (IS_CONST == IS_VAR) {
47894 zval *free_op_data = EX_VAR((opline+1)->op1.var);
47895 if (Z_ISREF_P(free_op_data)) {
47896 if (Z_REFCOUNTED_P(value)) {
47897 Z_ADDREF_P(value);
47898 }
47899 zval_ptr_dtor_nogc(free_op_data);
47900 }
47901 } else if (IS_CONST == IS_CONST) {
47902 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
47903 Z_ADDREF_P(value);
47904 }
47905 }
47906 } else {
47907 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47908 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47909 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
47910 } else {
47911 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
47912 }
47913 if (UNEXPECTED(variable_ptr == NULL)) {
47914 goto assign_dim_error;
47915 }
47916 value = RT_CONSTANT((opline+1), (opline+1)->op1);
47917 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
47918 }
47919 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47920 ZVAL_COPY(EX_VAR(opline->result.var), value);
47921 }
47922 if (garbage) {
47923 GC_DTOR_NO_REF(garbage);
47924 }
47925 } else {
47926 if (EXPECTED(Z_ISREF_P(object_ptr))) {
47927 object_ptr = Z_REFVAL_P(object_ptr);
47928 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
47929 goto try_assign_dim_array;
47930 }
47931 }
47932 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
47933 zend_object *obj = Z_OBJ_P(object_ptr);
47934
47935 GC_ADDREF(obj);
47936 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47937 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
47938 dim = ZVAL_UNDEFINED_OP2();
47939 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
47940 dim++;
47941 }
47942
47943 value = RT_CONSTANT((opline+1), (opline+1)->op1);
47944 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
47945 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
47946 } else if (IS_CONST & (IS_CV|IS_VAR)) {
47947 ZVAL_DEREF(value);
47948 }
47949
47950 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
47951
47952 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
47953 zend_objects_store_del(obj);
47954 }
47955 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
47956 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
47957 zend_use_new_element_for_string();
47958
47959 UNDEF_RESULT();
47960 } else {
47961 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47962 value = RT_CONSTANT((opline+1), (opline+1)->op1);
47963 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
47964
47965 }
47966 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
47967 if (Z_ISREF_P(orig_object_ptr)
47968 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
47969 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
47970 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47971
47972 UNDEF_RESULT();
47973 } else {
47974 HashTable *ht = zend_new_array(8);
47975 uint8_t old_type = Z_TYPE_P(object_ptr);
47976
47977 ZVAL_ARR(object_ptr, ht);
47978 if (UNEXPECTED(old_type == IS_FALSE)) {
47979 GC_ADDREF(ht);
47980 zend_false_to_array_deprecated();
47981 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
47982 zend_array_destroy(ht);
47983 goto assign_dim_error;
47984 }
47985 }
47986 goto try_assign_dim_array;
47987 }
47988 } else {
47989 zend_use_scalar_as_array();
47990 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47991 assign_dim_error:
47992
47993 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47994 ZVAL_NULL(EX_VAR(opline->result.var));
47995 }
47996 }
47997 }
47998 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
47999 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48000 }
48001
48002 /* assign_dim has two opcodes! */
48003 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48004 }
48005
ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48006 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48007 {
48008 USE_OPLINE
48009 zval *object_ptr, *orig_object_ptr;
48010 zval *value;
48011 zval *variable_ptr;
48012 zval *dim;
48013 zend_refcounted *garbage = NULL;
48014
48015 SAVE_OPLINE();
48016 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48017
48018 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48019 try_assign_dim_array:
48020 SEPARATE_ARRAY(object_ptr);
48021 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48022 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48023 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48024 HashTable *ht = Z_ARRVAL_P(object_ptr);
48025 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48026 GC_ADDREF(ht);
48027 }
48028 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48029 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48030 zend_array_destroy(ht);
48031 goto assign_dim_error;
48032 }
48033 }
48034 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
48035 ZVAL_DEREF(value);
48036 }
48037 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48038 if (UNEXPECTED(value == NULL)) {
48039 zend_cannot_add_element();
48040 goto assign_dim_error;
48041 } else if (IS_TMP_VAR == IS_CV) {
48042 if (Z_REFCOUNTED_P(value)) {
48043 Z_ADDREF_P(value);
48044 }
48045 } else if (IS_TMP_VAR == IS_VAR) {
48046 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48047 if (Z_ISREF_P(free_op_data)) {
48048 if (Z_REFCOUNTED_P(value)) {
48049 Z_ADDREF_P(value);
48050 }
48051 zval_ptr_dtor_nogc(free_op_data);
48052 }
48053 } else if (IS_TMP_VAR == IS_CONST) {
48054 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48055 Z_ADDREF_P(value);
48056 }
48057 }
48058 } else {
48059 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48060 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48061 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48062 } else {
48063 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48064 }
48065 if (UNEXPECTED(variable_ptr == NULL)) {
48066 goto assign_dim_error;
48067 }
48068 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48069 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
48070 }
48071 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48072 ZVAL_COPY(EX_VAR(opline->result.var), value);
48073 }
48074 if (garbage) {
48075 GC_DTOR_NO_REF(garbage);
48076 }
48077 } else {
48078 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48079 object_ptr = Z_REFVAL_P(object_ptr);
48080 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48081 goto try_assign_dim_array;
48082 }
48083 }
48084 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48085 zend_object *obj = Z_OBJ_P(object_ptr);
48086
48087 GC_ADDREF(obj);
48088 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48089 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48090 dim = ZVAL_UNDEFINED_OP2();
48091 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48092 dim++;
48093 }
48094
48095 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48096 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48097 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48098 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
48099 ZVAL_DEREF(value);
48100 }
48101
48102 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48103
48104 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48105 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48106 zend_objects_store_del(obj);
48107 }
48108 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48109 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48110 zend_use_new_element_for_string();
48111 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48112 UNDEF_RESULT();
48113 } else {
48114 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48115 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48116 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48117 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48118 }
48119 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48120 if (Z_ISREF_P(orig_object_ptr)
48121 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48122 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48123 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48124 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48125 UNDEF_RESULT();
48126 } else {
48127 HashTable *ht = zend_new_array(8);
48128 uint8_t old_type = Z_TYPE_P(object_ptr);
48129
48130 ZVAL_ARR(object_ptr, ht);
48131 if (UNEXPECTED(old_type == IS_FALSE)) {
48132 GC_ADDREF(ht);
48133 zend_false_to_array_deprecated();
48134 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48135 zend_array_destroy(ht);
48136 goto assign_dim_error;
48137 }
48138 }
48139 goto try_assign_dim_array;
48140 }
48141 } else {
48142 zend_use_scalar_as_array();
48143 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48144 assign_dim_error:
48145 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48146 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48147 ZVAL_NULL(EX_VAR(opline->result.var));
48148 }
48149 }
48150 }
48151 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48152 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48153 }
48154
48155 /* assign_dim has two opcodes! */
48156 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48157 }
48158
ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48159 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48160 {
48161 USE_OPLINE
48162 zval *object_ptr, *orig_object_ptr;
48163 zval *value;
48164 zval *variable_ptr;
48165 zval *dim;
48166 zend_refcounted *garbage = NULL;
48167
48168 SAVE_OPLINE();
48169 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48170
48171 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48172 try_assign_dim_array:
48173 SEPARATE_ARRAY(object_ptr);
48174 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48175 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48176 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48177 HashTable *ht = Z_ARRVAL_P(object_ptr);
48178 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48179 GC_ADDREF(ht);
48180 }
48181 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48182 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48183 zend_array_destroy(ht);
48184 goto assign_dim_error;
48185 }
48186 }
48187 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
48188 ZVAL_DEREF(value);
48189 }
48190 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48191 if (UNEXPECTED(value == NULL)) {
48192 zend_cannot_add_element();
48193 goto assign_dim_error;
48194 } else if (IS_VAR == IS_CV) {
48195 if (Z_REFCOUNTED_P(value)) {
48196 Z_ADDREF_P(value);
48197 }
48198 } else if (IS_VAR == IS_VAR) {
48199 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48200 if (Z_ISREF_P(free_op_data)) {
48201 if (Z_REFCOUNTED_P(value)) {
48202 Z_ADDREF_P(value);
48203 }
48204 zval_ptr_dtor_nogc(free_op_data);
48205 }
48206 } else if (IS_VAR == IS_CONST) {
48207 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48208 Z_ADDREF_P(value);
48209 }
48210 }
48211 } else {
48212 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48213 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48214 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48215 } else {
48216 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48217 }
48218 if (UNEXPECTED(variable_ptr == NULL)) {
48219 goto assign_dim_error;
48220 }
48221 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48222 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
48223 }
48224 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48225 ZVAL_COPY(EX_VAR(opline->result.var), value);
48226 }
48227 if (garbage) {
48228 GC_DTOR_NO_REF(garbage);
48229 }
48230 } else {
48231 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48232 object_ptr = Z_REFVAL_P(object_ptr);
48233 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48234 goto try_assign_dim_array;
48235 }
48236 }
48237 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48238 zend_object *obj = Z_OBJ_P(object_ptr);
48239
48240 GC_ADDREF(obj);
48241 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48242 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48243 dim = ZVAL_UNDEFINED_OP2();
48244 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48245 dim++;
48246 }
48247
48248 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48249 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48250 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48251 } else if (IS_VAR & (IS_CV|IS_VAR)) {
48252 ZVAL_DEREF(value);
48253 }
48254
48255 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48256
48257 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48258 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48259 zend_objects_store_del(obj);
48260 }
48261 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48262 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48263 zend_use_new_element_for_string();
48264 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48265 UNDEF_RESULT();
48266 } else {
48267 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48268 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48269 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48270 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48271 }
48272 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48273 if (Z_ISREF_P(orig_object_ptr)
48274 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48275 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48276 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48277 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48278 UNDEF_RESULT();
48279 } else {
48280 HashTable *ht = zend_new_array(8);
48281 uint8_t old_type = Z_TYPE_P(object_ptr);
48282
48283 ZVAL_ARR(object_ptr, ht);
48284 if (UNEXPECTED(old_type == IS_FALSE)) {
48285 GC_ADDREF(ht);
48286 zend_false_to_array_deprecated();
48287 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48288 zend_array_destroy(ht);
48289 goto assign_dim_error;
48290 }
48291 }
48292 goto try_assign_dim_array;
48293 }
48294 } else {
48295 zend_use_scalar_as_array();
48296 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48297 assign_dim_error:
48298 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48299 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48300 ZVAL_NULL(EX_VAR(opline->result.var));
48301 }
48302 }
48303 }
48304 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48305 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48306 }
48307
48308 /* assign_dim has two opcodes! */
48309 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48310 }
48311
ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48312 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48313 {
48314 USE_OPLINE
48315 zval *object_ptr, *orig_object_ptr;
48316 zval *value;
48317 zval *variable_ptr;
48318 zval *dim;
48319 zend_refcounted *garbage = NULL;
48320
48321 SAVE_OPLINE();
48322 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48323
48324 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48325 try_assign_dim_array:
48326 SEPARATE_ARRAY(object_ptr);
48327 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48328 value = EX_VAR((opline+1)->op1.var);
48329 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48330 HashTable *ht = Z_ARRVAL_P(object_ptr);
48331 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48332 GC_ADDREF(ht);
48333 }
48334 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48335 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48336 zend_array_destroy(ht);
48337 goto assign_dim_error;
48338 }
48339 }
48340 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
48341 ZVAL_DEREF(value);
48342 }
48343 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48344 if (UNEXPECTED(value == NULL)) {
48345 zend_cannot_add_element();
48346 goto assign_dim_error;
48347 } else if (IS_CV == IS_CV) {
48348 if (Z_REFCOUNTED_P(value)) {
48349 Z_ADDREF_P(value);
48350 }
48351 } else if (IS_CV == IS_VAR) {
48352 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48353 if (Z_ISREF_P(free_op_data)) {
48354 if (Z_REFCOUNTED_P(value)) {
48355 Z_ADDREF_P(value);
48356 }
48357 zval_ptr_dtor_nogc(free_op_data);
48358 }
48359 } else if (IS_CV == IS_CONST) {
48360 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48361 Z_ADDREF_P(value);
48362 }
48363 }
48364 } else {
48365 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48366 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48367 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48368 } else {
48369 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48370 }
48371 if (UNEXPECTED(variable_ptr == NULL)) {
48372 goto assign_dim_error;
48373 }
48374 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
48375 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
48376 }
48377 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48378 ZVAL_COPY(EX_VAR(opline->result.var), value);
48379 }
48380 if (garbage) {
48381 GC_DTOR_NO_REF(garbage);
48382 }
48383 } else {
48384 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48385 object_ptr = Z_REFVAL_P(object_ptr);
48386 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48387 goto try_assign_dim_array;
48388 }
48389 }
48390 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48391 zend_object *obj = Z_OBJ_P(object_ptr);
48392
48393 GC_ADDREF(obj);
48394 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48395 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48396 dim = ZVAL_UNDEFINED_OP2();
48397 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48398 dim++;
48399 }
48400
48401 value = EX_VAR((opline+1)->op1.var);
48402 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48403 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48404 } else if (IS_CV & (IS_CV|IS_VAR)) {
48405 ZVAL_DEREF(value);
48406 }
48407
48408 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48409
48410 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48411 zend_objects_store_del(obj);
48412 }
48413 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48414 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
48415 zend_use_new_element_for_string();
48416
48417 UNDEF_RESULT();
48418 } else {
48419 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48420 value = EX_VAR((opline+1)->op1.var);
48421 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48422
48423 }
48424 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48425 if (Z_ISREF_P(orig_object_ptr)
48426 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48427 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48428 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48429
48430 UNDEF_RESULT();
48431 } else {
48432 HashTable *ht = zend_new_array(8);
48433 uint8_t old_type = Z_TYPE_P(object_ptr);
48434
48435 ZVAL_ARR(object_ptr, ht);
48436 if (UNEXPECTED(old_type == IS_FALSE)) {
48437 GC_ADDREF(ht);
48438 zend_false_to_array_deprecated();
48439 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48440 zend_array_destroy(ht);
48441 goto assign_dim_error;
48442 }
48443 }
48444 goto try_assign_dim_array;
48445 }
48446 } else {
48447 zend_use_scalar_as_array();
48448 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48449 assign_dim_error:
48450
48451 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48452 ZVAL_NULL(EX_VAR(opline->result.var));
48453 }
48454 }
48455 }
48456 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48457 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48458 }
48459
48460 /* assign_dim has two opcodes! */
48461 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48462 }
48463
ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48464 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48465 {
48466 USE_OPLINE
48467 zval *property, *container, *value_ptr;
48468
48469 SAVE_OPLINE();
48470
48471 container = EX_VAR(opline->op1.var);
48472 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48473
48474 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48475
48476 if (1) {
48477 if (IS_CV == IS_UNUSED) {
48478 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48479 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48480 } else {
48481 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48482 }
48483 } else {
48484 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48485 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48486 } else {
48487 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48488 }
48489 }
48490 } else {
48491 zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
48492 }
48493
48494 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48495 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48496 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48497 }
48498
48499 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48500 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48501 {
48502 USE_OPLINE
48503 zval *property, *container, *value_ptr;
48504
48505 SAVE_OPLINE();
48506
48507 container = EX_VAR(opline->op1.var);
48508 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48509
48510 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
48511
48512 if (1) {
48513 if (IS_CV == IS_UNUSED) {
48514 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48515 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48516 } else {
48517 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48518 }
48519 } else {
48520 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48521 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48522 } else {
48523 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
48524 }
48525 }
48526 } else {
48527 zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
48528 }
48529
48530 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48531
48532 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48533 }
48534
48535 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48536 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48537 {
48538 USE_OPLINE
48539 zval *op1, *op2;
48540 zend_string *op1_str, *op2_str, *str;
48541
48542
48543 op1 = EX_VAR(opline->op1.var);
48544 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48545 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
48546 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
48547 zend_string *op1_str = Z_STR_P(op1);
48548 zend_string *op2_str = Z_STR_P(op2);
48549 zend_string *str;
48550 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
48551
48552 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
48553 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
48554 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
48555 } else {
48556 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
48557 }
48558 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
48559 zend_string_release_ex(op1_str, 0);
48560 }
48561 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
48562 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
48563 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
48564 } else {
48565 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
48566 }
48567 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48568 zend_string_release_ex(op2_str, 0);
48569 }
48570 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
48571 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
48572 size_t len = ZSTR_LEN(op1_str);
48573
48574 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
48575 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48576 GC_ADD_FLAGS(str, flags);
48577 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48578 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48579 zend_string_release_ex(op2_str, 0);
48580 }
48581 } else {
48582 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
48583 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
48584 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48585 GC_ADD_FLAGS(str, flags);
48586 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48587 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
48588 zend_string_release_ex(op1_str, 0);
48589 }
48590 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
48591 zend_string_release_ex(op2_str, 0);
48592 }
48593 }
48594 ZEND_VM_NEXT_OPCODE();
48595 }
48596
48597 SAVE_OPLINE();
48598 if (IS_CV == IS_CONST) {
48599 op1_str = Z_STR_P(op1);
48600 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
48601 op1_str = zend_string_copy(Z_STR_P(op1));
48602 } else {
48603 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
48604 ZVAL_UNDEFINED_OP1();
48605 }
48606 op1_str = zval_get_string_func(op1);
48607 }
48608 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48609 op2_str = Z_STR_P(op2);
48610 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
48611 op2_str = zend_string_copy(Z_STR_P(op2));
48612 } else {
48613 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
48614 ZVAL_UNDEFINED_OP2();
48615 }
48616 op2_str = zval_get_string_func(op2);
48617 }
48618 do {
48619 if (IS_CV != IS_CONST) {
48620 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
48621 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48622 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
48623 GC_ADDREF(op2_str);
48624 }
48625 }
48626 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
48627 zend_string_release_ex(op1_str, 0);
48628 break;
48629 }
48630 }
48631 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48632 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
48633 if (IS_CV == IS_CONST) {
48634 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
48635 GC_ADDREF(op1_str);
48636 }
48637 }
48638 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
48639 zend_string_release_ex(op2_str, 0);
48640 break;
48641 }
48642 }
48643 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
48644 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
48645 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
48646
48647 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
48648 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
48649 if (IS_CV != IS_CONST) {
48650 zend_string_release_ex(op1_str, 0);
48651 }
48652 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48653 zend_string_release_ex(op2_str, 0);
48654 }
48655 } while (0);
48656
48657 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48658 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48659 }
48660
ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48661 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48662 {
48663 USE_OPLINE
48664 zval *function_name;
48665 zval *object;
48666 zend_function *fbc;
48667 zend_class_entry *called_scope;
48668 zend_object *obj;
48669 zend_execute_data *call;
48670 uint32_t call_info;
48671
48672 SAVE_OPLINE();
48673
48674 object = EX_VAR(opline->op1.var);
48675
48676 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48677 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48678 }
48679
48680 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
48681 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
48682 do {
48683 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
48684 function_name = Z_REFVAL_P(function_name);
48685 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
48686 break;
48687 }
48688 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
48689 ZVAL_UNDEFINED_OP2();
48690 if (UNEXPECTED(EG(exception) != NULL)) {
48691
48692 HANDLE_EXCEPTION();
48693 }
48694 }
48695 zend_throw_error(NULL, "Method name must be a string");
48696 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48697
48698 HANDLE_EXCEPTION();
48699 } while (0);
48700 }
48701
48702 if (IS_CV == IS_UNUSED) {
48703 obj = Z_OBJ_P(object);
48704 } else {
48705 do {
48706 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
48707 obj = Z_OBJ_P(object);
48708 } else {
48709 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
48710 zend_reference *ref = Z_REF_P(object);
48711
48712 object = &ref->val;
48713 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
48714 obj = Z_OBJ_P(object);
48715 if (IS_CV & IS_VAR) {
48716 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
48717 efree_size(ref, sizeof(zend_reference));
48718 } else {
48719 Z_ADDREF_P(object);
48720 }
48721 }
48722 break;
48723 }
48724 }
48725 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
48726 object = ZVAL_UNDEFINED_OP1();
48727 if (UNEXPECTED(EG(exception) != NULL)) {
48728 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48729 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48730 }
48731 HANDLE_EXCEPTION();
48732 }
48733 }
48734 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48735 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48736 }
48737 zend_invalid_method_call(object, function_name);
48738 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48739
48740 HANDLE_EXCEPTION();
48741 }
48742 } while (0);
48743 }
48744
48745 called_scope = obj->ce;
48746
48747 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
48748 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
48749 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
48750 } else {
48751 zend_object *orig_obj = obj;
48752
48753 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
48754 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48755 }
48756
48757 /* First, locate the function. */
48758 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));
48759 if (UNEXPECTED(fbc == NULL)) {
48760 if (EXPECTED(!EG(exception))) {
48761 zend_undefined_method(obj->ce, Z_STR_P(function_name));
48762 }
48763 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48764 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
48765 zend_objects_store_del(orig_obj);
48766 }
48767 HANDLE_EXCEPTION();
48768 }
48769 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
48770 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
48771 EXPECTED(obj == orig_obj)) {
48772 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
48773 }
48774 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
48775 GC_ADDREF(obj); /* For $this pointer */
48776 if (GC_DELREF(orig_obj) == 0) {
48777 zend_objects_store_del(orig_obj);
48778 }
48779 }
48780 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
48781 init_func_run_time_cache(&fbc->op_array);
48782 }
48783 }
48784
48785 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48786 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48787 }
48788
48789 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
48790 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
48791 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
48792 zend_objects_store_del(obj);
48793 if (UNEXPECTED(EG(exception))) {
48794 HANDLE_EXCEPTION();
48795 }
48796 }
48797 /* call static method */
48798 obj = (zend_object*)called_scope;
48799 call_info = ZEND_CALL_NESTED_FUNCTION;
48800 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
48801 if (IS_CV == IS_CV) {
48802 GC_ADDREF(obj); /* For $this pointer */
48803 }
48804 /* CV may be changed indirectly (e.g. when it's a reference) */
48805 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
48806 }
48807
48808 call = zend_vm_stack_push_call_frame(call_info,
48809 fbc, opline->extended_value, obj);
48810 call->prev_execute_data = EX(call);
48811 EX(call) = call;
48812
48813 ZEND_VM_NEXT_OPCODE();
48814 }
48815
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48816 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48817 {
48818 USE_OPLINE
48819 zval *expr_ptr, new_expr;
48820
48821 SAVE_OPLINE();
48822 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
48823 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
48824 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
48825 if (Z_ISREF_P(expr_ptr)) {
48826 Z_ADDREF_P(expr_ptr);
48827 } else {
48828 ZVAL_MAKE_REF_EX(expr_ptr, 2);
48829 }
48830
48831 } else {
48832 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48833 if (IS_CV == IS_TMP_VAR) {
48834 /* pass */
48835 } else if (IS_CV == IS_CONST) {
48836 Z_TRY_ADDREF_P(expr_ptr);
48837 } else if (IS_CV == IS_CV) {
48838 ZVAL_DEREF(expr_ptr);
48839 Z_TRY_ADDREF_P(expr_ptr);
48840 } else /* if (IS_CV == IS_VAR) */ {
48841 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
48842 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
48843
48844 expr_ptr = Z_REFVAL_P(expr_ptr);
48845 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
48846 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
48847 expr_ptr = &new_expr;
48848 efree_size(ref, sizeof(zend_reference));
48849 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
48850 Z_ADDREF_P(expr_ptr);
48851 }
48852 }
48853 }
48854 }
48855
48856 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
48857 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48858 zend_string *str;
48859 zend_ulong hval;
48860
48861 add_again:
48862 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
48863 str = Z_STR_P(offset);
48864 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48865 if (ZEND_HANDLE_NUMERIC(str, hval)) {
48866 goto num_index;
48867 }
48868 }
48869 str_index:
48870 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
48871 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
48872 hval = Z_LVAL_P(offset);
48873 num_index:
48874 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
48875 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
48876 offset = Z_REFVAL_P(offset);
48877 goto add_again;
48878 } else if (Z_TYPE_P(offset) == IS_NULL) {
48879 str = ZSTR_EMPTY_ALLOC();
48880 goto str_index;
48881 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
48882 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
48883 goto num_index;
48884 } else if (Z_TYPE_P(offset) == IS_FALSE) {
48885 hval = 0;
48886 goto num_index;
48887 } else if (Z_TYPE_P(offset) == IS_TRUE) {
48888 hval = 1;
48889 goto num_index;
48890 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
48891 zend_use_resource_as_offset(offset);
48892 hval = Z_RES_HANDLE_P(offset);
48893 goto num_index;
48894 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
48895 ZVAL_UNDEFINED_OP2();
48896 str = ZSTR_EMPTY_ALLOC();
48897 goto str_index;
48898 } else {
48899 zend_illegal_array_offset_access(offset);
48900 zval_ptr_dtor_nogc(expr_ptr);
48901 }
48902 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48903 } else {
48904 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
48905 zend_cannot_add_element();
48906 zval_ptr_dtor_nogc(expr_ptr);
48907 }
48908 }
48909 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48910 }
48911
ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48912 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48913 {
48914 zval *array;
48915 uint32_t size;
48916 USE_OPLINE
48917
48918 array = EX_VAR(opline->result.var);
48919 if (IS_CV != IS_UNUSED) {
48920 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
48921 ZVAL_ARR(array, zend_new_array(size));
48922 /* Explicitly initialize array as not-packed if flag is set */
48923 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
48924 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
48925 }
48926 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
48927 } else {
48928 ZVAL_ARR(array, zend_new_array(0));
48929 ZEND_VM_NEXT_OPCODE();
48930 }
48931 }
48932
ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48933 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48934 {
48935 USE_OPLINE
48936 zval *container;
48937 zval *offset;
48938 zend_ulong hval;
48939 zend_string *key;
48940
48941 SAVE_OPLINE();
48942 container = EX_VAR(opline->op1.var);
48943 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48944
48945 do {
48946 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
48947 HashTable *ht;
48948
48949 unset_dim_array:
48950 SEPARATE_ARRAY(container);
48951 ht = Z_ARRVAL_P(container);
48952 offset_again:
48953 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
48954 key = Z_STR_P(offset);
48955 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
48956 if (ZEND_HANDLE_NUMERIC(key, hval)) {
48957 goto num_index_dim;
48958 }
48959 }
48960 str_index_dim:
48961 ZEND_ASSERT(ht != &EG(symbol_table));
48962 zend_hash_del(ht, key);
48963 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
48964 hval = Z_LVAL_P(offset);
48965 num_index_dim:
48966 zend_hash_index_del(ht, hval);
48967 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
48968 offset = Z_REFVAL_P(offset);
48969 goto offset_again;
48970 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
48971 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
48972 goto num_index_dim;
48973 } else if (Z_TYPE_P(offset) == IS_NULL) {
48974 key = ZSTR_EMPTY_ALLOC();
48975 goto str_index_dim;
48976 } else if (Z_TYPE_P(offset) == IS_FALSE) {
48977 hval = 0;
48978 goto num_index_dim;
48979 } else if (Z_TYPE_P(offset) == IS_TRUE) {
48980 hval = 1;
48981 goto num_index_dim;
48982 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
48983 zend_use_resource_as_offset(offset);
48984 hval = Z_RES_HANDLE_P(offset);
48985 goto num_index_dim;
48986 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
48987 ZVAL_UNDEFINED_OP2();
48988 key = ZSTR_EMPTY_ALLOC();
48989 goto str_index_dim;
48990 } else {
48991 zend_illegal_array_offset_unset(offset);
48992 }
48993 break;
48994 } else if (Z_ISREF_P(container)) {
48995 container = Z_REFVAL_P(container);
48996 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
48997 goto unset_dim_array;
48998 }
48999 }
49000 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
49001 container = ZVAL_UNDEFINED_OP1();
49002 }
49003 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
49004 offset = ZVAL_UNDEFINED_OP2();
49005 }
49006 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
49007 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
49008 offset++;
49009 }
49010 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
49011 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
49012 zend_throw_error(NULL, "Cannot unset string offsets");
49013 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
49014 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
49015 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
49016 zend_false_to_array_deprecated();
49017 }
49018 } while (0);
49019
49020 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49021
49022 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49023 }
49024
ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49025 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49026 {
49027 USE_OPLINE
49028 zval *container;
49029 zval *offset;
49030 zend_string *name, *tmp_name;
49031
49032 SAVE_OPLINE();
49033 container = EX_VAR(opline->op1.var);
49034 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49035
49036 do {
49037 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
49038 if (Z_ISREF_P(container)) {
49039 container = Z_REFVAL_P(container);
49040 if (Z_TYPE_P(container) != IS_OBJECT) {
49041 if (IS_CV == IS_CV
49042 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
49043 ZVAL_UNDEFINED_OP1();
49044 }
49045 break;
49046 }
49047 } else {
49048 break;
49049 }
49050 }
49051 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
49052 name = Z_STR_P(offset);
49053 } else {
49054 name = zval_try_get_tmp_string(offset, &tmp_name);
49055 if (UNEXPECTED(!name)) {
49056 break;
49057 }
49058 }
49059 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));
49060 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49061 zend_tmp_string_release(tmp_name);
49062 }
49063 } while (0);
49064
49065 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49066
49067 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49068 }
49069
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49070 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49071 {
49072 USE_OPLINE
49073 zval *container;
49074 bool result;
49075 zend_ulong hval;
49076 zval *offset;
49077
49078 SAVE_OPLINE();
49079 container = EX_VAR(opline->op1.var);
49080 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49081
49082 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49083 HashTable *ht;
49084 zval *value;
49085 zend_string *str;
49086
49087 isset_dim_obj_array:
49088 ht = Z_ARRVAL_P(container);
49089 isset_again:
49090 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
49091 str = Z_STR_P(offset);
49092 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49093 if (ZEND_HANDLE_NUMERIC(str, hval)) {
49094 goto num_index_prop;
49095 }
49096 }
49097 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
49098 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
49099 hval = Z_LVAL_P(offset);
49100 num_index_prop:
49101 value = zend_hash_index_find(ht, hval);
49102 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
49103 offset = Z_REFVAL_P(offset);
49104 goto isset_again;
49105 } else {
49106 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
49107 if (UNEXPECTED(EG(exception))) {
49108 result = 0;
49109 goto isset_dim_obj_exit;
49110 }
49111 }
49112
49113 if (!(opline->extended_value & ZEND_ISEMPTY)) {
49114 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
49115 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
49116 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
49117
49118 if (IS_CV & (IS_CONST|IS_CV)) {
49119 /* avoid exception check */
49120 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49121 ZEND_VM_SMART_BRANCH(result, 0);
49122 }
49123 } else {
49124 result = (value == NULL || !i_zend_is_true(value));
49125 }
49126 goto isset_dim_obj_exit;
49127 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
49128 container = Z_REFVAL_P(container);
49129 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49130 goto isset_dim_obj_array;
49131 }
49132 }
49133
49134 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
49135 offset++;
49136 }
49137 if (!(opline->extended_value & ZEND_ISEMPTY)) {
49138 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
49139 } else {
49140 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
49141 }
49142
49143 isset_dim_obj_exit:
49144 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49145
49146 ZEND_VM_SMART_BRANCH(result, 1);
49147 }
49148
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49149 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49150 {
49151 USE_OPLINE
49152 zval *container;
49153 int result;
49154 zval *offset;
49155 zend_string *name, *tmp_name;
49156
49157 SAVE_OPLINE();
49158 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
49159 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49160
49161 if (IS_CV == IS_CONST ||
49162 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
49163 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
49164 container = Z_REFVAL_P(container);
49165 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
49166 result = (opline->extended_value & ZEND_ISEMPTY);
49167 goto isset_object_finish;
49168 }
49169 } else {
49170 result = (opline->extended_value & ZEND_ISEMPTY);
49171 goto isset_object_finish;
49172 }
49173 }
49174
49175 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
49176 name = Z_STR_P(offset);
49177 } else {
49178 name = zval_try_get_tmp_string(offset, &tmp_name);
49179 if (UNEXPECTED(!name)) {
49180 result = 0;
49181 goto isset_object_finish;
49182 }
49183 }
49184
49185 result =
49186 (opline->extended_value & ZEND_ISEMPTY) ^
49187 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));
49188
49189 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
49190 zend_tmp_string_release(tmp_name);
49191 }
49192
49193 isset_object_finish:
49194 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49195
49196 ZEND_VM_SMART_BRANCH(result, 1);
49197 }
49198
ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49199 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49200 {
49201 USE_OPLINE
49202
49203 zval *key, *subject;
49204 HashTable *ht;
49205 bool result;
49206
49207 SAVE_OPLINE();
49208
49209 key = EX_VAR(opline->op1.var);
49210 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49211
49212 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
49213 array_key_exists_array:
49214 ht = Z_ARRVAL_P(subject);
49215 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
49216 } else {
49217 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
49218 subject = Z_REFVAL_P(subject);
49219 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
49220 goto array_key_exists_array;
49221 }
49222 }
49223 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
49224 result = 0;
49225 }
49226
49227 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49228
49229 ZEND_VM_SMART_BRANCH(result, 1);
49230 }
49231
ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49232 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49233 {
49234 USE_OPLINE
49235
49236 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
49237
49238 SAVE_OPLINE();
49239 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
49240 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49241 }
49242
49243 /* Destroy the previously yielded value */
49244 zval_ptr_dtor(&generator->value);
49245
49246 /* Destroy the previously yielded key */
49247 zval_ptr_dtor(&generator->key);
49248
49249 /* Set the new yielded value */
49250 if (IS_CV != IS_UNUSED) {
49251 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
49252 /* Constants and temporary variables aren't yieldable by reference,
49253 * but we still allow them with a notice. */
49254 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
49255 zval *value;
49256
49257 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49258
49259 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49260 ZVAL_COPY_VALUE(&generator->value, value);
49261 if (IS_CV == IS_CONST) {
49262 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49263 Z_ADDREF(generator->value);
49264 }
49265 }
49266 } else {
49267 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49268
49269 /* If a function call result is yielded and the function did
49270 * not return by reference we throw a notice. */
49271 do {
49272 if (IS_CV == IS_VAR) {
49273 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
49274 if (opline->extended_value == ZEND_RETURNS_FUNCTION
49275 && !Z_ISREF_P(value_ptr)) {
49276 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49277 ZVAL_COPY(&generator->value, value_ptr);
49278 break;
49279 }
49280 }
49281 if (Z_ISREF_P(value_ptr)) {
49282 Z_ADDREF_P(value_ptr);
49283 } else {
49284 ZVAL_MAKE_REF_EX(value_ptr, 2);
49285 }
49286 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
49287 } while (0);
49288
49289 }
49290 } else {
49291 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49292
49293 /* Consts, temporary variables and references need copying */
49294 if (IS_CV == IS_CONST) {
49295 ZVAL_COPY_VALUE(&generator->value, value);
49296 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49297 Z_ADDREF(generator->value);
49298 }
49299 } else if (IS_CV == IS_TMP_VAR) {
49300 ZVAL_COPY_VALUE(&generator->value, value);
49301 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
49302 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
49303
49304 } else {
49305 ZVAL_COPY_VALUE(&generator->value, value);
49306 if (IS_CV == IS_CV) {
49307 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
49308 }
49309 }
49310 }
49311 } else {
49312 /* If no value was specified yield null */
49313 ZVAL_NULL(&generator->value);
49314 }
49315
49316 /* Set the new yielded key */
49317 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
49318 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49319 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
49320 key = Z_REFVAL_P(key);
49321 }
49322 ZVAL_COPY(&generator->key, key);
49323 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49324
49325 if (Z_TYPE(generator->key) == IS_LONG
49326 && Z_LVAL(generator->key) > generator->largest_used_integer_key
49327 ) {
49328 generator->largest_used_integer_key = Z_LVAL(generator->key);
49329 }
49330 } else {
49331 /* If no key was specified we use auto-increment keys */
49332 generator->largest_used_integer_key++;
49333 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
49334 }
49335
49336 if (RETURN_VALUE_USED(opline)) {
49337 /* If the return value of yield is used set the send
49338 * target and initialize it to NULL */
49339 generator->send_target = EX_VAR(opline->result.var);
49340 ZVAL_NULL(generator->send_target);
49341 } else {
49342 generator->send_target = NULL;
49343 }
49344
49345 /* The GOTO VM uses a local opline variable. We need to set the opline
49346 * variable in execute_data so we don't resume at an old position. */
49347 SAVE_OPLINE();
49348
49349 ZEND_VM_RETURN();
49350 }
49351
ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49352 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49353 {
49354 USE_OPLINE
49355 zval *op1, *op2;
49356 bool result;
49357
49358 SAVE_OPLINE();
49359 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49360 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49361 result = fast_is_identical_function(op1, op2);
49362
49363 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49364 ZEND_VM_SMART_BRANCH(result, 1);
49365 }
49366
ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49367 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49368 {
49369 USE_OPLINE
49370 zval *op1, *op2;
49371 bool result;
49372
49373 SAVE_OPLINE();
49374 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49375 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49376 result = fast_is_not_identical_function(op1, op2);
49377
49378 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49379 ZEND_VM_SMART_BRANCH(result, 1);
49380 }
49381
ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49382 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49383 {
49384 USE_OPLINE
49385 zval *value;
49386 zval *variable_ptr;
49387
49388 SAVE_OPLINE();
49389 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49390 variable_ptr = EX_VAR(opline->op1.var);
49391
49392 if (0 || UNEXPECTED(0)) {
49393 zend_refcounted *garbage = NULL;
49394
49395 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
49396 if (UNEXPECTED(0)) {
49397 ZVAL_COPY(EX_VAR(opline->result.var), value);
49398 }
49399 if (garbage) {
49400 GC_DTOR_NO_REF(garbage);
49401 }
49402 } else {
49403 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
49404 }
49405
49406 /* zend_assign_to_variable() always takes care of op2, never free it! */
49407
49408 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49409 }
49410
ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49411 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49412 {
49413 USE_OPLINE
49414 zval *value;
49415 zval *variable_ptr;
49416
49417 SAVE_OPLINE();
49418 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
49419 variable_ptr = EX_VAR(opline->op1.var);
49420
49421 if (0 || UNEXPECTED(1)) {
49422 zend_refcounted *garbage = NULL;
49423
49424 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
49425 if (UNEXPECTED(1)) {
49426 ZVAL_COPY(EX_VAR(opline->result.var), value);
49427 }
49428 if (garbage) {
49429 GC_DTOR_NO_REF(garbage);
49430 }
49431 } else {
49432 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
49433 }
49434
49435 /* zend_assign_to_variable() always takes care of op2, never free it! */
49436
49437 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49438 }
49439
ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49440 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49441 {
49442 USE_OPLINE
49443 zval *op1, *op2;
49444 bool result;
49445
49446 SAVE_OPLINE();
49447 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49448 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
49449 result = fast_is_identical_function(op1, op2);
49450
49451 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49452 ZEND_VM_SMART_BRANCH(result, 1);
49453 }
49454
ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49455 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49456 {
49457 USE_OPLINE
49458 zval *op1, *op2;
49459 bool result;
49460
49461 SAVE_OPLINE();
49462 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49463 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
49464 result = fast_is_not_identical_function(op1, op2);
49465
49466 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49467 ZEND_VM_SMART_BRANCH(result, 1);
49468 }
49469
ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49470 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49471 {
49472 USE_OPLINE
49473 zval *value;
49474 zval *variable_ptr;
49475
49476 SAVE_OPLINE();
49477 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49478 variable_ptr = EX_VAR(opline->op1.var);
49479
49480 if (0 || UNEXPECTED(0)) {
49481 zend_refcounted *garbage = NULL;
49482
49483 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
49484 if (UNEXPECTED(0)) {
49485 ZVAL_COPY(EX_VAR(opline->result.var), value);
49486 }
49487 if (garbage) {
49488 GC_DTOR_NO_REF(garbage);
49489 }
49490 } else {
49491 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
49492 }
49493
49494 /* zend_assign_to_variable() always takes care of op2, never free it! */
49495
49496 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49497 }
49498
ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49499 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49500 {
49501 USE_OPLINE
49502 zval *value;
49503 zval *variable_ptr;
49504
49505 SAVE_OPLINE();
49506 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49507 variable_ptr = EX_VAR(opline->op1.var);
49508
49509 if (0 || UNEXPECTED(1)) {
49510 zend_refcounted *garbage = NULL;
49511
49512 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
49513 if (UNEXPECTED(1)) {
49514 ZVAL_COPY(EX_VAR(opline->result.var), value);
49515 }
49516 if (garbage) {
49517 GC_DTOR_NO_REF(garbage);
49518 }
49519 } else {
49520 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
49521 }
49522
49523 /* zend_assign_to_variable() always takes care of op2, never free it! */
49524
49525 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49526 }
49527
ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49528 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49529 {
49530 USE_OPLINE
49531 zval *variable_ptr;
49532 zval *value_ptr;
49533 zend_refcounted *garbage = NULL;
49534
49535 SAVE_OPLINE();
49536 value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
49537 variable_ptr = EX_VAR(opline->op1.var);
49538
49539 if (IS_CV == IS_VAR &&
49540 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
49541
49542 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
49543 variable_ptr = &EG(uninitialized_zval);
49544 } else if (IS_VAR == IS_VAR &&
49545 opline->extended_value == ZEND_RETURNS_FUNCTION &&
49546 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
49547
49548 variable_ptr = zend_wrong_assign_to_variable_reference(
49549 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
49550 } else {
49551 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
49552 }
49553
49554 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49555 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
49556 }
49557
49558 if (garbage) {
49559 GC_DTOR(garbage);
49560 }
49561
49562 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
49563
49564 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49565 }
49566
ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49567 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49568 {
49569 USE_OPLINE
49570 zval *expr;
49571 bool result;
49572
49573 SAVE_OPLINE();
49574 expr = EX_VAR(opline->op1.var);
49575
49576 try_instanceof:
49577 if (Z_TYPE_P(expr) == IS_OBJECT) {
49578 zend_class_entry *ce;
49579
49580 if (IS_VAR == IS_CONST) {
49581 ce = CACHED_PTR(opline->extended_value);
49582 if (UNEXPECTED(ce == NULL)) {
49583 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);
49584 if (EXPECTED(ce)) {
49585 CACHE_PTR(opline->extended_value, ce);
49586 }
49587 }
49588 } else if (IS_VAR == IS_UNUSED) {
49589 ce = zend_fetch_class(NULL, opline->op2.num);
49590 if (UNEXPECTED(ce == NULL)) {
49591
49592 ZVAL_UNDEF(EX_VAR(opline->result.var));
49593 HANDLE_EXCEPTION();
49594 }
49595 } else {
49596 ce = Z_CE_P(EX_VAR(opline->op2.var));
49597 }
49598 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
49599 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
49600 expr = Z_REFVAL_P(expr);
49601 goto try_instanceof;
49602 } else {
49603 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
49604 ZVAL_UNDEFINED_OP1();
49605 }
49606 result = 0;
49607 }
49608
49609 ZEND_VM_SMART_BRANCH(result, 1);
49610 }
49611
ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49612 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49613 {
49614 USE_OPLINE
49615 zval *var_ptr;
49616 zval *value, *container, *dim;
49617 HashTable *ht;
49618
49619 SAVE_OPLINE();
49620 container = EX_VAR(opline->op1.var);
49621
49622 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49623 assign_dim_op_array:
49624 SEPARATE_ARRAY(container);
49625 ht = Z_ARRVAL_P(container);
49626 assign_dim_op_new_array:
49627 dim = NULL;
49628 if (IS_UNUSED == IS_UNUSED) {
49629 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
49630 if (UNEXPECTED(!var_ptr)) {
49631 zend_cannot_add_element();
49632 goto assign_dim_op_ret_null;
49633 }
49634 } else {
49635 if (IS_UNUSED == IS_CONST) {
49636 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
49637 } else {
49638 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
49639 }
49640 if (UNEXPECTED(!var_ptr)) {
49641 goto assign_dim_op_ret_null;
49642 }
49643 }
49644
49645 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
49646
49647 do {
49648 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
49649 zend_reference *ref = Z_REF_P(var_ptr);
49650 var_ptr = Z_REFVAL_P(var_ptr);
49651 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
49652 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
49653 break;
49654 }
49655 }
49656 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
49657 } while (0);
49658
49659 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49660 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
49661 }
49662 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
49663 } else {
49664 if (EXPECTED(Z_ISREF_P(container))) {
49665 container = Z_REFVAL_P(container);
49666 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
49667 goto assign_dim_op_array;
49668 }
49669 }
49670
49671 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
49672 zend_object *obj = Z_OBJ_P(container);
49673
49674 dim = NULL;
49675 if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
49676 dim++;
49677 }
49678 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
49679 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
49680 uint8_t old_type;
49681
49682 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
49683 ZVAL_UNDEFINED_OP1();
49684 }
49685 ht = zend_new_array(8);
49686 old_type = Z_TYPE_P(container);
49687 ZVAL_ARR(container, ht);
49688 if (UNEXPECTED(old_type == IS_FALSE)) {
49689 GC_ADDREF(ht);
49690 zend_false_to_array_deprecated();
49691 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
49692 zend_array_destroy(ht);
49693 goto assign_dim_op_ret_null;
49694 }
49695 }
49696 goto assign_dim_op_new_array;
49697 } else {
49698 dim = NULL;
49699 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
49700 assign_dim_op_ret_null:
49701 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
49702 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49703 ZVAL_NULL(EX_VAR(opline->result.var));
49704 }
49705 }
49706 }
49707
49708
49709 ZEND_VM_NEXT_OPCODE_EX(1, 2);
49710 }
49711
zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)49712 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
49713 {
49714 USE_OPLINE
49715 zval *varname;
49716 zval *retval;
49717 zend_string *name, *tmp_name;
49718 HashTable *target_symbol_table;
49719
49720 SAVE_OPLINE();
49721 varname = EX_VAR(opline->op1.var);
49722
49723 if (IS_CV == IS_CONST) {
49724 name = Z_STR_P(varname);
49725 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
49726 name = Z_STR_P(varname);
49727 tmp_name = NULL;
49728 } else {
49729 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
49730 ZVAL_UNDEFINED_OP1();
49731 }
49732 name = zval_try_get_tmp_string(varname, &tmp_name);
49733 if (UNEXPECTED(!name)) {
49734 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
49735
49736 }
49737 ZVAL_UNDEF(EX_VAR(opline->result.var));
49738 HANDLE_EXCEPTION();
49739 }
49740 }
49741
49742 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
49743 retval = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
49744 if (retval == NULL) {
49745 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
49746 fetch_this:
49747 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
49748 if (IS_CV != IS_CONST) {
49749 zend_tmp_string_release(tmp_name);
49750 }
49751 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49752 }
49753 if (type == BP_VAR_W) {
49754 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
49755 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
49756 retval = &EG(uninitialized_zval);
49757 } else {
49758 if (IS_CV == IS_CV) {
49759 /* Keep name alive in case an error handler tries to free it. */
49760 zend_string_addref(name);
49761 }
49762 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
49763 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
49764 if (type == BP_VAR_RW && !EG(exception)) {
49765 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
49766 } else {
49767 retval = &EG(uninitialized_zval);
49768 }
49769 if (IS_CV == IS_CV) {
49770 zend_string_release(name);
49771 }
49772 }
49773 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
49774 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
49775 retval = Z_INDIRECT_P(retval);
49776 if (Z_TYPE_P(retval) == IS_UNDEF) {
49777 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
49778 goto fetch_this;
49779 }
49780 if (type == BP_VAR_W) {
49781 ZVAL_NULL(retval);
49782 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
49783 retval = &EG(uninitialized_zval);
49784 } else {
49785 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
49786 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
49787 if (type == BP_VAR_RW && !EG(exception)) {
49788 ZVAL_NULL(retval);
49789 } else {
49790 retval = &EG(uninitialized_zval);
49791 }
49792 }
49793 }
49794 }
49795
49796 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
49797
49798 }
49799
49800 if (IS_CV != IS_CONST) {
49801 zend_tmp_string_release(tmp_name);
49802 }
49803
49804 ZEND_ASSERT(retval != NULL);
49805 if (type == BP_VAR_R || type == BP_VAR_IS) {
49806 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
49807 } else {
49808 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
49809 }
49810 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49811 }
49812
ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49813 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49814 {
49815 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49816 }
49817
ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49818 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49819 {
49820 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49821 }
49822
ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49823 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49824 {
49825 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49826 }
49827
ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49828 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49829 {
49830 int fetch_type =
49831 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
49832 BP_VAR_W : BP_VAR_R;
49833 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49834 }
49835
ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49836 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49837 {
49838 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49839 }
49840
ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49841 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49842 {
49843 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
49844 }
49845
49846 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49847 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49848 {
49849 USE_OPLINE
49850 zval *container;
49851
49852 SAVE_OPLINE();
49853 container = EX_VAR(opline->op1.var);
49854 zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
49855
49856 if (IS_CV == IS_VAR) {
49857 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
49858 }
49859 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49860 }
49861
ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49862 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49863 {
49864 USE_OPLINE
49865 zval *container;
49866
49867 SAVE_OPLINE();
49868 container = EX_VAR(opline->op1.var);
49869 zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
49870
49871 if (IS_CV == IS_VAR) {
49872 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
49873 }
49874 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49875 }
49876
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49877 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49878 {
49879 #if 0
49880 USE_OPLINE
49881 #endif
49882
49883 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
49884 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
49885 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49886 }
49887 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49888 } else {
49889 if (IS_UNUSED == IS_UNUSED) {
49890 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49891 }
49892 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49893 }
49894 }
49895
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49896 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49897 {
49898 USE_OPLINE
49899 zval *object_ptr, *orig_object_ptr;
49900 zval *value;
49901 zval *variable_ptr;
49902 zval *dim;
49903 zend_refcounted *garbage = NULL;
49904
49905 SAVE_OPLINE();
49906 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
49907
49908 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
49909 try_assign_dim_array:
49910 SEPARATE_ARRAY(object_ptr);
49911 if (IS_UNUSED == IS_UNUSED) {
49912 value = RT_CONSTANT((opline+1), (opline+1)->op1);
49913 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
49914 HashTable *ht = Z_ARRVAL_P(object_ptr);
49915 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
49916 GC_ADDREF(ht);
49917 }
49918 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
49919 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
49920 zend_array_destroy(ht);
49921 goto assign_dim_error;
49922 }
49923 }
49924 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
49925 ZVAL_DEREF(value);
49926 }
49927 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
49928 if (UNEXPECTED(value == NULL)) {
49929 zend_cannot_add_element();
49930 goto assign_dim_error;
49931 } else if (IS_CONST == IS_CV) {
49932 if (Z_REFCOUNTED_P(value)) {
49933 Z_ADDREF_P(value);
49934 }
49935 } else if (IS_CONST == IS_VAR) {
49936 zval *free_op_data = EX_VAR((opline+1)->op1.var);
49937 if (Z_ISREF_P(free_op_data)) {
49938 if (Z_REFCOUNTED_P(value)) {
49939 Z_ADDREF_P(value);
49940 }
49941 zval_ptr_dtor_nogc(free_op_data);
49942 }
49943 } else if (IS_CONST == IS_CONST) {
49944 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
49945 Z_ADDREF_P(value);
49946 }
49947 }
49948 } else {
49949 dim = NULL;
49950 if (IS_UNUSED == IS_CONST) {
49951 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
49952 } else {
49953 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
49954 }
49955 if (UNEXPECTED(variable_ptr == NULL)) {
49956 goto assign_dim_error;
49957 }
49958 value = RT_CONSTANT((opline+1), (opline+1)->op1);
49959 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
49960 }
49961 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49962 ZVAL_COPY(EX_VAR(opline->result.var), value);
49963 }
49964 if (garbage) {
49965 GC_DTOR_NO_REF(garbage);
49966 }
49967 } else {
49968 if (EXPECTED(Z_ISREF_P(object_ptr))) {
49969 object_ptr = Z_REFVAL_P(object_ptr);
49970 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
49971 goto try_assign_dim_array;
49972 }
49973 }
49974 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
49975 zend_object *obj = Z_OBJ_P(object_ptr);
49976
49977 GC_ADDREF(obj);
49978 dim = NULL;
49979 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
49980 dim = ZVAL_UNDEFINED_OP2();
49981 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
49982 dim++;
49983 }
49984
49985 value = RT_CONSTANT((opline+1), (opline+1)->op1);
49986 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
49987 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
49988 } else if (IS_CONST & (IS_CV|IS_VAR)) {
49989 ZVAL_DEREF(value);
49990 }
49991
49992 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
49993
49994 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
49995 zend_objects_store_del(obj);
49996 }
49997 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
49998 if (IS_UNUSED == IS_UNUSED) {
49999 zend_use_new_element_for_string();
50000
50001 UNDEF_RESULT();
50002 } else {
50003 dim = NULL;
50004 value = RT_CONSTANT((opline+1), (opline+1)->op1);
50005 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50006
50007 }
50008 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50009 if (Z_ISREF_P(orig_object_ptr)
50010 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50011 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50012 dim = NULL;
50013
50014 UNDEF_RESULT();
50015 } else {
50016 HashTable *ht = zend_new_array(8);
50017 uint8_t old_type = Z_TYPE_P(object_ptr);
50018
50019 ZVAL_ARR(object_ptr, ht);
50020 if (UNEXPECTED(old_type == IS_FALSE)) {
50021 GC_ADDREF(ht);
50022 zend_false_to_array_deprecated();
50023 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50024 zend_array_destroy(ht);
50025 goto assign_dim_error;
50026 }
50027 }
50028 goto try_assign_dim_array;
50029 }
50030 } else {
50031 zend_use_scalar_as_array();
50032 dim = NULL;
50033 assign_dim_error:
50034
50035 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50036 ZVAL_NULL(EX_VAR(opline->result.var));
50037 }
50038 }
50039 }
50040 if (IS_UNUSED != IS_UNUSED) {
50041
50042 }
50043
50044 /* assign_dim has two opcodes! */
50045 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50046 }
50047
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50048 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50049 {
50050 USE_OPLINE
50051 zval *object_ptr, *orig_object_ptr;
50052 zval *value;
50053 zval *variable_ptr;
50054 zval *dim;
50055 zend_refcounted *garbage = NULL;
50056
50057 SAVE_OPLINE();
50058 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50059
50060 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50061 try_assign_dim_array:
50062 SEPARATE_ARRAY(object_ptr);
50063 if (IS_UNUSED == IS_UNUSED) {
50064 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50065 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50066 HashTable *ht = Z_ARRVAL_P(object_ptr);
50067 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50068 GC_ADDREF(ht);
50069 }
50070 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50071 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50072 zend_array_destroy(ht);
50073 goto assign_dim_error;
50074 }
50075 }
50076 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
50077 ZVAL_DEREF(value);
50078 }
50079 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50080 if (UNEXPECTED(value == NULL)) {
50081 zend_cannot_add_element();
50082 goto assign_dim_error;
50083 } else if (IS_TMP_VAR == IS_CV) {
50084 if (Z_REFCOUNTED_P(value)) {
50085 Z_ADDREF_P(value);
50086 }
50087 } else if (IS_TMP_VAR == IS_VAR) {
50088 zval *free_op_data = EX_VAR((opline+1)->op1.var);
50089 if (Z_ISREF_P(free_op_data)) {
50090 if (Z_REFCOUNTED_P(value)) {
50091 Z_ADDREF_P(value);
50092 }
50093 zval_ptr_dtor_nogc(free_op_data);
50094 }
50095 } else if (IS_TMP_VAR == IS_CONST) {
50096 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50097 Z_ADDREF_P(value);
50098 }
50099 }
50100 } else {
50101 dim = NULL;
50102 if (IS_UNUSED == IS_CONST) {
50103 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50104 } else {
50105 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50106 }
50107 if (UNEXPECTED(variable_ptr == NULL)) {
50108 goto assign_dim_error;
50109 }
50110 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50111 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
50112 }
50113 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50114 ZVAL_COPY(EX_VAR(opline->result.var), value);
50115 }
50116 if (garbage) {
50117 GC_DTOR_NO_REF(garbage);
50118 }
50119 } else {
50120 if (EXPECTED(Z_ISREF_P(object_ptr))) {
50121 object_ptr = Z_REFVAL_P(object_ptr);
50122 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50123 goto try_assign_dim_array;
50124 }
50125 }
50126 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50127 zend_object *obj = Z_OBJ_P(object_ptr);
50128
50129 GC_ADDREF(obj);
50130 dim = NULL;
50131 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50132 dim = ZVAL_UNDEFINED_OP2();
50133 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50134 dim++;
50135 }
50136
50137 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50138 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50139 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50140 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
50141 ZVAL_DEREF(value);
50142 }
50143
50144 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50145
50146 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50147 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50148 zend_objects_store_del(obj);
50149 }
50150 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50151 if (IS_UNUSED == IS_UNUSED) {
50152 zend_use_new_element_for_string();
50153 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50154 UNDEF_RESULT();
50155 } else {
50156 dim = NULL;
50157 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
50158 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50159 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50160 }
50161 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50162 if (Z_ISREF_P(orig_object_ptr)
50163 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50164 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50165 dim = NULL;
50166 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50167 UNDEF_RESULT();
50168 } else {
50169 HashTable *ht = zend_new_array(8);
50170 uint8_t old_type = Z_TYPE_P(object_ptr);
50171
50172 ZVAL_ARR(object_ptr, ht);
50173 if (UNEXPECTED(old_type == IS_FALSE)) {
50174 GC_ADDREF(ht);
50175 zend_false_to_array_deprecated();
50176 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50177 zend_array_destroy(ht);
50178 goto assign_dim_error;
50179 }
50180 }
50181 goto try_assign_dim_array;
50182 }
50183 } else {
50184 zend_use_scalar_as_array();
50185 dim = NULL;
50186 assign_dim_error:
50187 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50188 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50189 ZVAL_NULL(EX_VAR(opline->result.var));
50190 }
50191 }
50192 }
50193 if (IS_UNUSED != IS_UNUSED) {
50194
50195 }
50196
50197 /* assign_dim has two opcodes! */
50198 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50199 }
50200
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50201 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50202 {
50203 USE_OPLINE
50204 zval *object_ptr, *orig_object_ptr;
50205 zval *value;
50206 zval *variable_ptr;
50207 zval *dim;
50208 zend_refcounted *garbage = NULL;
50209
50210 SAVE_OPLINE();
50211 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50212
50213 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50214 try_assign_dim_array:
50215 SEPARATE_ARRAY(object_ptr);
50216 if (IS_UNUSED == IS_UNUSED) {
50217 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50218 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50219 HashTable *ht = Z_ARRVAL_P(object_ptr);
50220 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50221 GC_ADDREF(ht);
50222 }
50223 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50224 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50225 zend_array_destroy(ht);
50226 goto assign_dim_error;
50227 }
50228 }
50229 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
50230 ZVAL_DEREF(value);
50231 }
50232 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50233 if (UNEXPECTED(value == NULL)) {
50234 zend_cannot_add_element();
50235 goto assign_dim_error;
50236 } else if (IS_VAR == IS_CV) {
50237 if (Z_REFCOUNTED_P(value)) {
50238 Z_ADDREF_P(value);
50239 }
50240 } else if (IS_VAR == IS_VAR) {
50241 zval *free_op_data = EX_VAR((opline+1)->op1.var);
50242 if (Z_ISREF_P(free_op_data)) {
50243 if (Z_REFCOUNTED_P(value)) {
50244 Z_ADDREF_P(value);
50245 }
50246 zval_ptr_dtor_nogc(free_op_data);
50247 }
50248 } else if (IS_VAR == IS_CONST) {
50249 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50250 Z_ADDREF_P(value);
50251 }
50252 }
50253 } else {
50254 dim = NULL;
50255 if (IS_UNUSED == IS_CONST) {
50256 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50257 } else {
50258 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50259 }
50260 if (UNEXPECTED(variable_ptr == NULL)) {
50261 goto assign_dim_error;
50262 }
50263 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50264 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
50265 }
50266 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50267 ZVAL_COPY(EX_VAR(opline->result.var), value);
50268 }
50269 if (garbage) {
50270 GC_DTOR_NO_REF(garbage);
50271 }
50272 } else {
50273 if (EXPECTED(Z_ISREF_P(object_ptr))) {
50274 object_ptr = Z_REFVAL_P(object_ptr);
50275 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50276 goto try_assign_dim_array;
50277 }
50278 }
50279 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50280 zend_object *obj = Z_OBJ_P(object_ptr);
50281
50282 GC_ADDREF(obj);
50283 dim = NULL;
50284 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50285 dim = ZVAL_UNDEFINED_OP2();
50286 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50287 dim++;
50288 }
50289
50290 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50291 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50292 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50293 } else if (IS_VAR & (IS_CV|IS_VAR)) {
50294 ZVAL_DEREF(value);
50295 }
50296
50297 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50298
50299 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50300 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50301 zend_objects_store_del(obj);
50302 }
50303 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50304 if (IS_UNUSED == IS_UNUSED) {
50305 zend_use_new_element_for_string();
50306 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50307 UNDEF_RESULT();
50308 } else {
50309 dim = NULL;
50310 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
50311 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50312 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50313 }
50314 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50315 if (Z_ISREF_P(orig_object_ptr)
50316 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50317 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50318 dim = NULL;
50319 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50320 UNDEF_RESULT();
50321 } else {
50322 HashTable *ht = zend_new_array(8);
50323 uint8_t old_type = Z_TYPE_P(object_ptr);
50324
50325 ZVAL_ARR(object_ptr, ht);
50326 if (UNEXPECTED(old_type == IS_FALSE)) {
50327 GC_ADDREF(ht);
50328 zend_false_to_array_deprecated();
50329 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50330 zend_array_destroy(ht);
50331 goto assign_dim_error;
50332 }
50333 }
50334 goto try_assign_dim_array;
50335 }
50336 } else {
50337 zend_use_scalar_as_array();
50338 dim = NULL;
50339 assign_dim_error:
50340 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
50341 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50342 ZVAL_NULL(EX_VAR(opline->result.var));
50343 }
50344 }
50345 }
50346 if (IS_UNUSED != IS_UNUSED) {
50347
50348 }
50349
50350 /* assign_dim has two opcodes! */
50351 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50352 }
50353
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50354 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50355 {
50356 USE_OPLINE
50357 zval *object_ptr, *orig_object_ptr;
50358 zval *value;
50359 zval *variable_ptr;
50360 zval *dim;
50361 zend_refcounted *garbage = NULL;
50362
50363 SAVE_OPLINE();
50364 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
50365
50366 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50367 try_assign_dim_array:
50368 SEPARATE_ARRAY(object_ptr);
50369 if (IS_UNUSED == IS_UNUSED) {
50370 value = EX_VAR((opline+1)->op1.var);
50371 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
50372 HashTable *ht = Z_ARRVAL_P(object_ptr);
50373 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
50374 GC_ADDREF(ht);
50375 }
50376 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50377 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50378 zend_array_destroy(ht);
50379 goto assign_dim_error;
50380 }
50381 }
50382 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
50383 ZVAL_DEREF(value);
50384 }
50385 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
50386 if (UNEXPECTED(value == NULL)) {
50387 zend_cannot_add_element();
50388 goto assign_dim_error;
50389 } else if (IS_CV == IS_CV) {
50390 if (Z_REFCOUNTED_P(value)) {
50391 Z_ADDREF_P(value);
50392 }
50393 } else if (IS_CV == IS_VAR) {
50394 zval *free_op_data = EX_VAR((opline+1)->op1.var);
50395 if (Z_ISREF_P(free_op_data)) {
50396 if (Z_REFCOUNTED_P(value)) {
50397 Z_ADDREF_P(value);
50398 }
50399 zval_ptr_dtor_nogc(free_op_data);
50400 }
50401 } else if (IS_CV == IS_CONST) {
50402 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
50403 Z_ADDREF_P(value);
50404 }
50405 }
50406 } else {
50407 dim = NULL;
50408 if (IS_UNUSED == IS_CONST) {
50409 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50410 } else {
50411 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
50412 }
50413 if (UNEXPECTED(variable_ptr == NULL)) {
50414 goto assign_dim_error;
50415 }
50416 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
50417 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
50418 }
50419 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50420 ZVAL_COPY(EX_VAR(opline->result.var), value);
50421 }
50422 if (garbage) {
50423 GC_DTOR_NO_REF(garbage);
50424 }
50425 } else {
50426 if (EXPECTED(Z_ISREF_P(object_ptr))) {
50427 object_ptr = Z_REFVAL_P(object_ptr);
50428 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
50429 goto try_assign_dim_array;
50430 }
50431 }
50432 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
50433 zend_object *obj = Z_OBJ_P(object_ptr);
50434
50435 GC_ADDREF(obj);
50436 dim = NULL;
50437 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
50438 dim = ZVAL_UNDEFINED_OP2();
50439 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50440 dim++;
50441 }
50442
50443 value = EX_VAR((opline+1)->op1.var);
50444 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
50445 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
50446 } else if (IS_CV & (IS_CV|IS_VAR)) {
50447 ZVAL_DEREF(value);
50448 }
50449
50450 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
50451
50452 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
50453 zend_objects_store_del(obj);
50454 }
50455 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
50456 if (IS_UNUSED == IS_UNUSED) {
50457 zend_use_new_element_for_string();
50458
50459 UNDEF_RESULT();
50460 } else {
50461 dim = NULL;
50462 value = EX_VAR((opline+1)->op1.var);
50463 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
50464
50465 }
50466 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
50467 if (Z_ISREF_P(orig_object_ptr)
50468 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
50469 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
50470 dim = NULL;
50471
50472 UNDEF_RESULT();
50473 } else {
50474 HashTable *ht = zend_new_array(8);
50475 uint8_t old_type = Z_TYPE_P(object_ptr);
50476
50477 ZVAL_ARR(object_ptr, ht);
50478 if (UNEXPECTED(old_type == IS_FALSE)) {
50479 GC_ADDREF(ht);
50480 zend_false_to_array_deprecated();
50481 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50482 zend_array_destroy(ht);
50483 goto assign_dim_error;
50484 }
50485 }
50486 goto try_assign_dim_array;
50487 }
50488 } else {
50489 zend_use_scalar_as_array();
50490 dim = NULL;
50491 assign_dim_error:
50492
50493 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50494 ZVAL_NULL(EX_VAR(opline->result.var));
50495 }
50496 }
50497 }
50498 if (IS_UNUSED != IS_UNUSED) {
50499
50500 }
50501
50502 /* assign_dim has two opcodes! */
50503 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50504 }
50505
ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50506 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50507 {
50508 if (IS_CV == IS_UNUSED) {
50509 SAVE_OPLINE();
50510 zend_verify_missing_return_type(EX(func));
50511 HANDLE_EXCEPTION();
50512 } else {
50513 /* prevents "undefined variable opline" errors */
50514 #if 0 || (IS_CV != IS_UNUSED)
50515 USE_OPLINE
50516 zval *retval_ref, *retval_ptr;
50517 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
50518 retval_ref = retval_ptr = EX_VAR(opline->op1.var);
50519
50520 if (IS_CV == IS_CONST) {
50521 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
50522 retval_ref = retval_ptr = EX_VAR(opline->result.var);
50523 } else if (IS_CV == IS_VAR) {
50524 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
50525 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
50526 }
50527 ZVAL_DEREF(retval_ptr);
50528 } else if (IS_CV == IS_CV) {
50529 ZVAL_DEREF(retval_ptr);
50530 }
50531
50532 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
50533 ZEND_VM_NEXT_OPCODE();
50534 }
50535
50536 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
50537 SAVE_OPLINE();
50538 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
50539 if (UNEXPECTED(EG(exception))) {
50540 HANDLE_EXCEPTION();
50541 }
50542 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
50543 ZEND_VM_NEXT_OPCODE();
50544 }
50545 }
50546
50547 zend_reference *ref = NULL;
50548 void *cache_slot = CACHE_ADDR(opline->op2.num);
50549 if (UNEXPECTED(retval_ref != retval_ptr)) {
50550 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
50551 ref = Z_REF_P(retval_ref);
50552 } else {
50553 /* A cast might happen - unwrap the reference if this is a by-value return */
50554 if (Z_REFCOUNT_P(retval_ref) == 1) {
50555 ZVAL_UNREF(retval_ref);
50556 } else {
50557 Z_DELREF_P(retval_ref);
50558 ZVAL_COPY(retval_ref, retval_ptr);
50559 }
50560 retval_ptr = retval_ref;
50561 }
50562 }
50563
50564 SAVE_OPLINE();
50565 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
50566 zend_verify_return_error(EX(func), retval_ptr);
50567 HANDLE_EXCEPTION();
50568 }
50569 ZEND_VM_NEXT_OPCODE();
50570 #endif
50571 }
50572 }
50573
ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50574 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50575 {
50576 USE_OPLINE
50577 zval *varptr, *arg;
50578
50579 if (IS_UNUSED == IS_CONST) {
50580 SAVE_OPLINE();
50581 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50582 uint32_t arg_num;
50583 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50584 if (UNEXPECTED(!arg)) {
50585
50586 HANDLE_EXCEPTION();
50587 }
50588 } else {
50589 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50590 }
50591
50592 varptr = EX_VAR(opline->op1.var);
50593 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50594 SAVE_OPLINE();
50595 ZVAL_UNDEFINED_OP1();
50596 ZVAL_NULL(arg);
50597 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50598 }
50599
50600 if (IS_CV == IS_CV) {
50601 ZVAL_COPY_DEREF(arg, varptr);
50602 } else /* if (IS_CV == IS_VAR) */ {
50603 if (UNEXPECTED(Z_ISREF_P(varptr))) {
50604 zend_refcounted *ref = Z_COUNTED_P(varptr);
50605
50606 varptr = Z_REFVAL_P(varptr);
50607 ZVAL_COPY_VALUE(arg, varptr);
50608 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50609 efree_size(ref, sizeof(zend_reference));
50610 } else if (Z_OPT_REFCOUNTED_P(arg)) {
50611 Z_ADDREF_P(arg);
50612 }
50613 } else {
50614 ZVAL_COPY_VALUE(arg, varptr);
50615 }
50616 }
50617
50618 ZEND_VM_NEXT_OPCODE();
50619 }
50620
ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50621 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50622 {
50623 USE_OPLINE
50624 zval *varptr, *arg;
50625
50626 SAVE_OPLINE();
50627 if (IS_UNUSED == IS_CONST) {
50628 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50629 uint32_t arg_num;
50630 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50631 if (UNEXPECTED(!arg)) {
50632
50633 HANDLE_EXCEPTION();
50634 }
50635 } else {
50636 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50637 }
50638
50639 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50640 if (Z_ISREF_P(varptr)) {
50641 Z_ADDREF_P(varptr);
50642 } else {
50643 ZVAL_MAKE_REF_EX(varptr, 2);
50644 }
50645 ZVAL_REF(arg, Z_REF_P(varptr));
50646
50647 ZEND_VM_NEXT_OPCODE();
50648 }
50649
ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50650 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50651 {
50652 USE_OPLINE
50653 zval *varptr, *arg;
50654 uint32_t arg_num;
50655
50656 if (IS_UNUSED == IS_CONST) {
50657 SAVE_OPLINE();
50658 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50659 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50660 if (UNEXPECTED(!arg)) {
50661
50662 HANDLE_EXCEPTION();
50663 }
50664 } else {
50665 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50666 arg_num = opline->op2.num;
50667 }
50668
50669 if (EXPECTED(0)) {
50670 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50671 goto send_var_by_ref;
50672 }
50673 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50674 send_var_by_ref:
50675 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50676 if (Z_ISREF_P(varptr)) {
50677 Z_ADDREF_P(varptr);
50678 } else {
50679 ZVAL_MAKE_REF_EX(varptr, 2);
50680 }
50681 ZVAL_REF(arg, Z_REF_P(varptr));
50682
50683 ZEND_VM_NEXT_OPCODE();
50684 }
50685
50686 varptr = EX_VAR(opline->op1.var);
50687 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50688 SAVE_OPLINE();
50689 ZVAL_UNDEFINED_OP1();
50690 ZVAL_NULL(arg);
50691 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50692 }
50693
50694 if (IS_CV == IS_CV) {
50695 ZVAL_COPY_DEREF(arg, varptr);
50696 } else /* if (IS_CV == IS_VAR) */ {
50697 if (UNEXPECTED(Z_ISREF_P(varptr))) {
50698 zend_refcounted *ref = Z_COUNTED_P(varptr);
50699
50700 varptr = Z_REFVAL_P(varptr);
50701 ZVAL_COPY_VALUE(arg, varptr);
50702 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50703 efree_size(ref, sizeof(zend_reference));
50704 } else if (Z_OPT_REFCOUNTED_P(arg)) {
50705 Z_ADDREF_P(arg);
50706 }
50707 } else {
50708 ZVAL_COPY_VALUE(arg, varptr);
50709 }
50710 }
50711
50712 ZEND_VM_NEXT_OPCODE();
50713 }
50714
ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50715 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50716 {
50717 USE_OPLINE
50718 zval *varptr, *arg;
50719 uint32_t arg_num;
50720
50721 if (IS_UNUSED == IS_CONST) {
50722 SAVE_OPLINE();
50723 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
50724 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
50725 if (UNEXPECTED(!arg)) {
50726
50727 HANDLE_EXCEPTION();
50728 }
50729 } else {
50730 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50731 arg_num = opline->op2.num;
50732 }
50733
50734 if (EXPECTED(1)) {
50735 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50736 goto send_var_by_ref;
50737 }
50738 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50739 send_var_by_ref:
50740 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50741 if (Z_ISREF_P(varptr)) {
50742 Z_ADDREF_P(varptr);
50743 } else {
50744 ZVAL_MAKE_REF_EX(varptr, 2);
50745 }
50746 ZVAL_REF(arg, Z_REF_P(varptr));
50747
50748 ZEND_VM_NEXT_OPCODE();
50749 }
50750
50751 varptr = EX_VAR(opline->op1.var);
50752 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
50753 SAVE_OPLINE();
50754 ZVAL_UNDEFINED_OP1();
50755 ZVAL_NULL(arg);
50756 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50757 }
50758
50759 if (IS_CV == IS_CV) {
50760 ZVAL_COPY_DEREF(arg, varptr);
50761 } else /* if (IS_CV == IS_VAR) */ {
50762 if (UNEXPECTED(Z_ISREF_P(varptr))) {
50763 zend_refcounted *ref = Z_COUNTED_P(varptr);
50764
50765 varptr = Z_REFVAL_P(varptr);
50766 ZVAL_COPY_VALUE(arg, varptr);
50767 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50768 efree_size(ref, sizeof(zend_reference));
50769 } else if (Z_OPT_REFCOUNTED_P(arg)) {
50770 Z_ADDREF_P(arg);
50771 }
50772 } else {
50773 ZVAL_COPY_VALUE(arg, varptr);
50774 }
50775 }
50776
50777 ZEND_VM_NEXT_OPCODE();
50778 }
50779
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50780 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50781 {
50782 USE_OPLINE
50783 zval *expr_ptr, new_expr;
50784
50785 SAVE_OPLINE();
50786 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
50787 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
50788 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
50789 if (Z_ISREF_P(expr_ptr)) {
50790 Z_ADDREF_P(expr_ptr);
50791 } else {
50792 ZVAL_MAKE_REF_EX(expr_ptr, 2);
50793 }
50794
50795 } else {
50796 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50797 if (IS_CV == IS_TMP_VAR) {
50798 /* pass */
50799 } else if (IS_CV == IS_CONST) {
50800 Z_TRY_ADDREF_P(expr_ptr);
50801 } else if (IS_CV == IS_CV) {
50802 ZVAL_DEREF(expr_ptr);
50803 Z_TRY_ADDREF_P(expr_ptr);
50804 } else /* if (IS_CV == IS_VAR) */ {
50805 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
50806 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
50807
50808 expr_ptr = Z_REFVAL_P(expr_ptr);
50809 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
50810 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
50811 expr_ptr = &new_expr;
50812 efree_size(ref, sizeof(zend_reference));
50813 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
50814 Z_ADDREF_P(expr_ptr);
50815 }
50816 }
50817 }
50818 }
50819
50820 if (IS_UNUSED != IS_UNUSED) {
50821 zval *offset = NULL;
50822 zend_string *str;
50823 zend_ulong hval;
50824
50825 add_again:
50826 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
50827 str = Z_STR_P(offset);
50828 if (IS_UNUSED != IS_CONST) {
50829 if (ZEND_HANDLE_NUMERIC(str, hval)) {
50830 goto num_index;
50831 }
50832 }
50833 str_index:
50834 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
50835 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
50836 hval = Z_LVAL_P(offset);
50837 num_index:
50838 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
50839 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
50840 offset = Z_REFVAL_P(offset);
50841 goto add_again;
50842 } else if (Z_TYPE_P(offset) == IS_NULL) {
50843 str = ZSTR_EMPTY_ALLOC();
50844 goto str_index;
50845 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
50846 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
50847 goto num_index;
50848 } else if (Z_TYPE_P(offset) == IS_FALSE) {
50849 hval = 0;
50850 goto num_index;
50851 } else if (Z_TYPE_P(offset) == IS_TRUE) {
50852 hval = 1;
50853 goto num_index;
50854 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
50855 zend_use_resource_as_offset(offset);
50856 hval = Z_RES_HANDLE_P(offset);
50857 goto num_index;
50858 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
50859 ZVAL_UNDEFINED_OP2();
50860 str = ZSTR_EMPTY_ALLOC();
50861 goto str_index;
50862 } else {
50863 zend_illegal_array_offset_access(offset);
50864 zval_ptr_dtor_nogc(expr_ptr);
50865 }
50866
50867 } else {
50868 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
50869 zend_cannot_add_element();
50870 zval_ptr_dtor_nogc(expr_ptr);
50871 }
50872 }
50873 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50874 }
50875
ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50876 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50877 {
50878 zval *array;
50879 uint32_t size;
50880 USE_OPLINE
50881
50882 array = EX_VAR(opline->result.var);
50883 if (IS_CV != IS_UNUSED) {
50884 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
50885 ZVAL_ARR(array, zend_new_array(size));
50886 /* Explicitly initialize array as not-packed if flag is set */
50887 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
50888 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
50889 }
50890 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50891 } else {
50892 ZVAL_ARR(array, zend_new_array(0));
50893 ZEND_VM_NEXT_OPCODE();
50894 }
50895 }
50896
ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50897 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50898 {
50899 USE_OPLINE
50900 zval *var = EX_VAR(opline->op1.var);
50901
50902 if (Z_REFCOUNTED_P(var)) {
50903 zend_refcounted *garbage = Z_COUNTED_P(var);
50904
50905 ZVAL_UNDEF(var);
50906 SAVE_OPLINE();
50907 GC_DTOR(garbage);
50908 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50909 } else {
50910 ZVAL_UNDEF(var);
50911 }
50912 ZEND_VM_NEXT_OPCODE();
50913 }
50914
ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50915 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50916 {
50917 USE_OPLINE
50918 zval *varname;
50919 zend_string *name, *tmp_name;
50920 HashTable *target_symbol_table;
50921
50922 SAVE_OPLINE();
50923
50924 varname = EX_VAR(opline->op1.var);
50925
50926 if (IS_CV == IS_CONST) {
50927 name = Z_STR_P(varname);
50928 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
50929 name = Z_STR_P(varname);
50930 tmp_name = NULL;
50931 } else {
50932 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
50933 varname = ZVAL_UNDEFINED_OP1();
50934 }
50935 name = zval_try_get_tmp_string(varname, &tmp_name);
50936 if (UNEXPECTED(!name)) {
50937
50938 HANDLE_EXCEPTION();
50939 }
50940 }
50941
50942 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
50943 zend_hash_del_ind(target_symbol_table, name);
50944
50945 if (IS_CV != IS_CONST) {
50946 zend_tmp_string_release(tmp_name);
50947 }
50948
50949 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50950 }
50951
50952 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50953 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50954 {
50955 USE_OPLINE
50956 zval *value;
50957
50958 value = EX_VAR(opline->op1.var);
50959 if (!(0)) {
50960 if (Z_TYPE_P(value) > IS_NULL &&
50961 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
50962 ZEND_VM_SMART_BRANCH_TRUE();
50963 } else {
50964 ZEND_VM_SMART_BRANCH_FALSE();
50965 }
50966 } else {
50967 bool result;
50968
50969 SAVE_OPLINE();
50970 result = !i_zend_is_true(value);
50971 ZEND_VM_SMART_BRANCH(result, 1);
50972 }
50973 }
50974
ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50975 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50976 {
50977 USE_OPLINE
50978 zval *value;
50979
50980 value = EX_VAR(opline->op1.var);
50981 if (!(1)) {
50982 if (Z_TYPE_P(value) > IS_NULL &&
50983 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
50984 ZEND_VM_SMART_BRANCH_TRUE();
50985 } else {
50986 ZEND_VM_SMART_BRANCH_FALSE();
50987 }
50988 } else {
50989 bool result;
50990
50991 SAVE_OPLINE();
50992 result = !i_zend_is_true(value);
50993 ZEND_VM_SMART_BRANCH(result, 1);
50994 }
50995 }
50996
ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50997 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50998 {
50999 USE_OPLINE
51000 zval *value;
51001 bool result;
51002 zval *varname;
51003 zend_string *name, *tmp_name;
51004 HashTable *target_symbol_table;
51005
51006 SAVE_OPLINE();
51007 varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
51008 if (IS_CV == IS_CONST) {
51009 name = Z_STR_P(varname);
51010 } else {
51011 name = zval_get_tmp_string(varname, &tmp_name);
51012 }
51013
51014 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
51015 value = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
51016
51017 if (IS_CV != IS_CONST) {
51018 zend_tmp_string_release(tmp_name);
51019 }
51020
51021 if (!value) {
51022 result = (opline->extended_value & ZEND_ISEMPTY);
51023 } else {
51024 if (Z_TYPE_P(value) == IS_INDIRECT) {
51025 value = Z_INDIRECT_P(value);
51026 }
51027 if (!(opline->extended_value & ZEND_ISEMPTY)) {
51028 if (Z_ISREF_P(value)) {
51029 value = Z_REFVAL_P(value);
51030 }
51031 result = Z_TYPE_P(value) > IS_NULL;
51032 } else {
51033 result = !i_zend_is_true(value);
51034 }
51035 }
51036
51037 ZEND_VM_SMART_BRANCH(result, true);
51038 }
51039
51040 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51041 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51042 {
51043 USE_OPLINE
51044 zval *expr;
51045 bool result;
51046
51047 SAVE_OPLINE();
51048 expr = EX_VAR(opline->op1.var);
51049
51050 try_instanceof:
51051 if (Z_TYPE_P(expr) == IS_OBJECT) {
51052 zend_class_entry *ce;
51053
51054 if (IS_UNUSED == IS_CONST) {
51055 ce = CACHED_PTR(opline->extended_value);
51056 if (UNEXPECTED(ce == NULL)) {
51057 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);
51058 if (EXPECTED(ce)) {
51059 CACHE_PTR(opline->extended_value, ce);
51060 }
51061 }
51062 } else if (IS_UNUSED == IS_UNUSED) {
51063 ce = zend_fetch_class(NULL, opline->op2.num);
51064 if (UNEXPECTED(ce == NULL)) {
51065
51066 ZVAL_UNDEF(EX_VAR(opline->result.var));
51067 HANDLE_EXCEPTION();
51068 }
51069 } else {
51070 ce = Z_CE_P(EX_VAR(opline->op2.var));
51071 }
51072 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
51073 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
51074 expr = Z_REFVAL_P(expr);
51075 goto try_instanceof;
51076 } else {
51077 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
51078 ZVAL_UNDEFINED_OP1();
51079 }
51080 result = 0;
51081 }
51082
51083 ZEND_VM_SMART_BRANCH(result, 1);
51084 }
51085
ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51086 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51087 {
51088 USE_OPLINE
51089
51090 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
51091
51092 SAVE_OPLINE();
51093 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
51094 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51095 }
51096
51097 /* Destroy the previously yielded value */
51098 zval_ptr_dtor(&generator->value);
51099
51100 /* Destroy the previously yielded key */
51101 zval_ptr_dtor(&generator->key);
51102
51103 /* Set the new yielded value */
51104 if (IS_CV != IS_UNUSED) {
51105 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
51106 /* Constants and temporary variables aren't yieldable by reference,
51107 * but we still allow them with a notice. */
51108 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
51109 zval *value;
51110
51111 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
51112
51113 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51114 ZVAL_COPY_VALUE(&generator->value, value);
51115 if (IS_CV == IS_CONST) {
51116 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
51117 Z_ADDREF(generator->value);
51118 }
51119 }
51120 } else {
51121 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
51122
51123 /* If a function call result is yielded and the function did
51124 * not return by reference we throw a notice. */
51125 do {
51126 if (IS_CV == IS_VAR) {
51127 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
51128 if (opline->extended_value == ZEND_RETURNS_FUNCTION
51129 && !Z_ISREF_P(value_ptr)) {
51130 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
51131 ZVAL_COPY(&generator->value, value_ptr);
51132 break;
51133 }
51134 }
51135 if (Z_ISREF_P(value_ptr)) {
51136 Z_ADDREF_P(value_ptr);
51137 } else {
51138 ZVAL_MAKE_REF_EX(value_ptr, 2);
51139 }
51140 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
51141 } while (0);
51142
51143 }
51144 } else {
51145 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51146
51147 /* Consts, temporary variables and references need copying */
51148 if (IS_CV == IS_CONST) {
51149 ZVAL_COPY_VALUE(&generator->value, value);
51150 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
51151 Z_ADDREF(generator->value);
51152 }
51153 } else if (IS_CV == IS_TMP_VAR) {
51154 ZVAL_COPY_VALUE(&generator->value, value);
51155 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
51156 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
51157
51158 } else {
51159 ZVAL_COPY_VALUE(&generator->value, value);
51160 if (IS_CV == IS_CV) {
51161 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
51162 }
51163 }
51164 }
51165 } else {
51166 /* If no value was specified yield null */
51167 ZVAL_NULL(&generator->value);
51168 }
51169
51170 /* Set the new yielded key */
51171 if (IS_UNUSED != IS_UNUSED) {
51172 zval *key = NULL;
51173 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
51174 key = Z_REFVAL_P(key);
51175 }
51176 ZVAL_COPY(&generator->key, key);
51177
51178 if (Z_TYPE(generator->key) == IS_LONG
51179 && Z_LVAL(generator->key) > generator->largest_used_integer_key
51180 ) {
51181 generator->largest_used_integer_key = Z_LVAL(generator->key);
51182 }
51183 } else {
51184 /* If no key was specified we use auto-increment keys */
51185 generator->largest_used_integer_key++;
51186 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
51187 }
51188
51189 if (RETURN_VALUE_USED(opline)) {
51190 /* If the return value of yield is used set the send
51191 * target and initialize it to NULL */
51192 generator->send_target = EX_VAR(opline->result.var);
51193 ZVAL_NULL(generator->send_target);
51194 } else {
51195 generator->send_target = NULL;
51196 }
51197
51198 /* The GOTO VM uses a local opline variable. We need to set the opline
51199 * variable in execute_data so we don't resume at an old position. */
51200 SAVE_OPLINE();
51201
51202 ZEND_VM_RETURN();
51203 }
51204
ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51205 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51206 {
51207 USE_OPLINE
51208 zval *op1 = EX_VAR(opline->op1.var);
51209
51210 if (UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
51211 SAVE_OPLINE();
51212 ZVAL_UNDEFINED_OP1();
51213 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51214 }
51215 ZEND_VM_NEXT_OPCODE();
51216 }
51217
ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51218 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51219 {
51220 USE_OPLINE
51221 zval *op1 = EX_VAR(opline->op1.var);
51222
51223 if (IS_CV == IS_CV) {
51224 if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51225 ZVAL_NEW_EMPTY_REF(op1);
51226 Z_SET_REFCOUNT_P(op1, 2);
51227 ZVAL_NULL(Z_REFVAL_P(op1));
51228 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51229 } else {
51230 if (Z_ISREF_P(op1)) {
51231 Z_ADDREF_P(op1);
51232 } else {
51233 ZVAL_MAKE_REF_EX(op1, 2);
51234 }
51235 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51236 }
51237 } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
51238 op1 = Z_INDIRECT_P(op1);
51239 if (EXPECTED(!Z_ISREF_P(op1))) {
51240 ZVAL_MAKE_REF_EX(op1, 2);
51241 } else {
51242 GC_ADDREF(Z_REF_P(op1));
51243 }
51244 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
51245 } else {
51246 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
51247 }
51248 ZEND_VM_NEXT_OPCODE();
51249 }
51250
ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51251 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51252 {
51253 USE_OPLINE
51254 zval *op1;
51255 zend_long count;
51256
51257 SAVE_OPLINE();
51258 op1 = EX_VAR(opline->op1.var);
51259
51260 while (1) {
51261 if (Z_TYPE_P(op1) == IS_ARRAY) {
51262 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
51263 break;
51264 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
51265 zend_object *zobj = Z_OBJ_P(op1);
51266
51267 /* first, we check if the handler is defined */
51268 if (zobj->handlers->count_elements) {
51269 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
51270 break;
51271 }
51272 if (UNEXPECTED(EG(exception))) {
51273 count = 0;
51274 break;
51275 }
51276 }
51277
51278 /* if not and the object implements Countable we call its count() method */
51279 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
51280 zval retval;
51281
51282 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
51283 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
51284 count = zval_get_long(&retval);
51285 zval_ptr_dtor(&retval);
51286 break;
51287 }
51288
51289 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
51290 } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
51291 op1 = Z_REFVAL_P(op1);
51292 continue;
51293 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51294 ZVAL_UNDEFINED_OP1();
51295 }
51296 count = 0;
51297 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));
51298 break;
51299 }
51300
51301 ZVAL_LONG(EX_VAR(opline->result.var), count);
51302
51303 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51304 }
51305
ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51306 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51307 {
51308 USE_OPLINE
51309 zend_array *ht = Z_ARRVAL_P(EX_VAR(opline->op1.var));
51310 ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
51311 if (IS_CV & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
51312 SAVE_OPLINE();
51313 zend_array_destroy(ht);
51314 if (EG(exception)) {
51315 HANDLE_EXCEPTION();
51316 }
51317 }
51318 ZEND_VM_NEXT_OPCODE();
51319 }
51320
ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51321 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51322 {
51323 USE_OPLINE
51324
51325 if (IS_CV == IS_UNUSED) {
51326 SAVE_OPLINE();
51327 if (UNEXPECTED(!EX(func)->common.scope)) {
51328 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
51329 ZVAL_UNDEF(EX_VAR(opline->result.var));
51330 HANDLE_EXCEPTION();
51331 } else {
51332 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
51333 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
51334 if (UNEXPECTED(EG(exception))) {
51335 HANDLE_EXCEPTION();
51336 }
51337 ZEND_VM_NEXT_OPCODE();
51338 }
51339 } else {
51340 zval *op1;
51341
51342 SAVE_OPLINE();
51343 op1 = EX_VAR(opline->op1.var);
51344 while (1) {
51345 if (Z_TYPE_P(op1) == IS_OBJECT) {
51346 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
51347 } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
51348 op1 = Z_REFVAL_P(op1);
51349 continue;
51350 } else {
51351 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51352 ZVAL_UNDEFINED_OP1();
51353 }
51354 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
51355 ZVAL_UNDEF(EX_VAR(opline->result.var));
51356 }
51357 break;
51358 }
51359
51360 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51361 }
51362 }
51363
ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51364 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51365 {
51366 USE_OPLINE
51367 zval *op1;
51368 zend_string *type;
51369
51370 SAVE_OPLINE();
51371 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51372 type = zend_zval_get_legacy_type(op1);
51373 if (EXPECTED(type)) {
51374 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
51375 } else {
51376 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
51377 }
51378
51379 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51380 }
51381
ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51382 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51383 {
51384 USE_OPLINE
51385 zval *varptr, *arg;
51386 uint32_t arg_num = opline->op2.num;
51387
51388 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
51389 ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51390 }
51391
51392 varptr = EX_VAR(opline->op1.var);
51393 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
51394
51395 if (IS_CV == IS_CV) {
51396 ZVAL_COPY(arg, varptr);
51397 } else /* if (IS_CV == IS_VAR) */ {
51398 ZVAL_COPY_VALUE(arg, varptr);
51399 }
51400
51401 ZEND_VM_NEXT_OPCODE();
51402 }
51403
ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51404 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51405 {
51406 USE_OPLINE
51407 zval *op1, *op2;
51408
51409 SAVE_OPLINE();
51410 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51411 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51412 div_function(EX_VAR(opline->result.var), op1, op2);
51413
51414
51415 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51416 }
51417
ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51418 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51419 {
51420 USE_OPLINE
51421 zval *op1, *op2;
51422
51423 SAVE_OPLINE();
51424 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51425 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51426 pow_function(EX_VAR(opline->result.var), op1, op2);
51427
51428
51429 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51430 }
51431
ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51432 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51433 {
51434 USE_OPLINE
51435 zval *op1, *op2;
51436
51437 op1 = EX_VAR(opline->op1.var);
51438 op2 = EX_VAR(opline->op2.var);
51439
51440 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
51441 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
51442 zend_string *op1_str = Z_STR_P(op1);
51443 zend_string *op2_str = Z_STR_P(op2);
51444 zend_string *str;
51445 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
51446
51447 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
51448 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
51449 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
51450 } else {
51451 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
51452 }
51453 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51454 zend_string_release_ex(op1_str, 0);
51455 }
51456 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
51457 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
51458 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
51459 } else {
51460 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
51461 }
51462 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51463 zend_string_release_ex(op2_str, 0);
51464 }
51465 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
51466 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
51467 size_t len = ZSTR_LEN(op1_str);
51468
51469 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
51470 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
51471 }
51472 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
51473 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
51474 GC_ADD_FLAGS(str, flags);
51475 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
51476 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51477 zend_string_release_ex(op2_str, 0);
51478 }
51479 } else {
51480 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
51481 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
51482 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
51483 GC_ADD_FLAGS(str, flags);
51484 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
51485 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51486 zend_string_release_ex(op1_str, 0);
51487 }
51488 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51489 zend_string_release_ex(op2_str, 0);
51490 }
51491 }
51492 ZEND_VM_NEXT_OPCODE();
51493 } else {
51494 SAVE_OPLINE();
51495
51496 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
51497 op1 = ZVAL_UNDEFINED_OP1();
51498 }
51499 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
51500 op2 = ZVAL_UNDEFINED_OP2();
51501 }
51502 concat_function(EX_VAR(opline->result.var), op1, op2);
51503
51504
51505 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51506 }
51507 }
51508
ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51509 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51510 {
51511 USE_OPLINE
51512 zval *op1, *op2;
51513 bool result;
51514
51515 SAVE_OPLINE();
51516 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51517 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51518 result = fast_is_identical_function(op1, op2);
51519
51520
51521 ZEND_VM_SMART_BRANCH(result, 1);
51522 }
51523
ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51524 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51525 {
51526 USE_OPLINE
51527 zval *op1, *op2;
51528 bool result;
51529
51530 SAVE_OPLINE();
51531 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51532 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51533 result = fast_is_not_identical_function(op1, op2);
51534
51535
51536 ZEND_VM_SMART_BRANCH(result, 1);
51537 }
51538
ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51539 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51540 {
51541 USE_OPLINE
51542 zval *op1, *op2;
51543 double d1, d2;
51544
51545 op1 = EX_VAR(opline->op1.var);
51546 op2 = EX_VAR(opline->op2.var);
51547 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51548 /* pass */
51549 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51550 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51551 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51552 is_equal_true:
51553 ZEND_VM_SMART_BRANCH_TRUE_NONE();
51554 } else {
51555 is_equal_false:
51556 ZEND_VM_SMART_BRANCH_FALSE_NONE();
51557 }
51558 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51559 d1 = (double)Z_LVAL_P(op1);
51560 d2 = Z_DVAL_P(op2);
51561 goto is_equal_double;
51562 }
51563 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51564 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51565 d1 = Z_DVAL_P(op1);
51566 d2 = Z_DVAL_P(op2);
51567 is_equal_double:
51568 if (d1 == d2) {
51569 goto is_equal_true;
51570 } else {
51571 goto is_equal_false;
51572 }
51573 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51574 d1 = Z_DVAL_P(op1);
51575 d2 = (double)Z_LVAL_P(op2);
51576 goto is_equal_double;
51577 }
51578 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51579 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51580 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51581 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51582 zval_ptr_dtor_str(op1);
51583 }
51584 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51585 zval_ptr_dtor_str(op2);
51586 }
51587 if (result) {
51588 goto is_equal_true;
51589 } else {
51590 goto is_equal_false;
51591 }
51592 }
51593 }
51594 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51595 }
51596
ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51597 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51598 {
51599 USE_OPLINE
51600 zval *op1, *op2;
51601 double d1, d2;
51602
51603 op1 = EX_VAR(opline->op1.var);
51604 op2 = EX_VAR(opline->op2.var);
51605 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51606 /* pass */
51607 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51608 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51609 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51610 is_equal_true:
51611 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
51612 } else {
51613 is_equal_false:
51614 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
51615 }
51616 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51617 d1 = (double)Z_LVAL_P(op1);
51618 d2 = Z_DVAL_P(op2);
51619 goto is_equal_double;
51620 }
51621 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51622 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51623 d1 = Z_DVAL_P(op1);
51624 d2 = Z_DVAL_P(op2);
51625 is_equal_double:
51626 if (d1 == d2) {
51627 goto is_equal_true;
51628 } else {
51629 goto is_equal_false;
51630 }
51631 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51632 d1 = Z_DVAL_P(op1);
51633 d2 = (double)Z_LVAL_P(op2);
51634 goto is_equal_double;
51635 }
51636 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51637 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51638 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51639 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51640 zval_ptr_dtor_str(op1);
51641 }
51642 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51643 zval_ptr_dtor_str(op2);
51644 }
51645 if (result) {
51646 goto is_equal_true;
51647 } else {
51648 goto is_equal_false;
51649 }
51650 }
51651 }
51652 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51653 }
51654
ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51655 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51656 {
51657 USE_OPLINE
51658 zval *op1, *op2;
51659 double d1, d2;
51660
51661 op1 = EX_VAR(opline->op1.var);
51662 op2 = EX_VAR(opline->op2.var);
51663 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51664 /* pass */
51665 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51666 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51667 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
51668 is_equal_true:
51669 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
51670 } else {
51671 is_equal_false:
51672 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
51673 }
51674 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51675 d1 = (double)Z_LVAL_P(op1);
51676 d2 = Z_DVAL_P(op2);
51677 goto is_equal_double;
51678 }
51679 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51680 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51681 d1 = Z_DVAL_P(op1);
51682 d2 = Z_DVAL_P(op2);
51683 is_equal_double:
51684 if (d1 == d2) {
51685 goto is_equal_true;
51686 } else {
51687 goto is_equal_false;
51688 }
51689 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51690 d1 = Z_DVAL_P(op1);
51691 d2 = (double)Z_LVAL_P(op2);
51692 goto is_equal_double;
51693 }
51694 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51695 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51696 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51697 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51698 zval_ptr_dtor_str(op1);
51699 }
51700 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51701 zval_ptr_dtor_str(op2);
51702 }
51703 if (result) {
51704 goto is_equal_true;
51705 } else {
51706 goto is_equal_false;
51707 }
51708 }
51709 }
51710 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51711 }
51712
ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51713 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51714 {
51715 USE_OPLINE
51716 zval *op1, *op2;
51717 double d1, d2;
51718
51719 op1 = EX_VAR(opline->op1.var);
51720 op2 = EX_VAR(opline->op2.var);
51721 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51722 /* pass */
51723 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51724 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51725 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51726 is_not_equal_true:
51727 ZEND_VM_SMART_BRANCH_TRUE_NONE();
51728 } else {
51729 is_not_equal_false:
51730 ZEND_VM_SMART_BRANCH_FALSE_NONE();
51731 }
51732 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51733 d1 = (double)Z_LVAL_P(op1);
51734 d2 = Z_DVAL_P(op2);
51735 goto is_not_equal_double;
51736 }
51737 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51738 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51739 d1 = Z_DVAL_P(op1);
51740 d2 = Z_DVAL_P(op2);
51741 is_not_equal_double:
51742 if (d1 != d2) {
51743 goto is_not_equal_true;
51744 } else {
51745 goto is_not_equal_false;
51746 }
51747 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51748 d1 = Z_DVAL_P(op1);
51749 d2 = (double)Z_LVAL_P(op2);
51750 goto is_not_equal_double;
51751 }
51752 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51753 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51754 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51755 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51756 zval_ptr_dtor_str(op1);
51757 }
51758 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51759 zval_ptr_dtor_str(op2);
51760 }
51761 if (!result) {
51762 goto is_not_equal_true;
51763 } else {
51764 goto is_not_equal_false;
51765 }
51766 }
51767 }
51768 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51769 }
51770
ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51771 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51772 {
51773 USE_OPLINE
51774 zval *op1, *op2;
51775 double d1, d2;
51776
51777 op1 = EX_VAR(opline->op1.var);
51778 op2 = EX_VAR(opline->op2.var);
51779 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51780 /* pass */
51781 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51782 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51783 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51784 is_not_equal_true:
51785 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
51786 } else {
51787 is_not_equal_false:
51788 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
51789 }
51790 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51791 d1 = (double)Z_LVAL_P(op1);
51792 d2 = Z_DVAL_P(op2);
51793 goto is_not_equal_double;
51794 }
51795 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51796 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51797 d1 = Z_DVAL_P(op1);
51798 d2 = Z_DVAL_P(op2);
51799 is_not_equal_double:
51800 if (d1 != d2) {
51801 goto is_not_equal_true;
51802 } else {
51803 goto is_not_equal_false;
51804 }
51805 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51806 d1 = Z_DVAL_P(op1);
51807 d2 = (double)Z_LVAL_P(op2);
51808 goto is_not_equal_double;
51809 }
51810 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51811 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51812 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51813 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51814 zval_ptr_dtor_str(op1);
51815 }
51816 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51817 zval_ptr_dtor_str(op2);
51818 }
51819 if (!result) {
51820 goto is_not_equal_true;
51821 } else {
51822 goto is_not_equal_false;
51823 }
51824 }
51825 }
51826 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51827 }
51828
ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51829 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51830 {
51831 USE_OPLINE
51832 zval *op1, *op2;
51833 double d1, d2;
51834
51835 op1 = EX_VAR(opline->op1.var);
51836 op2 = EX_VAR(opline->op2.var);
51837 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
51838 /* pass */
51839 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
51840 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51841 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
51842 is_not_equal_true:
51843 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
51844 } else {
51845 is_not_equal_false:
51846 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
51847 }
51848 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51849 d1 = (double)Z_LVAL_P(op1);
51850 d2 = Z_DVAL_P(op2);
51851 goto is_not_equal_double;
51852 }
51853 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
51854 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
51855 d1 = Z_DVAL_P(op1);
51856 d2 = Z_DVAL_P(op2);
51857 is_not_equal_double:
51858 if (d1 != d2) {
51859 goto is_not_equal_true;
51860 } else {
51861 goto is_not_equal_false;
51862 }
51863 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
51864 d1 = Z_DVAL_P(op1);
51865 d2 = (double)Z_LVAL_P(op2);
51866 goto is_not_equal_double;
51867 }
51868 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
51869 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
51870 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
51871 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51872 zval_ptr_dtor_str(op1);
51873 }
51874 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
51875 zval_ptr_dtor_str(op2);
51876 }
51877 if (!result) {
51878 goto is_not_equal_true;
51879 } else {
51880 goto is_not_equal_false;
51881 }
51882 }
51883 }
51884 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
51885 }
51886
ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51887 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51888 {
51889 USE_OPLINE
51890 zval *op1, *op2;
51891
51892 SAVE_OPLINE();
51893 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51894 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51895 compare_function(EX_VAR(opline->result.var), op1, op2);
51896
51897
51898 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51899 }
51900
ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51901 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51902 {
51903 USE_OPLINE
51904 zval *op1, *op2;
51905
51906 SAVE_OPLINE();
51907 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
51908 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51909 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
51910
51911
51912 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51913 }
51914
ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51915 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51916 {
51917 USE_OPLINE
51918 zval *object;
51919 zval *property;
51920 zval *value;
51921 zval *zptr;
51922 void *_cache_slot[3] = {0};
51923 void **cache_slot;
51924 zend_property_info *prop_info;
51925 zend_object *zobj;
51926 zend_string *name, *tmp_name;
51927
51928 SAVE_OPLINE();
51929 object = EX_VAR(opline->op1.var);
51930 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51931
51932 do {
51933 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
51934
51935 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
51936 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
51937 object = Z_REFVAL_P(object);
51938 goto assign_op_object;
51939 }
51940 if (IS_CV == IS_CV
51941 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
51942 ZVAL_UNDEFINED_OP1();
51943 }
51944 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
51945 break;
51946 }
51947
51948 assign_op_object:
51949 /* here we are sure we are dealing with an object */
51950 zobj = Z_OBJ_P(object);
51951 if (IS_CV == IS_CONST) {
51952 name = Z_STR_P(property);
51953 } else {
51954 name = zval_try_get_tmp_string(property, &tmp_name);
51955 if (UNEXPECTED(!name)) {
51956 UNDEF_RESULT();
51957 break;
51958 }
51959 }
51960 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot;
51961 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
51962 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
51963 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51964 ZVAL_NULL(EX_VAR(opline->result.var));
51965 }
51966 } else {
51967 zend_reference *ref;
51968
51969 do {
51970 if (UNEXPECTED(Z_ISREF_P(zptr))) {
51971 ref = Z_REF_P(zptr);
51972 zptr = Z_REFVAL_P(zptr);
51973 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
51974 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
51975 break;
51976 }
51977 }
51978
51979 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
51980 if (prop_info) {
51981 /* special case for typed properties */
51982 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
51983 } else {
51984 zend_binary_op(zptr, zptr, value OPLINE_CC);
51985 }
51986 } while (0);
51987
51988 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51989 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
51990 }
51991 }
51992 } else {
51993 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
51994 }
51995 if (IS_CV != IS_CONST) {
51996 zend_tmp_string_release(tmp_name);
51997 }
51998 } while (0);
51999
52000 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52001
52002
52003 /* assign_obj has two opcodes! */
52004 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52005 }
52006
52007 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52008 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52009 {
52010 USE_OPLINE
52011 zval *var_ptr;
52012 zval *value, *container, *dim;
52013 HashTable *ht;
52014
52015 SAVE_OPLINE();
52016 container = EX_VAR(opline->op1.var);
52017
52018 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52019 assign_dim_op_array:
52020 SEPARATE_ARRAY(container);
52021 ht = Z_ARRVAL_P(container);
52022 assign_dim_op_new_array:
52023 dim = EX_VAR(opline->op2.var);
52024 if (IS_CV == IS_UNUSED) {
52025 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
52026 if (UNEXPECTED(!var_ptr)) {
52027 zend_cannot_add_element();
52028 goto assign_dim_op_ret_null;
52029 }
52030 } else {
52031 if (IS_CV == IS_CONST) {
52032 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
52033 } else {
52034 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
52035 }
52036 if (UNEXPECTED(!var_ptr)) {
52037 goto assign_dim_op_ret_null;
52038 }
52039 }
52040
52041 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
52042
52043 do {
52044 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
52045 zend_reference *ref = Z_REF_P(var_ptr);
52046 var_ptr = Z_REFVAL_P(var_ptr);
52047 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
52048 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
52049 break;
52050 }
52051 }
52052 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
52053 } while (0);
52054
52055 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52056 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
52057 }
52058 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52059 } else {
52060 if (EXPECTED(Z_ISREF_P(container))) {
52061 container = Z_REFVAL_P(container);
52062 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52063 goto assign_dim_op_array;
52064 }
52065 }
52066
52067 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52068 zend_object *obj = Z_OBJ_P(container);
52069
52070 dim = EX_VAR(opline->op2.var);
52071 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52072 dim++;
52073 }
52074 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
52075 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
52076 uint8_t old_type;
52077
52078 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
52079 ZVAL_UNDEFINED_OP1();
52080 }
52081 ht = zend_new_array(8);
52082 old_type = Z_TYPE_P(container);
52083 ZVAL_ARR(container, ht);
52084 if (UNEXPECTED(old_type == IS_FALSE)) {
52085 GC_ADDREF(ht);
52086 zend_false_to_array_deprecated();
52087 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52088 zend_array_destroy(ht);
52089 goto assign_dim_op_ret_null;
52090 }
52091 }
52092 goto assign_dim_op_new_array;
52093 } else {
52094 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52095 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
52096 assign_dim_op_ret_null:
52097 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
52098 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52099 ZVAL_NULL(EX_VAR(opline->result.var));
52100 }
52101 }
52102 }
52103
52104
52105 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52106 }
52107
ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52108 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52109 {
52110 USE_OPLINE
52111 zval *var_ptr;
52112 zval *value;
52113
52114 SAVE_OPLINE();
52115 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52116 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
52117
52118 do {
52119 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
52120 zend_reference *ref = Z_REF_P(var_ptr);
52121 var_ptr = Z_REFVAL_P(var_ptr);
52122 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
52123 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
52124 break;
52125 }
52126 }
52127 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
52128 } while (0);
52129
52130 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52131 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
52132 }
52133
52134
52135 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52136 }
52137
ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52138 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52139 {
52140 USE_OPLINE
52141 zval *object;
52142 zval *property;
52143 zval *zptr;
52144 void *_cache_slot[3] = {0};
52145 void **cache_slot;
52146 zend_property_info *prop_info;
52147 zend_object *zobj;
52148 zend_string *name, *tmp_name;
52149
52150 SAVE_OPLINE();
52151 object = EX_VAR(opline->op1.var);
52152 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52153
52154 do {
52155 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52156 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52157 object = Z_REFVAL_P(object);
52158 goto pre_incdec_object;
52159 }
52160 if (IS_CV == IS_CV
52161 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52162 ZVAL_UNDEFINED_OP1();
52163 }
52164 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
52165 break;
52166 }
52167
52168 pre_incdec_object:
52169 /* here we are sure we are dealing with an object */
52170 zobj = Z_OBJ_P(object);
52171 if (IS_CV == IS_CONST) {
52172 name = Z_STR_P(property);
52173 } else {
52174 name = zval_try_get_tmp_string(property, &tmp_name);
52175 if (UNEXPECTED(!name)) {
52176 UNDEF_RESULT();
52177 break;
52178 }
52179 }
52180 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
52181 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
52182 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
52183 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52184 ZVAL_NULL(EX_VAR(opline->result.var));
52185 }
52186 } else {
52187 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
52188 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
52189 }
52190 } else {
52191 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
52192 }
52193 if (IS_CV != IS_CONST) {
52194 zend_tmp_string_release(tmp_name);
52195 }
52196 } while (0);
52197
52198
52199 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52200 }
52201
ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52202 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52203 {
52204 USE_OPLINE
52205 zval *object;
52206 zval *property;
52207 zval *zptr;
52208 void *_cache_slot[3] = {0};
52209 void **cache_slot;
52210 zend_property_info *prop_info;
52211 zend_object *zobj;
52212 zend_string *name, *tmp_name;
52213
52214 SAVE_OPLINE();
52215 object = EX_VAR(opline->op1.var);
52216 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52217
52218 do {
52219 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52220 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52221 object = Z_REFVAL_P(object);
52222 goto post_incdec_object;
52223 }
52224 if (IS_CV == IS_CV
52225 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52226 ZVAL_UNDEFINED_OP1();
52227 }
52228 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
52229 break;
52230 }
52231
52232 post_incdec_object:
52233 /* here we are sure we are dealing with an object */
52234 zobj = Z_OBJ_P(object);
52235 if (IS_CV == IS_CONST) {
52236 name = Z_STR_P(property);
52237 } else {
52238 name = zval_try_get_tmp_string(property, &tmp_name);
52239 if (UNEXPECTED(!name)) {
52240 ZVAL_UNDEF(EX_VAR(opline->result.var));
52241 break;
52242 }
52243 }
52244 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot;
52245 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
52246 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
52247 ZVAL_NULL(EX_VAR(opline->result.var));
52248 } else {
52249 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
52250 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
52251 }
52252 } else {
52253 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
52254 }
52255 if (IS_CV != IS_CONST) {
52256 zend_tmp_string_release(tmp_name);
52257 }
52258 } while (0);
52259
52260
52261 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52262 }
52263
ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52264 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52265 {
52266 USE_OPLINE
52267 zval *container, *dim, *value;
52268
52269 SAVE_OPLINE();
52270 container = EX_VAR(opline->op1.var);
52271 dim = EX_VAR(opline->op2.var);
52272 if (IS_CV != IS_CONST) {
52273 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52274 fetch_dim_r_array:
52275 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
52276 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
52277 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
52278 container = Z_REFVAL_P(container);
52279 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
52280 goto fetch_dim_r_array;
52281 } else {
52282 goto fetch_dim_r_slow;
52283 }
52284 } else {
52285 fetch_dim_r_slow:
52286 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52287 dim++;
52288 }
52289 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
52290 }
52291 } else {
52292 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
52293 }
52294
52295
52296 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52297 }
52298
ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52299 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52300 {
52301 USE_OPLINE
52302 zval *container;
52303
52304 SAVE_OPLINE();
52305 container = EX_VAR(opline->op1.var);
52306 zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52307
52308 if (IS_CV == IS_VAR) {
52309 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52310 }
52311 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52312 }
52313
ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52314 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52315 {
52316 USE_OPLINE
52317 zval *container;
52318
52319 SAVE_OPLINE();
52320 container = EX_VAR(opline->op1.var);
52321 zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52322
52323 if (IS_CV == IS_VAR) {
52324 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52325 }
52326 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52327 }
52328
ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52329 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52330 {
52331 USE_OPLINE
52332 zval *container;
52333
52334 SAVE_OPLINE();
52335 container = EX_VAR(opline->op1.var);
52336 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52337
52338
52339 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52340 }
52341
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52342 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52343 {
52344 #if 0
52345 USE_OPLINE
52346 #endif
52347
52348 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
52349 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
52350 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52351 }
52352 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52353 } else {
52354 if (IS_CV == IS_UNUSED) {
52355 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52356 }
52357 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52358 }
52359 }
52360
ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52361 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52362 {
52363 USE_OPLINE
52364 zval *container;
52365
52366 SAVE_OPLINE();
52367 container = EX_VAR(opline->op1.var);
52368 zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
52369
52370 if (IS_CV == IS_VAR) {
52371 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52372 }
52373 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52374 }
52375
ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52376 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52377 {
52378 USE_OPLINE
52379 zval *container;
52380 void **cache_slot = NULL;
52381
52382 SAVE_OPLINE();
52383 container = EX_VAR(opline->op1.var);
52384
52385 if (IS_CV == IS_CONST ||
52386 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
52387 do {
52388 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
52389 container = Z_REFVAL_P(container);
52390 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52391 break;
52392 }
52393 }
52394 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
52395 ZVAL_UNDEFINED_OP1();
52396 }
52397 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52398 ZVAL_NULL(EX_VAR(opline->result.var));
52399 goto fetch_obj_r_finish;
52400 } while (0);
52401 }
52402
52403 /* here we are sure we are dealing with an object */
52404 do {
52405 zend_object *zobj = Z_OBJ_P(container);
52406 zend_string *name, *tmp_name;
52407 zval *retval;
52408
52409 if (IS_CV == IS_CONST) {
52410 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
52411
52412 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
52413 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52414
52415 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52416 fetch_obj_r_simple:
52417 retval = OBJ_PROP(zobj, prop_offset);
52418 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
52419 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52420 goto fetch_obj_r_copy;
52421 } else {
52422 fetch_obj_r_fast_copy:
52423 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52424 ZEND_VM_NEXT_OPCODE();
52425 }
52426 }
52427 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
52428 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
52429 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
52430 prop_offset = prop_info->offset;
52431 goto fetch_obj_r_simple;
52432 } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) {
52433 zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
52434 ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION);
52435 ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array));
52436
52437 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
52438 if (IS_CV & IS_CV) {
52439 GC_ADDREF(zobj);
52440 }
52441 if (IS_CV & (IS_CV|IS_VAR|IS_TMP_VAR)) {
52442 call_info |= ZEND_CALL_RELEASE_THIS;
52443 }
52444 zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj);
52445 call->prev_execute_data = execute_data;
52446 call->call = NULL;
52447 call->return_value = EX_VAR(opline->result.var);
52448 call->run_time_cache = RUN_TIME_CACHE(&hook->op_array);
52449
52450 execute_data = call;
52451 EG(current_execute_data) = execute_data;
52452 zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC);
52453
52454 #if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID))
52455 opline = hook->op_array.opcodes;
52456 #else
52457 EX(opline) = hook->op_array.opcodes;
52458 #endif
52459 LOAD_OPLINE_EX();
52460
52461
52462 ZEND_VM_ENTER_EX();
52463 }
52464 /* Fall through to read_property for hooks. */
52465 } else if (EXPECTED(zobj->properties != NULL)) {
52466 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
52467 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52468 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
52469 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
52470
52471 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
52472 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
52473
52474 if (EXPECTED(p->key == name) ||
52475 (EXPECTED(p->h == ZSTR_H(name)) &&
52476 EXPECTED(p->key != NULL) &&
52477 EXPECTED(zend_string_equal_content(p->key, name)))) {
52478 retval = &p->val;
52479 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52480 goto fetch_obj_r_copy;
52481 } else {
52482 goto fetch_obj_r_fast_copy;
52483 }
52484 }
52485 }
52486 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
52487 }
52488 retval = zend_hash_find_known_hash(zobj->properties, name);
52489 if (EXPECTED(retval)) {
52490 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
52491 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
52492 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52493 goto fetch_obj_r_copy;
52494 } else {
52495 goto fetch_obj_r_fast_copy;
52496 }
52497 }
52498 }
52499 }
52500 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52501 } else {
52502 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52503 if (UNEXPECTED(!name)) {
52504 ZVAL_UNDEF(EX_VAR(opline->result.var));
52505 break;
52506 }
52507 }
52508
52509 #if ZEND_DEBUG
52510 /* For non-standard object handlers, verify a declared property type in debug builds.
52511 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
52512 zend_property_info *prop_info = NULL;
52513 if (zobj->handlers->read_property != zend_std_read_property) {
52514 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
52515 }
52516 #endif
52517 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
52518 #if ZEND_DEBUG
52519 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
52520 && ZEND_TYPE_IS_SET(prop_info->type)) {
52521 ZVAL_OPT_DEREF(retval);
52522 zend_verify_property_type(prop_info, retval, /* strict */ true);
52523 }
52524 #endif
52525
52526 if (IS_CV != IS_CONST) {
52527 zend_tmp_string_release(tmp_name);
52528 }
52529
52530 if (retval != EX_VAR(opline->result.var)) {
52531 fetch_obj_r_copy:
52532 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52533 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
52534 zend_unwrap_reference(retval);
52535 }
52536 } while (0);
52537
52538 fetch_obj_r_finish:
52539
52540
52541 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52542 }
52543
ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52544 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52545 {
52546 USE_OPLINE
52547 zval *property, *container, *result;
52548
52549 SAVE_OPLINE();
52550
52551 container = EX_VAR(opline->op1.var);
52552 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52553 result = EX_VAR(opline->result.var);
52554 zend_fetch_property_address(
52555 result, container, IS_CV, property, IS_CV,
52556 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
52557 BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC);
52558
52559 if (IS_CV == IS_VAR) {
52560 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52561 }
52562 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52563 }
52564
ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52565 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52566 {
52567 USE_OPLINE
52568 zval *property, *container, *result;
52569
52570 SAVE_OPLINE();
52571 container = EX_VAR(opline->op1.var);
52572 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52573 result = EX_VAR(opline->result.var);
52574 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);
52575
52576 if (IS_CV == IS_VAR) {
52577 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52578 }
52579 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52580 }
52581
ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52582 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52583 {
52584 USE_OPLINE
52585 zval *container;
52586 void **cache_slot = NULL;
52587
52588 SAVE_OPLINE();
52589 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
52590
52591 if (IS_CV == IS_CONST ||
52592 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
52593 do {
52594 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
52595 container = Z_REFVAL_P(container);
52596 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
52597 break;
52598 }
52599 }
52600 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
52601 ZVAL_UNDEFINED_OP2();
52602 }
52603 ZVAL_NULL(EX_VAR(opline->result.var));
52604 goto fetch_obj_is_finish;
52605 } while (0);
52606 }
52607
52608 /* here we are sure we are dealing with an object */
52609 do {
52610 zend_object *zobj = Z_OBJ_P(container);
52611 zend_string *name, *tmp_name;
52612 zval *retval;
52613
52614 if (IS_CV == IS_CONST) {
52615 cache_slot = CACHE_ADDR(opline->extended_value);
52616
52617 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
52618 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52619
52620 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52621 fetch_obj_is_simple:
52622 retval = OBJ_PROP(zobj, prop_offset);
52623 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
52624 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52625 goto fetch_obj_is_copy;
52626 } else {
52627 fetch_obj_is_fast_copy:
52628 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52629 ZEND_VM_NEXT_OPCODE();
52630 }
52631 }
52632 } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) {
52633 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) {
52634 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
52635 prop_offset = prop_info->offset;
52636 goto fetch_obj_is_simple;
52637 }
52638 /* Fall through to read_property for hooks. */
52639 } else if (EXPECTED(zobj->properties != NULL)) {
52640 ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset));
52641 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52642 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
52643 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
52644
52645 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
52646 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
52647
52648 if (EXPECTED(p->key == name) ||
52649 (EXPECTED(p->h == ZSTR_H(name)) &&
52650 EXPECTED(p->key != NULL) &&
52651 EXPECTED(zend_string_equal_content(p->key, name)))) {
52652 retval = &p->val;
52653 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52654 goto fetch_obj_is_copy;
52655 } else {
52656 goto fetch_obj_is_fast_copy;
52657 }
52658 }
52659 }
52660 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
52661 }
52662 retval = zend_hash_find_known_hash(zobj->properties, name);
52663 if (EXPECTED(retval)) {
52664 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
52665 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
52666 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
52667 goto fetch_obj_is_copy;
52668 } else {
52669 goto fetch_obj_is_fast_copy;
52670 }
52671 }
52672 }
52673 }
52674 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52675 } else {
52676 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52677 if (UNEXPECTED(!name)) {
52678 ZVAL_UNDEF(EX_VAR(opline->result.var));
52679 break;
52680 }
52681 }
52682
52683 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
52684
52685 if (IS_CV != IS_CONST) {
52686 zend_tmp_string_release(tmp_name);
52687 }
52688
52689 if (retval != EX_VAR(opline->result.var)) {
52690 fetch_obj_is_copy:
52691 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
52692 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
52693 zend_unwrap_reference(retval);
52694 }
52695 } while (0);
52696
52697 fetch_obj_is_finish:
52698
52699
52700 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52701 }
52702
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52703 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52704 {
52705 #if 0
52706 USE_OPLINE
52707 #endif
52708
52709 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
52710 /* Behave like FETCH_OBJ_W */
52711 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
52712 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52713 }
52714 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52715 } else {
52716 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
52717 }
52718 }
52719
ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52720 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52721 {
52722 USE_OPLINE
52723 zval *container, *property, *result;
52724
52725 SAVE_OPLINE();
52726 container = EX_VAR(opline->op1.var);
52727 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52728 result = EX_VAR(opline->result.var);
52729 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);
52730
52731 if (IS_CV == IS_VAR) {
52732 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
52733 }
52734 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52735 }
52736
ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52737 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52738 {
52739 USE_OPLINE
52740 zval *object, *value, tmp;
52741 zend_object *zobj;
52742 zend_string *name, *tmp_name;
52743 zend_refcounted *garbage = NULL;
52744
52745 SAVE_OPLINE();
52746 object = EX_VAR(opline->op1.var);
52747 value = RT_CONSTANT((opline+1), (opline+1)->op1);
52748
52749 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52750 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52751 object = Z_REFVAL_P(object);
52752 goto assign_object;
52753 }
52754 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
52755 value = &EG(uninitialized_zval);
52756 goto free_and_exit_assign_obj;
52757 }
52758
52759 assign_object:
52760 zobj = Z_OBJ_P(object);
52761 if (IS_CV == IS_CONST) {
52762 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
52763 void **cache_slot = CACHE_ADDR(opline->extended_value);
52764 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52765 zval *property_val;
52766
52767 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52768 property_val = OBJ_PROP(zobj, prop_offset);
52769 if (Z_TYPE_P(property_val) != IS_UNDEF) {
52770 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
52771
52772 if (prop_info != NULL) {
52773 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
52774 goto free_and_exit_assign_obj;
52775 } else {
52776 fast_assign_obj:
52777 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
52778 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52779 ZVAL_COPY(EX_VAR(opline->result.var), value);
52780 }
52781 goto exit_assign_obj;
52782 }
52783 }
52784 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
52785 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52786 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
52787 zobj = zend_lazy_object_init(zobj);
52788 if (!zobj) {
52789 value = &EG(uninitialized_zval);
52790 goto free_and_exit_assign_obj;
52791 }
52792 }
52793 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
52794 rebuild_object_properties_internal(zobj);
52795 }
52796 if (EXPECTED(zobj->properties != NULL)) {
52797 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
52798 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
52799 GC_DELREF(zobj->properties);
52800 }
52801 zobj->properties = zend_array_dup(zobj->properties);
52802 }
52803 property_val = zend_hash_find_known_hash(zobj->properties, name);
52804 if (property_val) {
52805 goto fast_assign_obj;
52806 }
52807 }
52808
52809 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
52810 if (IS_CONST == IS_CONST) {
52811 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
52812 Z_ADDREF_P(value);
52813 }
52814 } else if (IS_CONST != IS_TMP_VAR) {
52815 if (Z_ISREF_P(value)) {
52816 if (IS_CONST == IS_VAR) {
52817 zend_reference *ref = Z_REF_P(value);
52818 if (GC_DELREF(ref) == 0) {
52819 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
52820 efree_size(ref, sizeof(zend_reference));
52821 value = &tmp;
52822 } else {
52823 value = Z_REFVAL_P(value);
52824 Z_TRY_ADDREF_P(value);
52825 }
52826 } else {
52827 value = Z_REFVAL_P(value);
52828 Z_TRY_ADDREF_P(value);
52829 }
52830 } else if (IS_CONST == IS_CV) {
52831 Z_TRY_ADDREF_P(value);
52832 }
52833 }
52834 zend_hash_add_new(zobj->properties, name, value);
52835 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52836 ZVAL_COPY(EX_VAR(opline->result.var), value);
52837 }
52838 goto exit_assign_obj;
52839 }
52840 } else {
52841 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
52842 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
52843 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
52844 property_val = OBJ_PROP(zobj, prop_info->offset);
52845 if (ZEND_TYPE_IS_SET(prop_info->type)) {
52846 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
52847 goto free_and_exit_assign_obj;
52848 } else {
52849 goto fast_assign_obj;
52850 }
52851 }
52852 /* Fall through to write_property for hooks. */
52853 }
52854 }
52855 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52856 } else {
52857 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
52858 if (UNEXPECTED(!name)) {
52859
52860 UNDEF_RESULT();
52861 goto exit_assign_obj;
52862 }
52863 }
52864
52865 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
52866 ZVAL_DEREF(value);
52867 }
52868
52869 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
52870
52871 if (IS_CV != IS_CONST) {
52872 zend_tmp_string_release(tmp_name);
52873 }
52874
52875 free_and_exit_assign_obj:
52876 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
52877 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
52878 }
52879
52880 exit_assign_obj:
52881 if (garbage) {
52882 GC_DTOR_NO_REF(garbage);
52883 }
52884
52885
52886 /* assign_obj has two opcodes! */
52887 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52888 }
52889
52890 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52891 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52892 {
52893 USE_OPLINE
52894 zval *object, *value, tmp;
52895 zend_object *zobj;
52896 zend_string *name, *tmp_name;
52897 zend_refcounted *garbage = NULL;
52898
52899 SAVE_OPLINE();
52900 object = EX_VAR(opline->op1.var);
52901 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
52902
52903 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
52904 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
52905 object = Z_REFVAL_P(object);
52906 goto assign_object;
52907 }
52908 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
52909 value = &EG(uninitialized_zval);
52910 goto free_and_exit_assign_obj;
52911 }
52912
52913 assign_object:
52914 zobj = Z_OBJ_P(object);
52915 if (IS_CV == IS_CONST) {
52916 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
52917 void **cache_slot = CACHE_ADDR(opline->extended_value);
52918 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
52919 zval *property_val;
52920
52921 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
52922 property_val = OBJ_PROP(zobj, prop_offset);
52923 if (Z_TYPE_P(property_val) != IS_UNDEF) {
52924 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
52925
52926 if (prop_info != NULL) {
52927 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
52928 goto free_and_exit_assign_obj;
52929 } else {
52930 fast_assign_obj:
52931 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
52932 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52933 ZVAL_COPY(EX_VAR(opline->result.var), value);
52934 }
52935 goto exit_assign_obj;
52936 }
52937 }
52938 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
52939 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
52940 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
52941 zobj = zend_lazy_object_init(zobj);
52942 if (!zobj) {
52943 value = &EG(uninitialized_zval);
52944 goto free_and_exit_assign_obj;
52945 }
52946 }
52947 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
52948 rebuild_object_properties_internal(zobj);
52949 }
52950 if (EXPECTED(zobj->properties != NULL)) {
52951 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
52952 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
52953 GC_DELREF(zobj->properties);
52954 }
52955 zobj->properties = zend_array_dup(zobj->properties);
52956 }
52957 property_val = zend_hash_find_known_hash(zobj->properties, name);
52958 if (property_val) {
52959 goto fast_assign_obj;
52960 }
52961 }
52962
52963 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
52964 if (IS_TMP_VAR == IS_CONST) {
52965 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
52966 Z_ADDREF_P(value);
52967 }
52968 } else if (IS_TMP_VAR != IS_TMP_VAR) {
52969 if (Z_ISREF_P(value)) {
52970 if (IS_TMP_VAR == IS_VAR) {
52971 zend_reference *ref = Z_REF_P(value);
52972 if (GC_DELREF(ref) == 0) {
52973 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
52974 efree_size(ref, sizeof(zend_reference));
52975 value = &tmp;
52976 } else {
52977 value = Z_REFVAL_P(value);
52978 Z_TRY_ADDREF_P(value);
52979 }
52980 } else {
52981 value = Z_REFVAL_P(value);
52982 Z_TRY_ADDREF_P(value);
52983 }
52984 } else if (IS_TMP_VAR == IS_CV) {
52985 Z_TRY_ADDREF_P(value);
52986 }
52987 }
52988 zend_hash_add_new(zobj->properties, name, value);
52989 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52990 ZVAL_COPY(EX_VAR(opline->result.var), value);
52991 }
52992 goto exit_assign_obj;
52993 }
52994 } else {
52995 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
52996 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
52997 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
52998 property_val = OBJ_PROP(zobj, prop_info->offset);
52999 if (ZEND_TYPE_IS_SET(prop_info->type)) {
53000 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53001 goto free_and_exit_assign_obj;
53002 } else {
53003 goto fast_assign_obj;
53004 }
53005 }
53006 /* Fall through to write_property for hooks. */
53007 }
53008 }
53009 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53010 } else {
53011 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53012 if (UNEXPECTED(!name)) {
53013 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53014 UNDEF_RESULT();
53015 goto exit_assign_obj;
53016 }
53017 }
53018
53019 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
53020 ZVAL_DEREF(value);
53021 }
53022
53023 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53024
53025 if (IS_CV != IS_CONST) {
53026 zend_tmp_string_release(tmp_name);
53027 }
53028
53029 free_and_exit_assign_obj:
53030 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53031 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53032 }
53033 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53034 exit_assign_obj:
53035 if (garbage) {
53036 GC_DTOR_NO_REF(garbage);
53037 }
53038
53039
53040 /* assign_obj has two opcodes! */
53041 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53042 }
53043
53044 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53045 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53046 {
53047 USE_OPLINE
53048 zval *object, *value, tmp;
53049 zend_object *zobj;
53050 zend_string *name, *tmp_name;
53051 zend_refcounted *garbage = NULL;
53052
53053 SAVE_OPLINE();
53054 object = EX_VAR(opline->op1.var);
53055 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53056
53057 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
53058 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
53059 object = Z_REFVAL_P(object);
53060 goto assign_object;
53061 }
53062 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
53063 value = &EG(uninitialized_zval);
53064 goto free_and_exit_assign_obj;
53065 }
53066
53067 assign_object:
53068 zobj = Z_OBJ_P(object);
53069 if (IS_CV == IS_CONST) {
53070 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
53071 void **cache_slot = CACHE_ADDR(opline->extended_value);
53072 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
53073 zval *property_val;
53074
53075 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
53076 property_val = OBJ_PROP(zobj, prop_offset);
53077 if (Z_TYPE_P(property_val) != IS_UNDEF) {
53078 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
53079
53080 if (prop_info != NULL) {
53081 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53082 goto free_and_exit_assign_obj;
53083 } else {
53084 fast_assign_obj:
53085 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
53086 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53087 ZVAL_COPY(EX_VAR(opline->result.var), value);
53088 }
53089 goto exit_assign_obj;
53090 }
53091 }
53092 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
53093 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53094 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
53095 zobj = zend_lazy_object_init(zobj);
53096 if (!zobj) {
53097 value = &EG(uninitialized_zval);
53098 goto free_and_exit_assign_obj;
53099 }
53100 }
53101 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53102 rebuild_object_properties_internal(zobj);
53103 }
53104 if (EXPECTED(zobj->properties != NULL)) {
53105 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
53106 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
53107 GC_DELREF(zobj->properties);
53108 }
53109 zobj->properties = zend_array_dup(zobj->properties);
53110 }
53111 property_val = zend_hash_find_known_hash(zobj->properties, name);
53112 if (property_val) {
53113 goto fast_assign_obj;
53114 }
53115 }
53116
53117 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53118 if (IS_VAR == IS_CONST) {
53119 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
53120 Z_ADDREF_P(value);
53121 }
53122 } else if (IS_VAR != IS_TMP_VAR) {
53123 if (Z_ISREF_P(value)) {
53124 if (IS_VAR == IS_VAR) {
53125 zend_reference *ref = Z_REF_P(value);
53126 if (GC_DELREF(ref) == 0) {
53127 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
53128 efree_size(ref, sizeof(zend_reference));
53129 value = &tmp;
53130 } else {
53131 value = Z_REFVAL_P(value);
53132 Z_TRY_ADDREF_P(value);
53133 }
53134 } else {
53135 value = Z_REFVAL_P(value);
53136 Z_TRY_ADDREF_P(value);
53137 }
53138 } else if (IS_VAR == IS_CV) {
53139 Z_TRY_ADDREF_P(value);
53140 }
53141 }
53142 zend_hash_add_new(zobj->properties, name, value);
53143 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53144 ZVAL_COPY(EX_VAR(opline->result.var), value);
53145 }
53146 goto exit_assign_obj;
53147 }
53148 } else {
53149 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
53150 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
53151 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
53152 property_val = OBJ_PROP(zobj, prop_info->offset);
53153 if (ZEND_TYPE_IS_SET(prop_info->type)) {
53154 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53155 goto free_and_exit_assign_obj;
53156 } else {
53157 goto fast_assign_obj;
53158 }
53159 }
53160 /* Fall through to write_property for hooks. */
53161 }
53162 }
53163 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53164 } else {
53165 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53166 if (UNEXPECTED(!name)) {
53167 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53168 UNDEF_RESULT();
53169 goto exit_assign_obj;
53170 }
53171 }
53172
53173 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
53174 ZVAL_DEREF(value);
53175 }
53176
53177 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53178
53179 if (IS_CV != IS_CONST) {
53180 zend_tmp_string_release(tmp_name);
53181 }
53182
53183 free_and_exit_assign_obj:
53184 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53185 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53186 }
53187 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53188 exit_assign_obj:
53189 if (garbage) {
53190 GC_DTOR_NO_REF(garbage);
53191 }
53192
53193
53194 /* assign_obj has two opcodes! */
53195 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53196 }
53197
53198 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53199 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53200 {
53201 USE_OPLINE
53202 zval *object, *value, tmp;
53203 zend_object *zobj;
53204 zend_string *name, *tmp_name;
53205 zend_refcounted *garbage = NULL;
53206
53207 SAVE_OPLINE();
53208 object = EX_VAR(opline->op1.var);
53209 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
53210
53211 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
53212 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
53213 object = Z_REFVAL_P(object);
53214 goto assign_object;
53215 }
53216 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
53217 value = &EG(uninitialized_zval);
53218 goto free_and_exit_assign_obj;
53219 }
53220
53221 assign_object:
53222 zobj = Z_OBJ_P(object);
53223 if (IS_CV == IS_CONST) {
53224 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
53225 void **cache_slot = CACHE_ADDR(opline->extended_value);
53226 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
53227 zval *property_val;
53228
53229 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
53230 property_val = OBJ_PROP(zobj, prop_offset);
53231 if (Z_TYPE_P(property_val) != IS_UNDEF) {
53232 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
53233
53234 if (prop_info != NULL) {
53235 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53236 goto free_and_exit_assign_obj;
53237 } else {
53238 fast_assign_obj:
53239 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
53240 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53241 ZVAL_COPY(EX_VAR(opline->result.var), value);
53242 }
53243 goto exit_assign_obj;
53244 }
53245 }
53246 } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) {
53247 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53248 if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
53249 zobj = zend_lazy_object_init(zobj);
53250 if (!zobj) {
53251 value = &EG(uninitialized_zval);
53252 goto free_and_exit_assign_obj;
53253 }
53254 }
53255 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53256 rebuild_object_properties_internal(zobj);
53257 }
53258 if (EXPECTED(zobj->properties != NULL)) {
53259 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
53260 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
53261 GC_DELREF(zobj->properties);
53262 }
53263 zobj->properties = zend_array_dup(zobj->properties);
53264 }
53265 property_val = zend_hash_find_known_hash(zobj->properties, name);
53266 if (property_val) {
53267 goto fast_assign_obj;
53268 }
53269 }
53270
53271 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
53272 if (IS_CV == IS_CONST) {
53273 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
53274 Z_ADDREF_P(value);
53275 }
53276 } else if (IS_CV != IS_TMP_VAR) {
53277 if (Z_ISREF_P(value)) {
53278 if (IS_CV == IS_VAR) {
53279 zend_reference *ref = Z_REF_P(value);
53280 if (GC_DELREF(ref) == 0) {
53281 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
53282 efree_size(ref, sizeof(zend_reference));
53283 value = &tmp;
53284 } else {
53285 value = Z_REFVAL_P(value);
53286 Z_TRY_ADDREF_P(value);
53287 }
53288 } else {
53289 value = Z_REFVAL_P(value);
53290 Z_TRY_ADDREF_P(value);
53291 }
53292 } else if (IS_CV == IS_CV) {
53293 Z_TRY_ADDREF_P(value);
53294 }
53295 }
53296 zend_hash_add_new(zobj->properties, name, value);
53297 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53298 ZVAL_COPY(EX_VAR(opline->result.var), value);
53299 }
53300 goto exit_assign_obj;
53301 }
53302 } else {
53303 ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset));
53304 if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) {
53305 zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2);
53306 property_val = OBJ_PROP(zobj, prop_info->offset);
53307 if (ZEND_TYPE_IS_SET(prop_info->type)) {
53308 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
53309 goto free_and_exit_assign_obj;
53310 } else {
53311 goto fast_assign_obj;
53312 }
53313 }
53314 /* Fall through to write_property for hooks. */
53315 }
53316 }
53317 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
53318 } else {
53319 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
53320 if (UNEXPECTED(!name)) {
53321
53322 UNDEF_RESULT();
53323 goto exit_assign_obj;
53324 }
53325 }
53326
53327 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
53328 ZVAL_DEREF(value);
53329 }
53330
53331 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
53332
53333 if (IS_CV != IS_CONST) {
53334 zend_tmp_string_release(tmp_name);
53335 }
53336
53337 free_and_exit_assign_obj:
53338 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
53339 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
53340 }
53341
53342 exit_assign_obj:
53343 if (garbage) {
53344 GC_DTOR_NO_REF(garbage);
53345 }
53346
53347
53348 /* assign_obj has two opcodes! */
53349 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53350 }
53351
53352 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53353 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53354 {
53355 USE_OPLINE
53356 zval *object_ptr, *orig_object_ptr;
53357 zval *value;
53358 zval *variable_ptr;
53359 zval *dim;
53360 zend_refcounted *garbage = NULL;
53361
53362 SAVE_OPLINE();
53363 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53364
53365 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53366 try_assign_dim_array:
53367 SEPARATE_ARRAY(object_ptr);
53368 if (IS_CV == IS_UNUSED) {
53369 value = RT_CONSTANT((opline+1), (opline+1)->op1);
53370 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53371 HashTable *ht = Z_ARRVAL_P(object_ptr);
53372 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53373 GC_ADDREF(ht);
53374 }
53375 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53376 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53377 zend_array_destroy(ht);
53378 goto assign_dim_error;
53379 }
53380 }
53381 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
53382 ZVAL_DEREF(value);
53383 }
53384 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53385 if (UNEXPECTED(value == NULL)) {
53386 zend_cannot_add_element();
53387 goto assign_dim_error;
53388 } else if (IS_CONST == IS_CV) {
53389 if (Z_REFCOUNTED_P(value)) {
53390 Z_ADDREF_P(value);
53391 }
53392 } else if (IS_CONST == IS_VAR) {
53393 zval *free_op_data = EX_VAR((opline+1)->op1.var);
53394 if (Z_ISREF_P(free_op_data)) {
53395 if (Z_REFCOUNTED_P(value)) {
53396 Z_ADDREF_P(value);
53397 }
53398 zval_ptr_dtor_nogc(free_op_data);
53399 }
53400 } else if (IS_CONST == IS_CONST) {
53401 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53402 Z_ADDREF_P(value);
53403 }
53404 }
53405 } else {
53406 dim = EX_VAR(opline->op2.var);
53407 if (IS_CV == IS_CONST) {
53408 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53409 } else {
53410 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53411 }
53412 if (UNEXPECTED(variable_ptr == NULL)) {
53413 goto assign_dim_error;
53414 }
53415 value = RT_CONSTANT((opline+1), (opline+1)->op1);
53416 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
53417 }
53418 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53419 ZVAL_COPY(EX_VAR(opline->result.var), value);
53420 }
53421 if (garbage) {
53422 GC_DTOR_NO_REF(garbage);
53423 }
53424 } else {
53425 if (EXPECTED(Z_ISREF_P(object_ptr))) {
53426 object_ptr = Z_REFVAL_P(object_ptr);
53427 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53428 goto try_assign_dim_array;
53429 }
53430 }
53431 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53432 zend_object *obj = Z_OBJ_P(object_ptr);
53433
53434 GC_ADDREF(obj);
53435 dim = EX_VAR(opline->op2.var);
53436 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53437 dim = ZVAL_UNDEFINED_OP2();
53438 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53439 dim++;
53440 }
53441
53442 value = RT_CONSTANT((opline+1), (opline+1)->op1);
53443 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53444 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53445 } else if (IS_CONST & (IS_CV|IS_VAR)) {
53446 ZVAL_DEREF(value);
53447 }
53448
53449 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53450
53451 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53452 zend_objects_store_del(obj);
53453 }
53454 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53455 if (IS_CV == IS_UNUSED) {
53456 zend_use_new_element_for_string();
53457
53458 UNDEF_RESULT();
53459 } else {
53460 dim = EX_VAR(opline->op2.var);
53461 value = RT_CONSTANT((opline+1), (opline+1)->op1);
53462 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53463
53464 }
53465 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53466 if (Z_ISREF_P(orig_object_ptr)
53467 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53468 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53469 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53470
53471 UNDEF_RESULT();
53472 } else {
53473 HashTable *ht = zend_new_array(8);
53474 uint8_t old_type = Z_TYPE_P(object_ptr);
53475
53476 ZVAL_ARR(object_ptr, ht);
53477 if (UNEXPECTED(old_type == IS_FALSE)) {
53478 GC_ADDREF(ht);
53479 zend_false_to_array_deprecated();
53480 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53481 zend_array_destroy(ht);
53482 goto assign_dim_error;
53483 }
53484 }
53485 goto try_assign_dim_array;
53486 }
53487 } else {
53488 zend_use_scalar_as_array();
53489 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53490 assign_dim_error:
53491
53492 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53493 ZVAL_NULL(EX_VAR(opline->result.var));
53494 }
53495 }
53496 }
53497 if (IS_CV != IS_UNUSED) {
53498
53499 }
53500
53501 /* assign_dim has two opcodes! */
53502 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53503 }
53504
ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53505 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53506 {
53507 USE_OPLINE
53508 zval *object_ptr, *orig_object_ptr;
53509 zval *value;
53510 zval *variable_ptr;
53511 zval *dim;
53512 zend_refcounted *garbage = NULL;
53513
53514 SAVE_OPLINE();
53515 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53516
53517 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53518 try_assign_dim_array:
53519 SEPARATE_ARRAY(object_ptr);
53520 if (IS_CV == IS_UNUSED) {
53521 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53522 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53523 HashTable *ht = Z_ARRVAL_P(object_ptr);
53524 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53525 GC_ADDREF(ht);
53526 }
53527 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53528 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53529 zend_array_destroy(ht);
53530 goto assign_dim_error;
53531 }
53532 }
53533 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
53534 ZVAL_DEREF(value);
53535 }
53536 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53537 if (UNEXPECTED(value == NULL)) {
53538 zend_cannot_add_element();
53539 goto assign_dim_error;
53540 } else if (IS_TMP_VAR == IS_CV) {
53541 if (Z_REFCOUNTED_P(value)) {
53542 Z_ADDREF_P(value);
53543 }
53544 } else if (IS_TMP_VAR == IS_VAR) {
53545 zval *free_op_data = EX_VAR((opline+1)->op1.var);
53546 if (Z_ISREF_P(free_op_data)) {
53547 if (Z_REFCOUNTED_P(value)) {
53548 Z_ADDREF_P(value);
53549 }
53550 zval_ptr_dtor_nogc(free_op_data);
53551 }
53552 } else if (IS_TMP_VAR == IS_CONST) {
53553 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53554 Z_ADDREF_P(value);
53555 }
53556 }
53557 } else {
53558 dim = EX_VAR(opline->op2.var);
53559 if (IS_CV == IS_CONST) {
53560 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53561 } else {
53562 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53563 }
53564 if (UNEXPECTED(variable_ptr == NULL)) {
53565 goto assign_dim_error;
53566 }
53567 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53568 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
53569 }
53570 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53571 ZVAL_COPY(EX_VAR(opline->result.var), value);
53572 }
53573 if (garbage) {
53574 GC_DTOR_NO_REF(garbage);
53575 }
53576 } else {
53577 if (EXPECTED(Z_ISREF_P(object_ptr))) {
53578 object_ptr = Z_REFVAL_P(object_ptr);
53579 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53580 goto try_assign_dim_array;
53581 }
53582 }
53583 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53584 zend_object *obj = Z_OBJ_P(object_ptr);
53585
53586 GC_ADDREF(obj);
53587 dim = EX_VAR(opline->op2.var);
53588 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53589 dim = ZVAL_UNDEFINED_OP2();
53590 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53591 dim++;
53592 }
53593
53594 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53595 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53596 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53597 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
53598 ZVAL_DEREF(value);
53599 }
53600
53601 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53602
53603 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53604 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53605 zend_objects_store_del(obj);
53606 }
53607 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53608 if (IS_CV == IS_UNUSED) {
53609 zend_use_new_element_for_string();
53610 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53611 UNDEF_RESULT();
53612 } else {
53613 dim = EX_VAR(opline->op2.var);
53614 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
53615 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53616 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53617 }
53618 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53619 if (Z_ISREF_P(orig_object_ptr)
53620 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53621 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53622 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53623 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53624 UNDEF_RESULT();
53625 } else {
53626 HashTable *ht = zend_new_array(8);
53627 uint8_t old_type = Z_TYPE_P(object_ptr);
53628
53629 ZVAL_ARR(object_ptr, ht);
53630 if (UNEXPECTED(old_type == IS_FALSE)) {
53631 GC_ADDREF(ht);
53632 zend_false_to_array_deprecated();
53633 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53634 zend_array_destroy(ht);
53635 goto assign_dim_error;
53636 }
53637 }
53638 goto try_assign_dim_array;
53639 }
53640 } else {
53641 zend_use_scalar_as_array();
53642 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53643 assign_dim_error:
53644 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53645 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53646 ZVAL_NULL(EX_VAR(opline->result.var));
53647 }
53648 }
53649 }
53650 if (IS_CV != IS_UNUSED) {
53651
53652 }
53653
53654 /* assign_dim has two opcodes! */
53655 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53656 }
53657
ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53658 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53659 {
53660 USE_OPLINE
53661 zval *object_ptr, *orig_object_ptr;
53662 zval *value;
53663 zval *variable_ptr;
53664 zval *dim;
53665 zend_refcounted *garbage = NULL;
53666
53667 SAVE_OPLINE();
53668 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53669
53670 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53671 try_assign_dim_array:
53672 SEPARATE_ARRAY(object_ptr);
53673 if (IS_CV == IS_UNUSED) {
53674 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53675 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53676 HashTable *ht = Z_ARRVAL_P(object_ptr);
53677 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53678 GC_ADDREF(ht);
53679 }
53680 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53681 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53682 zend_array_destroy(ht);
53683 goto assign_dim_error;
53684 }
53685 }
53686 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
53687 ZVAL_DEREF(value);
53688 }
53689 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53690 if (UNEXPECTED(value == NULL)) {
53691 zend_cannot_add_element();
53692 goto assign_dim_error;
53693 } else if (IS_VAR == IS_CV) {
53694 if (Z_REFCOUNTED_P(value)) {
53695 Z_ADDREF_P(value);
53696 }
53697 } else if (IS_VAR == IS_VAR) {
53698 zval *free_op_data = EX_VAR((opline+1)->op1.var);
53699 if (Z_ISREF_P(free_op_data)) {
53700 if (Z_REFCOUNTED_P(value)) {
53701 Z_ADDREF_P(value);
53702 }
53703 zval_ptr_dtor_nogc(free_op_data);
53704 }
53705 } else if (IS_VAR == IS_CONST) {
53706 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53707 Z_ADDREF_P(value);
53708 }
53709 }
53710 } else {
53711 dim = EX_VAR(opline->op2.var);
53712 if (IS_CV == IS_CONST) {
53713 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53714 } else {
53715 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53716 }
53717 if (UNEXPECTED(variable_ptr == NULL)) {
53718 goto assign_dim_error;
53719 }
53720 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53721 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
53722 }
53723 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53724 ZVAL_COPY(EX_VAR(opline->result.var), value);
53725 }
53726 if (garbage) {
53727 GC_DTOR_NO_REF(garbage);
53728 }
53729 } else {
53730 if (EXPECTED(Z_ISREF_P(object_ptr))) {
53731 object_ptr = Z_REFVAL_P(object_ptr);
53732 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53733 goto try_assign_dim_array;
53734 }
53735 }
53736 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53737 zend_object *obj = Z_OBJ_P(object_ptr);
53738
53739 GC_ADDREF(obj);
53740 dim = EX_VAR(opline->op2.var);
53741 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53742 dim = ZVAL_UNDEFINED_OP2();
53743 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53744 dim++;
53745 }
53746
53747 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53748 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53749 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53750 } else if (IS_VAR & (IS_CV|IS_VAR)) {
53751 ZVAL_DEREF(value);
53752 }
53753
53754 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53755
53756 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53757 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53758 zend_objects_store_del(obj);
53759 }
53760 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53761 if (IS_CV == IS_UNUSED) {
53762 zend_use_new_element_for_string();
53763 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53764 UNDEF_RESULT();
53765 } else {
53766 dim = EX_VAR(opline->op2.var);
53767 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
53768 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53769 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53770 }
53771 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53772 if (Z_ISREF_P(orig_object_ptr)
53773 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53774 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53775 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53776 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53777 UNDEF_RESULT();
53778 } else {
53779 HashTable *ht = zend_new_array(8);
53780 uint8_t old_type = Z_TYPE_P(object_ptr);
53781
53782 ZVAL_ARR(object_ptr, ht);
53783 if (UNEXPECTED(old_type == IS_FALSE)) {
53784 GC_ADDREF(ht);
53785 zend_false_to_array_deprecated();
53786 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53787 zend_array_destroy(ht);
53788 goto assign_dim_error;
53789 }
53790 }
53791 goto try_assign_dim_array;
53792 }
53793 } else {
53794 zend_use_scalar_as_array();
53795 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53796 assign_dim_error:
53797 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
53798 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53799 ZVAL_NULL(EX_VAR(opline->result.var));
53800 }
53801 }
53802 }
53803 if (IS_CV != IS_UNUSED) {
53804
53805 }
53806
53807 /* assign_dim has two opcodes! */
53808 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53809 }
53810
ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53811 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53812 {
53813 USE_OPLINE
53814 zval *object_ptr, *orig_object_ptr;
53815 zval *value;
53816 zval *variable_ptr;
53817 zval *dim;
53818 zend_refcounted *garbage = NULL;
53819
53820 SAVE_OPLINE();
53821 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
53822
53823 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53824 try_assign_dim_array:
53825 SEPARATE_ARRAY(object_ptr);
53826 if (IS_CV == IS_UNUSED) {
53827 value = EX_VAR((opline+1)->op1.var);
53828 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
53829 HashTable *ht = Z_ARRVAL_P(object_ptr);
53830 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
53831 GC_ADDREF(ht);
53832 }
53833 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53834 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
53835 zend_array_destroy(ht);
53836 goto assign_dim_error;
53837 }
53838 }
53839 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
53840 ZVAL_DEREF(value);
53841 }
53842 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
53843 if (UNEXPECTED(value == NULL)) {
53844 zend_cannot_add_element();
53845 goto assign_dim_error;
53846 } else if (IS_CV == IS_CV) {
53847 if (Z_REFCOUNTED_P(value)) {
53848 Z_ADDREF_P(value);
53849 }
53850 } else if (IS_CV == IS_VAR) {
53851 zval *free_op_data = EX_VAR((opline+1)->op1.var);
53852 if (Z_ISREF_P(free_op_data)) {
53853 if (Z_REFCOUNTED_P(value)) {
53854 Z_ADDREF_P(value);
53855 }
53856 zval_ptr_dtor_nogc(free_op_data);
53857 }
53858 } else if (IS_CV == IS_CONST) {
53859 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
53860 Z_ADDREF_P(value);
53861 }
53862 }
53863 } else {
53864 dim = EX_VAR(opline->op2.var);
53865 if (IS_CV == IS_CONST) {
53866 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53867 } else {
53868 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
53869 }
53870 if (UNEXPECTED(variable_ptr == NULL)) {
53871 goto assign_dim_error;
53872 }
53873 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
53874 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
53875 }
53876 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53877 ZVAL_COPY(EX_VAR(opline->result.var), value);
53878 }
53879 if (garbage) {
53880 GC_DTOR_NO_REF(garbage);
53881 }
53882 } else {
53883 if (EXPECTED(Z_ISREF_P(object_ptr))) {
53884 object_ptr = Z_REFVAL_P(object_ptr);
53885 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
53886 goto try_assign_dim_array;
53887 }
53888 }
53889 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
53890 zend_object *obj = Z_OBJ_P(object_ptr);
53891
53892 GC_ADDREF(obj);
53893 dim = EX_VAR(opline->op2.var);
53894 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
53895 dim = ZVAL_UNDEFINED_OP2();
53896 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
53897 dim++;
53898 }
53899
53900 value = EX_VAR((opline+1)->op1.var);
53901 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
53902 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
53903 } else if (IS_CV & (IS_CV|IS_VAR)) {
53904 ZVAL_DEREF(value);
53905 }
53906
53907 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
53908
53909 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
53910 zend_objects_store_del(obj);
53911 }
53912 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
53913 if (IS_CV == IS_UNUSED) {
53914 zend_use_new_element_for_string();
53915
53916 UNDEF_RESULT();
53917 } else {
53918 dim = EX_VAR(opline->op2.var);
53919 value = EX_VAR((opline+1)->op1.var);
53920 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
53921
53922 }
53923 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
53924 if (Z_ISREF_P(orig_object_ptr)
53925 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
53926 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
53927 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53928
53929 UNDEF_RESULT();
53930 } else {
53931 HashTable *ht = zend_new_array(8);
53932 uint8_t old_type = Z_TYPE_P(object_ptr);
53933
53934 ZVAL_ARR(object_ptr, ht);
53935 if (UNEXPECTED(old_type == IS_FALSE)) {
53936 GC_ADDREF(ht);
53937 zend_false_to_array_deprecated();
53938 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
53939 zend_array_destroy(ht);
53940 goto assign_dim_error;
53941 }
53942 }
53943 goto try_assign_dim_array;
53944 }
53945 } else {
53946 zend_use_scalar_as_array();
53947 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53948 assign_dim_error:
53949
53950 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
53951 ZVAL_NULL(EX_VAR(opline->result.var));
53952 }
53953 }
53954 }
53955 if (IS_CV != IS_UNUSED) {
53956
53957 }
53958
53959 /* assign_dim has two opcodes! */
53960 ZEND_VM_NEXT_OPCODE_EX(1, 2);
53961 }
53962
ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53963 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53964 {
53965 USE_OPLINE
53966 zval *value;
53967 zval *variable_ptr;
53968
53969 SAVE_OPLINE();
53970 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53971 variable_ptr = EX_VAR(opline->op1.var);
53972
53973 if (0 || UNEXPECTED(0)) {
53974 zend_refcounted *garbage = NULL;
53975
53976 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
53977 if (UNEXPECTED(0)) {
53978 ZVAL_COPY(EX_VAR(opline->result.var), value);
53979 }
53980 if (garbage) {
53981 GC_DTOR_NO_REF(garbage);
53982 }
53983 } else {
53984 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
53985 }
53986
53987 /* zend_assign_to_variable() always takes care of op2, never free it! */
53988
53989 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
53990 }
53991
ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53992 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53993 {
53994 USE_OPLINE
53995 zval *value;
53996 zval *variable_ptr;
53997
53998 SAVE_OPLINE();
53999 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54000 variable_ptr = EX_VAR(opline->op1.var);
54001
54002 if (0 || UNEXPECTED(1)) {
54003 zend_refcounted *garbage = NULL;
54004
54005 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
54006 if (UNEXPECTED(1)) {
54007 ZVAL_COPY(EX_VAR(opline->result.var), value);
54008 }
54009 if (garbage) {
54010 GC_DTOR_NO_REF(garbage);
54011 }
54012 } else {
54013 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
54014 }
54015
54016 /* zend_assign_to_variable() always takes care of op2, never free it! */
54017
54018 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54019 }
54020
ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54021 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54022 {
54023 USE_OPLINE
54024 zval *variable_ptr;
54025 zval *value_ptr;
54026 zend_refcounted *garbage = NULL;
54027
54028 SAVE_OPLINE();
54029 value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
54030 variable_ptr = EX_VAR(opline->op1.var);
54031
54032 if (IS_CV == IS_VAR &&
54033 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
54034
54035 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
54036 variable_ptr = &EG(uninitialized_zval);
54037 } else if (IS_CV == IS_VAR &&
54038 opline->extended_value == ZEND_RETURNS_FUNCTION &&
54039 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
54040
54041 variable_ptr = zend_wrong_assign_to_variable_reference(
54042 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
54043 } else {
54044 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
54045 }
54046
54047 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
54048 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
54049 }
54050
54051 if (garbage) {
54052 GC_DTOR(garbage);
54053 }
54054
54055
54056 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54057 }
54058
ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54059 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54060 {
54061 USE_OPLINE
54062 zval *property, *container, *value_ptr;
54063
54064 SAVE_OPLINE();
54065
54066 container = EX_VAR(opline->op1.var);
54067 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54068
54069 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
54070
54071 if (1) {
54072 if (IS_CV == IS_UNUSED) {
54073 if (IS_CV == IS_CONST) {
54074 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54075 } else {
54076 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54077 }
54078 } else {
54079 if (IS_CV == IS_CONST) {
54080 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54081 } else {
54082 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54083 }
54084 }
54085 } else {
54086 zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54087 }
54088
54089
54090 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
54091 ZEND_VM_NEXT_OPCODE_EX(1, 2);
54092 }
54093
54094 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54095 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54096 {
54097 USE_OPLINE
54098 zval *property, *container, *value_ptr;
54099
54100 SAVE_OPLINE();
54101
54102 container = EX_VAR(opline->op1.var);
54103 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54104
54105 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
54106
54107 if (1) {
54108 if (IS_CV == IS_UNUSED) {
54109 if (IS_CV == IS_CONST) {
54110 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54111 } else {
54112 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54113 }
54114 } else {
54115 if (IS_CV == IS_CONST) {
54116 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54117 } else {
54118 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54119 }
54120 }
54121 } else {
54122 zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
54123 }
54124
54125
54126
54127 ZEND_VM_NEXT_OPCODE_EX(1, 2);
54128 }
54129
54130 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54131 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54132 {
54133 USE_OPLINE
54134 zval *op1, *op2;
54135 zend_string *op1_str, *op2_str, *str;
54136
54137
54138 op1 = EX_VAR(opline->op1.var);
54139 op2 = EX_VAR(opline->op2.var);
54140 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
54141 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
54142 zend_string *op1_str = Z_STR_P(op1);
54143 zend_string *op2_str = Z_STR_P(op2);
54144 zend_string *str;
54145 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
54146
54147 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
54148 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
54149 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
54150 } else {
54151 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
54152 }
54153 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54154 zend_string_release_ex(op1_str, 0);
54155 }
54156 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
54157 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
54158 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
54159 } else {
54160 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
54161 }
54162 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54163 zend_string_release_ex(op2_str, 0);
54164 }
54165 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
54166 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
54167 size_t len = ZSTR_LEN(op1_str);
54168
54169 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
54170 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54171 GC_ADD_FLAGS(str, flags);
54172 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54173 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54174 zend_string_release_ex(op2_str, 0);
54175 }
54176 } else {
54177 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
54178 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
54179 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54180 GC_ADD_FLAGS(str, flags);
54181 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54182 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54183 zend_string_release_ex(op1_str, 0);
54184 }
54185 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
54186 zend_string_release_ex(op2_str, 0);
54187 }
54188 }
54189 ZEND_VM_NEXT_OPCODE();
54190 }
54191
54192 SAVE_OPLINE();
54193 if (IS_CV == IS_CONST) {
54194 op1_str = Z_STR_P(op1);
54195 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
54196 op1_str = zend_string_copy(Z_STR_P(op1));
54197 } else {
54198 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
54199 ZVAL_UNDEFINED_OP1();
54200 }
54201 op1_str = zval_get_string_func(op1);
54202 }
54203 if (IS_CV == IS_CONST) {
54204 op2_str = Z_STR_P(op2);
54205 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
54206 op2_str = zend_string_copy(Z_STR_P(op2));
54207 } else {
54208 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
54209 ZVAL_UNDEFINED_OP2();
54210 }
54211 op2_str = zval_get_string_func(op2);
54212 }
54213 do {
54214 if (IS_CV != IS_CONST) {
54215 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
54216 if (IS_CV == IS_CONST) {
54217 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
54218 GC_ADDREF(op2_str);
54219 }
54220 }
54221 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
54222 zend_string_release_ex(op1_str, 0);
54223 break;
54224 }
54225 }
54226 if (IS_CV != IS_CONST) {
54227 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
54228 if (IS_CV == IS_CONST) {
54229 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
54230 GC_ADDREF(op1_str);
54231 }
54232 }
54233 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
54234 zend_string_release_ex(op2_str, 0);
54235 break;
54236 }
54237 }
54238 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
54239 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
54240 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
54241
54242 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
54243 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
54244 if (IS_CV != IS_CONST) {
54245 zend_string_release_ex(op1_str, 0);
54246 }
54247 if (IS_CV != IS_CONST) {
54248 zend_string_release_ex(op2_str, 0);
54249 }
54250 } while (0);
54251
54252
54253 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54254 }
54255
ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54256 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54257 {
54258 USE_OPLINE
54259 zval *function_name;
54260 zval *object;
54261 zend_function *fbc;
54262 zend_class_entry *called_scope;
54263 zend_object *obj;
54264 zend_execute_data *call;
54265 uint32_t call_info;
54266
54267 SAVE_OPLINE();
54268
54269 object = EX_VAR(opline->op1.var);
54270
54271 if (IS_CV != IS_CONST) {
54272 function_name = EX_VAR(opline->op2.var);
54273 }
54274
54275 if (IS_CV != IS_CONST &&
54276 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
54277 do {
54278 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
54279 function_name = Z_REFVAL_P(function_name);
54280 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
54281 break;
54282 }
54283 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
54284 ZVAL_UNDEFINED_OP2();
54285 if (UNEXPECTED(EG(exception) != NULL)) {
54286
54287 HANDLE_EXCEPTION();
54288 }
54289 }
54290 zend_throw_error(NULL, "Method name must be a string");
54291
54292
54293 HANDLE_EXCEPTION();
54294 } while (0);
54295 }
54296
54297 if (IS_CV == IS_UNUSED) {
54298 obj = Z_OBJ_P(object);
54299 } else {
54300 do {
54301 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
54302 obj = Z_OBJ_P(object);
54303 } else {
54304 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
54305 zend_reference *ref = Z_REF_P(object);
54306
54307 object = &ref->val;
54308 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
54309 obj = Z_OBJ_P(object);
54310 if (IS_CV & IS_VAR) {
54311 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
54312 efree_size(ref, sizeof(zend_reference));
54313 } else {
54314 Z_ADDREF_P(object);
54315 }
54316 }
54317 break;
54318 }
54319 }
54320 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
54321 object = ZVAL_UNDEFINED_OP1();
54322 if (UNEXPECTED(EG(exception) != NULL)) {
54323 if (IS_CV != IS_CONST) {
54324
54325 }
54326 HANDLE_EXCEPTION();
54327 }
54328 }
54329 if (IS_CV == IS_CONST) {
54330 function_name = EX_VAR(opline->op2.var);
54331 }
54332 zend_invalid_method_call(object, function_name);
54333
54334
54335 HANDLE_EXCEPTION();
54336 }
54337 } while (0);
54338 }
54339
54340 called_scope = obj->ce;
54341
54342 if (IS_CV == IS_CONST &&
54343 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
54344 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
54345 } else {
54346 zend_object *orig_obj = obj;
54347
54348 if (IS_CV == IS_CONST) {
54349 function_name = EX_VAR(opline->op2.var);
54350 }
54351
54352 /* First, locate the function. */
54353 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
54354 if (UNEXPECTED(fbc == NULL)) {
54355 if (EXPECTED(!EG(exception))) {
54356 zend_undefined_method(obj->ce, Z_STR_P(function_name));
54357 }
54358
54359 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
54360 zend_objects_store_del(orig_obj);
54361 }
54362 HANDLE_EXCEPTION();
54363 }
54364 if (IS_CV == IS_CONST &&
54365 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
54366 EXPECTED(obj == orig_obj)) {
54367 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
54368 }
54369 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
54370 GC_ADDREF(obj); /* For $this pointer */
54371 if (GC_DELREF(orig_obj) == 0) {
54372 zend_objects_store_del(orig_obj);
54373 }
54374 }
54375 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
54376 init_func_run_time_cache(&fbc->op_array);
54377 }
54378 }
54379
54380 if (IS_CV != IS_CONST) {
54381
54382 }
54383
54384 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
54385 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
54386 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
54387 zend_objects_store_del(obj);
54388 if (UNEXPECTED(EG(exception))) {
54389 HANDLE_EXCEPTION();
54390 }
54391 }
54392 /* call static method */
54393 obj = (zend_object*)called_scope;
54394 call_info = ZEND_CALL_NESTED_FUNCTION;
54395 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
54396 if (IS_CV == IS_CV) {
54397 GC_ADDREF(obj); /* For $this pointer */
54398 }
54399 /* CV may be changed indirectly (e.g. when it's a reference) */
54400 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
54401 }
54402
54403 call = zend_vm_stack_push_call_frame(call_info,
54404 fbc, opline->extended_value, obj);
54405 call->prev_execute_data = EX(call);
54406 EX(call) = call;
54407
54408 ZEND_VM_NEXT_OPCODE();
54409 }
54410
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54411 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54412 {
54413 USE_OPLINE
54414 zval *expr_ptr, new_expr;
54415
54416 SAVE_OPLINE();
54417 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
54418 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
54419 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
54420 if (Z_ISREF_P(expr_ptr)) {
54421 Z_ADDREF_P(expr_ptr);
54422 } else {
54423 ZVAL_MAKE_REF_EX(expr_ptr, 2);
54424 }
54425
54426 } else {
54427 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
54428 if (IS_CV == IS_TMP_VAR) {
54429 /* pass */
54430 } else if (IS_CV == IS_CONST) {
54431 Z_TRY_ADDREF_P(expr_ptr);
54432 } else if (IS_CV == IS_CV) {
54433 ZVAL_DEREF(expr_ptr);
54434 Z_TRY_ADDREF_P(expr_ptr);
54435 } else /* if (IS_CV == IS_VAR) */ {
54436 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
54437 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
54438
54439 expr_ptr = Z_REFVAL_P(expr_ptr);
54440 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
54441 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
54442 expr_ptr = &new_expr;
54443 efree_size(ref, sizeof(zend_reference));
54444 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
54445 Z_ADDREF_P(expr_ptr);
54446 }
54447 }
54448 }
54449 }
54450
54451 if (IS_CV != IS_UNUSED) {
54452 zval *offset = EX_VAR(opline->op2.var);
54453 zend_string *str;
54454 zend_ulong hval;
54455
54456 add_again:
54457 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54458 str = Z_STR_P(offset);
54459 if (IS_CV != IS_CONST) {
54460 if (ZEND_HANDLE_NUMERIC(str, hval)) {
54461 goto num_index;
54462 }
54463 }
54464 str_index:
54465 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
54466 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54467 hval = Z_LVAL_P(offset);
54468 num_index:
54469 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
54470 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
54471 offset = Z_REFVAL_P(offset);
54472 goto add_again;
54473 } else if (Z_TYPE_P(offset) == IS_NULL) {
54474 str = ZSTR_EMPTY_ALLOC();
54475 goto str_index;
54476 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
54477 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
54478 goto num_index;
54479 } else if (Z_TYPE_P(offset) == IS_FALSE) {
54480 hval = 0;
54481 goto num_index;
54482 } else if (Z_TYPE_P(offset) == IS_TRUE) {
54483 hval = 1;
54484 goto num_index;
54485 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
54486 zend_use_resource_as_offset(offset);
54487 hval = Z_RES_HANDLE_P(offset);
54488 goto num_index;
54489 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
54490 ZVAL_UNDEFINED_OP2();
54491 str = ZSTR_EMPTY_ALLOC();
54492 goto str_index;
54493 } else {
54494 zend_illegal_array_offset_access(offset);
54495 zval_ptr_dtor_nogc(expr_ptr);
54496 }
54497
54498 } else {
54499 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
54500 zend_cannot_add_element();
54501 zval_ptr_dtor_nogc(expr_ptr);
54502 }
54503 }
54504 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54505 }
54506
ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54507 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54508 {
54509 zval *array;
54510 uint32_t size;
54511 USE_OPLINE
54512
54513 array = EX_VAR(opline->result.var);
54514 if (IS_CV != IS_UNUSED) {
54515 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
54516 ZVAL_ARR(array, zend_new_array(size));
54517 /* Explicitly initialize array as not-packed if flag is set */
54518 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
54519 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
54520 }
54521 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
54522 } else {
54523 ZVAL_ARR(array, zend_new_array(0));
54524 ZEND_VM_NEXT_OPCODE();
54525 }
54526 }
54527
ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54528 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54529 {
54530 USE_OPLINE
54531 zval *container;
54532 zval *offset;
54533 zend_ulong hval;
54534 zend_string *key;
54535
54536 SAVE_OPLINE();
54537 container = EX_VAR(opline->op1.var);
54538 offset = EX_VAR(opline->op2.var);
54539
54540 do {
54541 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54542 HashTable *ht;
54543
54544 unset_dim_array:
54545 SEPARATE_ARRAY(container);
54546 ht = Z_ARRVAL_P(container);
54547 offset_again:
54548 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54549 key = Z_STR_P(offset);
54550 if (IS_CV != IS_CONST) {
54551 if (ZEND_HANDLE_NUMERIC(key, hval)) {
54552 goto num_index_dim;
54553 }
54554 }
54555 str_index_dim:
54556 ZEND_ASSERT(ht != &EG(symbol_table));
54557 zend_hash_del(ht, key);
54558 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54559 hval = Z_LVAL_P(offset);
54560 num_index_dim:
54561 zend_hash_index_del(ht, hval);
54562 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
54563 offset = Z_REFVAL_P(offset);
54564 goto offset_again;
54565 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
54566 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
54567 goto num_index_dim;
54568 } else if (Z_TYPE_P(offset) == IS_NULL) {
54569 key = ZSTR_EMPTY_ALLOC();
54570 goto str_index_dim;
54571 } else if (Z_TYPE_P(offset) == IS_FALSE) {
54572 hval = 0;
54573 goto num_index_dim;
54574 } else if (Z_TYPE_P(offset) == IS_TRUE) {
54575 hval = 1;
54576 goto num_index_dim;
54577 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
54578 zend_use_resource_as_offset(offset);
54579 hval = Z_RES_HANDLE_P(offset);
54580 goto num_index_dim;
54581 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
54582 ZVAL_UNDEFINED_OP2();
54583 key = ZSTR_EMPTY_ALLOC();
54584 goto str_index_dim;
54585 } else {
54586 zend_illegal_array_offset_unset(offset);
54587 }
54588 break;
54589 } else if (Z_ISREF_P(container)) {
54590 container = Z_REFVAL_P(container);
54591 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54592 goto unset_dim_array;
54593 }
54594 }
54595 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
54596 container = ZVAL_UNDEFINED_OP1();
54597 }
54598 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
54599 offset = ZVAL_UNDEFINED_OP2();
54600 }
54601 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
54602 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
54603 offset++;
54604 }
54605 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
54606 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
54607 zend_throw_error(NULL, "Cannot unset string offsets");
54608 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
54609 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
54610 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
54611 zend_false_to_array_deprecated();
54612 }
54613 } while (0);
54614
54615
54616 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54617 }
54618
ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54619 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54620 {
54621 USE_OPLINE
54622 zval *container;
54623 zval *offset;
54624 zend_string *name, *tmp_name;
54625
54626 SAVE_OPLINE();
54627 container = EX_VAR(opline->op1.var);
54628 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54629
54630 do {
54631 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
54632 if (Z_ISREF_P(container)) {
54633 container = Z_REFVAL_P(container);
54634 if (Z_TYPE_P(container) != IS_OBJECT) {
54635 if (IS_CV == IS_CV
54636 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
54637 ZVAL_UNDEFINED_OP1();
54638 }
54639 break;
54640 }
54641 } else {
54642 break;
54643 }
54644 }
54645 if (IS_CV == IS_CONST) {
54646 name = Z_STR_P(offset);
54647 } else {
54648 name = zval_try_get_tmp_string(offset, &tmp_name);
54649 if (UNEXPECTED(!name)) {
54650 break;
54651 }
54652 }
54653 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
54654 if (IS_CV != IS_CONST) {
54655 zend_tmp_string_release(tmp_name);
54656 }
54657 } while (0);
54658
54659
54660 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
54661 }
54662
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54663 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54664 {
54665 USE_OPLINE
54666 zval *container;
54667 bool result;
54668 zend_ulong hval;
54669 zval *offset;
54670
54671 SAVE_OPLINE();
54672 container = EX_VAR(opline->op1.var);
54673 offset = EX_VAR(opline->op2.var);
54674
54675 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54676 HashTable *ht;
54677 zval *value;
54678 zend_string *str;
54679
54680 isset_dim_obj_array:
54681 ht = Z_ARRVAL_P(container);
54682 isset_again:
54683 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
54684 str = Z_STR_P(offset);
54685 if (IS_CV != IS_CONST) {
54686 if (ZEND_HANDLE_NUMERIC(str, hval)) {
54687 goto num_index_prop;
54688 }
54689 }
54690 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
54691 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
54692 hval = Z_LVAL_P(offset);
54693 num_index_prop:
54694 value = zend_hash_index_find(ht, hval);
54695 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
54696 offset = Z_REFVAL_P(offset);
54697 goto isset_again;
54698 } else {
54699 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
54700 if (UNEXPECTED(EG(exception))) {
54701 result = 0;
54702 goto isset_dim_obj_exit;
54703 }
54704 }
54705
54706 if (!(opline->extended_value & ZEND_ISEMPTY)) {
54707 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
54708 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
54709 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
54710
54711 if (IS_CV & (IS_CONST|IS_CV)) {
54712 /* avoid exception check */
54713
54714 ZEND_VM_SMART_BRANCH(result, 0);
54715 }
54716 } else {
54717 result = (value == NULL || !i_zend_is_true(value));
54718 }
54719 goto isset_dim_obj_exit;
54720 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
54721 container = Z_REFVAL_P(container);
54722 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
54723 goto isset_dim_obj_array;
54724 }
54725 }
54726
54727 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
54728 offset++;
54729 }
54730 if (!(opline->extended_value & ZEND_ISEMPTY)) {
54731 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
54732 } else {
54733 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
54734 }
54735
54736 isset_dim_obj_exit:
54737
54738
54739 ZEND_VM_SMART_BRANCH(result, 1);
54740 }
54741
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54742 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54743 {
54744 USE_OPLINE
54745 zval *container;
54746 int result;
54747 zval *offset;
54748 zend_string *name, *tmp_name;
54749
54750 SAVE_OPLINE();
54751 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
54752 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54753
54754 if (IS_CV == IS_CONST ||
54755 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
54756 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
54757 container = Z_REFVAL_P(container);
54758 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
54759 result = (opline->extended_value & ZEND_ISEMPTY);
54760 goto isset_object_finish;
54761 }
54762 } else {
54763 result = (opline->extended_value & ZEND_ISEMPTY);
54764 goto isset_object_finish;
54765 }
54766 }
54767
54768 if (IS_CV == IS_CONST) {
54769 name = Z_STR_P(offset);
54770 } else {
54771 name = zval_try_get_tmp_string(offset, &tmp_name);
54772 if (UNEXPECTED(!name)) {
54773 result = 0;
54774 goto isset_object_finish;
54775 }
54776 }
54777
54778 result =
54779 (opline->extended_value & ZEND_ISEMPTY) ^
54780 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));
54781
54782 if (IS_CV != IS_CONST) {
54783 zend_tmp_string_release(tmp_name);
54784 }
54785
54786 isset_object_finish:
54787
54788
54789 ZEND_VM_SMART_BRANCH(result, 1);
54790 }
54791
ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54792 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54793 {
54794 USE_OPLINE
54795
54796 zval *key, *subject;
54797 HashTable *ht;
54798 bool result;
54799
54800 SAVE_OPLINE();
54801
54802 key = EX_VAR(opline->op1.var);
54803 subject = EX_VAR(opline->op2.var);
54804
54805 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
54806 array_key_exists_array:
54807 ht = Z_ARRVAL_P(subject);
54808 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
54809 } else {
54810 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
54811 subject = Z_REFVAL_P(subject);
54812 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
54813 goto array_key_exists_array;
54814 }
54815 }
54816 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
54817 result = 0;
54818 }
54819
54820
54821 ZEND_VM_SMART_BRANCH(result, 1);
54822 }
54823
ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54824 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54825 {
54826 USE_OPLINE
54827
54828 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
54829
54830 SAVE_OPLINE();
54831 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
54832 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
54833 }
54834
54835 /* Destroy the previously yielded value */
54836 zval_ptr_dtor(&generator->value);
54837
54838 /* Destroy the previously yielded key */
54839 zval_ptr_dtor(&generator->key);
54840
54841 /* Set the new yielded value */
54842 if (IS_CV != IS_UNUSED) {
54843 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
54844 /* Constants and temporary variables aren't yieldable by reference,
54845 * but we still allow them with a notice. */
54846 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
54847 zval *value;
54848
54849 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
54850
54851 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
54852 ZVAL_COPY_VALUE(&generator->value, value);
54853 if (IS_CV == IS_CONST) {
54854 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
54855 Z_ADDREF(generator->value);
54856 }
54857 }
54858 } else {
54859 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
54860
54861 /* If a function call result is yielded and the function did
54862 * not return by reference we throw a notice. */
54863 do {
54864 if (IS_CV == IS_VAR) {
54865 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
54866 if (opline->extended_value == ZEND_RETURNS_FUNCTION
54867 && !Z_ISREF_P(value_ptr)) {
54868 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
54869 ZVAL_COPY(&generator->value, value_ptr);
54870 break;
54871 }
54872 }
54873 if (Z_ISREF_P(value_ptr)) {
54874 Z_ADDREF_P(value_ptr);
54875 } else {
54876 ZVAL_MAKE_REF_EX(value_ptr, 2);
54877 }
54878 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
54879 } while (0);
54880
54881 }
54882 } else {
54883 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
54884
54885 /* Consts, temporary variables and references need copying */
54886 if (IS_CV == IS_CONST) {
54887 ZVAL_COPY_VALUE(&generator->value, value);
54888 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
54889 Z_ADDREF(generator->value);
54890 }
54891 } else if (IS_CV == IS_TMP_VAR) {
54892 ZVAL_COPY_VALUE(&generator->value, value);
54893 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
54894 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
54895
54896 } else {
54897 ZVAL_COPY_VALUE(&generator->value, value);
54898 if (IS_CV == IS_CV) {
54899 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
54900 }
54901 }
54902 }
54903 } else {
54904 /* If no value was specified yield null */
54905 ZVAL_NULL(&generator->value);
54906 }
54907
54908 /* Set the new yielded key */
54909 if (IS_CV != IS_UNUSED) {
54910 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
54911 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
54912 key = Z_REFVAL_P(key);
54913 }
54914 ZVAL_COPY(&generator->key, key);
54915
54916 if (Z_TYPE(generator->key) == IS_LONG
54917 && Z_LVAL(generator->key) > generator->largest_used_integer_key
54918 ) {
54919 generator->largest_used_integer_key = Z_LVAL(generator->key);
54920 }
54921 } else {
54922 /* If no key was specified we use auto-increment keys */
54923 generator->largest_used_integer_key++;
54924 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
54925 }
54926
54927 if (RETURN_VALUE_USED(opline)) {
54928 /* If the return value of yield is used set the send
54929 * target and initialize it to NULL */
54930 generator->send_target = EX_VAR(opline->result.var);
54931 ZVAL_NULL(generator->send_target);
54932 } else {
54933 generator->send_target = NULL;
54934 }
54935
54936 /* The GOTO VM uses a local opline variable. We need to set the opline
54937 * variable in execute_data so we don't resume at an old position. */
54938 SAVE_OPLINE();
54939
54940 ZEND_VM_RETURN();
54941 }
54942
ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54943 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54944 {
54945 /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
54946 /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
54947 /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
54948 USE_OPLINE
54949 zval *op1, *op2;
54950 bool result;
54951
54952 op1 = EX_VAR(opline->op1.var);
54953 op2 = EX_VAR(opline->op2.var);
54954 result = fast_is_identical_function(op1, op2);
54955 /* Free is a no-op for const/cv */
54956 ZEND_VM_SMART_BRANCH(result, 0);
54957 }
54958
ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54959 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54960 {
54961 USE_OPLINE
54962 zval *op1, *op2;
54963 bool result;
54964
54965 op1 = EX_VAR(opline->op1.var);
54966 op2 = EX_VAR(opline->op2.var);
54967 result = fast_is_identical_function(op1, op2);
54968 /* Free is a no-op for const/cv */
54969 ZEND_VM_SMART_BRANCH(!result, 0);
54970 }
54971
ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)54972 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
54973 {
54974 USE_OPLINE
54975
54976 SAVE_OPLINE();
54977 zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);
54978 ZEND_VM_NEXT_OPCODE(); /* Never reached */
54979 }
54980
54981
54982 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
54983 # undef ZEND_VM_TAIL_CALL
54984 # undef ZEND_VM_CONTINUE
54985 # undef ZEND_VM_RETURN
54986
54987 # define ZEND_VM_TAIL_CALL(call) call; ZEND_VM_CONTINUE()
54988 # define ZEND_VM_CONTINUE() HYBRID_NEXT()
54989 # define ZEND_VM_RETURN() goto HYBRID_HALT_LABEL
54990 #endif
54991
54992
54993 #if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
54994 # pragma GCC push_options
54995 # pragma GCC optimize("no-gcse")
54996 # pragma GCC optimize("no-ivopts")
54997 #endif
execute_ex(zend_execute_data * ex)54998 ZEND_API void execute_ex(zend_execute_data *ex)
54999 {
55000 DCL_OPLINE
55001
55002 #if defined(ZEND_VM_IP_GLOBAL_REG) || defined(ZEND_VM_FP_GLOBAL_REG)
55003 struct {
55004 #ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
55005 char hybrid_jit_red_zone[ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE];
55006 #endif
55007 #ifdef ZEND_VM_IP_GLOBAL_REG
55008 const zend_op *orig_opline;
55009 #endif
55010 #ifdef ZEND_VM_FP_GLOBAL_REG
55011 zend_execute_data *orig_execute_data;
55012 #endif
55013 } vm_stack_data;
55014 #endif
55015 #ifdef ZEND_VM_IP_GLOBAL_REG
55016 vm_stack_data.orig_opline = opline;
55017 #endif
55018 #ifdef ZEND_VM_FP_GLOBAL_REG
55019 vm_stack_data.orig_execute_data = execute_data;
55020 execute_data = ex;
55021 #else
55022 zend_execute_data *execute_data = ex;
55023 #endif
55024
55025 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
55026 if (UNEXPECTED(execute_data == NULL)) {
55027 static const void * const labels[] = {
55028 (void*)&&ZEND_NOP_SPEC_LABEL,
55029 (void*)&&ZEND_ADD_SPEC_CONST_CONST_LABEL,
55030 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55031 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55032 (void*)&&ZEND_NULL_LABEL,
55033 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
55034 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55035 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55036 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55037 (void*)&&ZEND_NULL_LABEL,
55038 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55039 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55040 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55041 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55042 (void*)&&ZEND_NULL_LABEL,
55043 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55044 (void*)&&ZEND_NULL_LABEL,
55045 (void*)&&ZEND_NULL_LABEL,
55046 (void*)&&ZEND_NULL_LABEL,
55047 (void*)&&ZEND_NULL_LABEL,
55048 (void*)&&ZEND_NULL_LABEL,
55049 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
55050 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55051 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55052 (void*)&&ZEND_NULL_LABEL,
55053 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55054 (void*)&&ZEND_SUB_SPEC_CONST_CONST_LABEL,
55055 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55056 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55057 (void*)&&ZEND_NULL_LABEL,
55058 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
55059 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55060 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55061 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55062 (void*)&&ZEND_NULL_LABEL,
55063 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55064 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55065 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55066 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55067 (void*)&&ZEND_NULL_LABEL,
55068 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55069 (void*)&&ZEND_NULL_LABEL,
55070 (void*)&&ZEND_NULL_LABEL,
55071 (void*)&&ZEND_NULL_LABEL,
55072 (void*)&&ZEND_NULL_LABEL,
55073 (void*)&&ZEND_NULL_LABEL,
55074 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
55075 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55076 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55077 (void*)&&ZEND_NULL_LABEL,
55078 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
55079 (void*)&&ZEND_MUL_SPEC_CONST_CONST_LABEL,
55080 (void*)&&ZEND_NULL_LABEL,
55081 (void*)&&ZEND_NULL_LABEL,
55082 (void*)&&ZEND_NULL_LABEL,
55083 (void*)&&ZEND_NULL_LABEL,
55084 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55085 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55086 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55087 (void*)&&ZEND_NULL_LABEL,
55088 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55089 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55090 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55091 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55092 (void*)&&ZEND_NULL_LABEL,
55093 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55094 (void*)&&ZEND_NULL_LABEL,
55095 (void*)&&ZEND_NULL_LABEL,
55096 (void*)&&ZEND_NULL_LABEL,
55097 (void*)&&ZEND_NULL_LABEL,
55098 (void*)&&ZEND_NULL_LABEL,
55099 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
55100 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55101 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55102 (void*)&&ZEND_NULL_LABEL,
55103 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55104 (void*)&&ZEND_DIV_SPEC_CONST_CONST_LABEL,
55105 (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
55106 (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
55107 (void*)&&ZEND_NULL_LABEL,
55108 (void*)&&ZEND_DIV_SPEC_CONST_CV_LABEL,
55109 (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
55110 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55111 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55112 (void*)&&ZEND_NULL_LABEL,
55113 (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
55114 (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
55115 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55116 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
55117 (void*)&&ZEND_NULL_LABEL,
55118 (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
55119 (void*)&&ZEND_NULL_LABEL,
55120 (void*)&&ZEND_NULL_LABEL,
55121 (void*)&&ZEND_NULL_LABEL,
55122 (void*)&&ZEND_NULL_LABEL,
55123 (void*)&&ZEND_NULL_LABEL,
55124 (void*)&&ZEND_DIV_SPEC_CV_CONST_LABEL,
55125 (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
55126 (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
55127 (void*)&&ZEND_NULL_LABEL,
55128 (void*)&&ZEND_DIV_SPEC_CV_CV_LABEL,
55129 (void*)&&ZEND_MOD_SPEC_CONST_CONST_LABEL,
55130 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55131 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55132 (void*)&&ZEND_NULL_LABEL,
55133 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
55134 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55135 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55136 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55137 (void*)&&ZEND_NULL_LABEL,
55138 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55139 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55140 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55141 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55142 (void*)&&ZEND_NULL_LABEL,
55143 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55144 (void*)&&ZEND_NULL_LABEL,
55145 (void*)&&ZEND_NULL_LABEL,
55146 (void*)&&ZEND_NULL_LABEL,
55147 (void*)&&ZEND_NULL_LABEL,
55148 (void*)&&ZEND_NULL_LABEL,
55149 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
55150 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55151 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55152 (void*)&&ZEND_NULL_LABEL,
55153 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
55154 (void*)&&ZEND_SL_SPEC_CONST_CONST_LABEL,
55155 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55156 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55157 (void*)&&ZEND_NULL_LABEL,
55158 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
55159 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55160 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55161 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55162 (void*)&&ZEND_NULL_LABEL,
55163 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55164 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55165 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55166 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55167 (void*)&&ZEND_NULL_LABEL,
55168 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55169 (void*)&&ZEND_NULL_LABEL,
55170 (void*)&&ZEND_NULL_LABEL,
55171 (void*)&&ZEND_NULL_LABEL,
55172 (void*)&&ZEND_NULL_LABEL,
55173 (void*)&&ZEND_NULL_LABEL,
55174 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
55175 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55176 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55177 (void*)&&ZEND_NULL_LABEL,
55178 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55179 (void*)&&ZEND_SR_SPEC_CONST_CONST_LABEL,
55180 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55181 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55182 (void*)&&ZEND_NULL_LABEL,
55183 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
55184 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55185 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55186 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55187 (void*)&&ZEND_NULL_LABEL,
55188 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55189 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55190 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55191 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55192 (void*)&&ZEND_NULL_LABEL,
55193 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55194 (void*)&&ZEND_NULL_LABEL,
55195 (void*)&&ZEND_NULL_LABEL,
55196 (void*)&&ZEND_NULL_LABEL,
55197 (void*)&&ZEND_NULL_LABEL,
55198 (void*)&&ZEND_NULL_LABEL,
55199 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
55200 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55201 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55202 (void*)&&ZEND_NULL_LABEL,
55203 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55204 (void*)&&ZEND_NULL_LABEL,
55205 (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
55206 (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
55207 (void*)&&ZEND_NULL_LABEL,
55208 (void*)&&ZEND_CONCAT_SPEC_CONST_CV_LABEL,
55209 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
55210 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55211 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55212 (void*)&&ZEND_NULL_LABEL,
55213 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
55214 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
55215 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55216 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
55217 (void*)&&ZEND_NULL_LABEL,
55218 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
55219 (void*)&&ZEND_NULL_LABEL,
55220 (void*)&&ZEND_NULL_LABEL,
55221 (void*)&&ZEND_NULL_LABEL,
55222 (void*)&&ZEND_NULL_LABEL,
55223 (void*)&&ZEND_NULL_LABEL,
55224 (void*)&&ZEND_CONCAT_SPEC_CV_CONST_LABEL,
55225 (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
55226 (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
55227 (void*)&&ZEND_NULL_LABEL,
55228 (void*)&&ZEND_CONCAT_SPEC_CV_CV_LABEL,
55229 (void*)&&ZEND_BW_OR_SPEC_CONST_CONST_LABEL,
55230 (void*)&&ZEND_NULL_LABEL,
55231 (void*)&&ZEND_NULL_LABEL,
55232 (void*)&&ZEND_NULL_LABEL,
55233 (void*)&&ZEND_NULL_LABEL,
55234 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55235 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55236 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55237 (void*)&&ZEND_NULL_LABEL,
55238 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55239 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55240 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55241 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55242 (void*)&&ZEND_NULL_LABEL,
55243 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55244 (void*)&&ZEND_NULL_LABEL,
55245 (void*)&&ZEND_NULL_LABEL,
55246 (void*)&&ZEND_NULL_LABEL,
55247 (void*)&&ZEND_NULL_LABEL,
55248 (void*)&&ZEND_NULL_LABEL,
55249 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
55250 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55251 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55252 (void*)&&ZEND_NULL_LABEL,
55253 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55254 (void*)&&ZEND_BW_AND_SPEC_CONST_CONST_LABEL,
55255 (void*)&&ZEND_NULL_LABEL,
55256 (void*)&&ZEND_NULL_LABEL,
55257 (void*)&&ZEND_NULL_LABEL,
55258 (void*)&&ZEND_NULL_LABEL,
55259 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55260 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55261 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55262 (void*)&&ZEND_NULL_LABEL,
55263 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55264 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55265 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55266 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55267 (void*)&&ZEND_NULL_LABEL,
55268 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55269 (void*)&&ZEND_NULL_LABEL,
55270 (void*)&&ZEND_NULL_LABEL,
55271 (void*)&&ZEND_NULL_LABEL,
55272 (void*)&&ZEND_NULL_LABEL,
55273 (void*)&&ZEND_NULL_LABEL,
55274 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
55275 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55276 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55277 (void*)&&ZEND_NULL_LABEL,
55278 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
55279 (void*)&&ZEND_BW_XOR_SPEC_CONST_CONST_LABEL,
55280 (void*)&&ZEND_NULL_LABEL,
55281 (void*)&&ZEND_NULL_LABEL,
55282 (void*)&&ZEND_NULL_LABEL,
55283 (void*)&&ZEND_NULL_LABEL,
55284 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55285 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55286 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55287 (void*)&&ZEND_NULL_LABEL,
55288 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55289 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55290 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55291 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55292 (void*)&&ZEND_NULL_LABEL,
55293 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55294 (void*)&&ZEND_NULL_LABEL,
55295 (void*)&&ZEND_NULL_LABEL,
55296 (void*)&&ZEND_NULL_LABEL,
55297 (void*)&&ZEND_NULL_LABEL,
55298 (void*)&&ZEND_NULL_LABEL,
55299 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
55300 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55301 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55302 (void*)&&ZEND_NULL_LABEL,
55303 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
55304 (void*)&&ZEND_POW_SPEC_CONST_CONST_LABEL,
55305 (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
55306 (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
55307 (void*)&&ZEND_NULL_LABEL,
55308 (void*)&&ZEND_POW_SPEC_CONST_CV_LABEL,
55309 (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
55310 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55311 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55312 (void*)&&ZEND_NULL_LABEL,
55313 (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
55314 (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
55315 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55316 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
55317 (void*)&&ZEND_NULL_LABEL,
55318 (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
55319 (void*)&&ZEND_NULL_LABEL,
55320 (void*)&&ZEND_NULL_LABEL,
55321 (void*)&&ZEND_NULL_LABEL,
55322 (void*)&&ZEND_NULL_LABEL,
55323 (void*)&&ZEND_NULL_LABEL,
55324 (void*)&&ZEND_POW_SPEC_CV_CONST_LABEL,
55325 (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
55326 (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
55327 (void*)&&ZEND_NULL_LABEL,
55328 (void*)&&ZEND_POW_SPEC_CV_CV_LABEL,
55329 (void*)&&ZEND_BW_NOT_SPEC_CONST_LABEL,
55330 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55331 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55332 (void*)&&ZEND_NULL_LABEL,
55333 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
55334 (void*)&&ZEND_BOOL_NOT_SPEC_CONST_LABEL,
55335 (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
55336 (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
55337 (void*)&&ZEND_NULL_LABEL,
55338 (void*)&&ZEND_BOOL_NOT_SPEC_CV_LABEL,
55339 (void*)&&ZEND_BOOL_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_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
55345 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55346 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55347 (void*)&&ZEND_NULL_LABEL,
55348 (void*)&&ZEND_NULL_LABEL,
55349 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
55350 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55351 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
55352 (void*)&&ZEND_NULL_LABEL,
55353 (void*)&&ZEND_NULL_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_BOOL_XOR_SPEC_CV_CONST_LABEL,
55360 (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
55361 (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
55362 (void*)&&ZEND_NULL_LABEL,
55363 (void*)&&ZEND_BOOL_XOR_SPEC_CV_CV_LABEL,
55364 (void*)&&ZEND_IS_IDENTICAL_SPEC_CONST_CONST_LABEL,
55365 (void*)&&ZEND_NULL_LABEL,
55366 (void*)&&ZEND_NULL_LABEL,
55367 (void*)&&ZEND_NULL_LABEL,
55368 (void*)&&ZEND_NULL_LABEL,
55369 (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_CONST_LABEL,
55370 (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_TMP_LABEL,
55371 (void*)&&ZEND_NULL_LABEL,
55372 (void*)&&ZEND_NULL_LABEL,
55373 (void*)&&ZEND_NULL_LABEL,
55374 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_CONST_LABEL,
55375 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_TMP_LABEL,
55376 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_VAR_LABEL,
55377 (void*)&&ZEND_NULL_LABEL,
55378 (void*)&&ZEND_NULL_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_IS_IDENTICAL_SPEC_CV_CONST_LABEL,
55385 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_TMP_LABEL,
55386 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_VAR_LABEL,
55387 (void*)&&ZEND_NULL_LABEL,
55388 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CV_LABEL,
55389 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_LABEL,
55390 (void*)&&ZEND_NULL_LABEL,
55391 (void*)&&ZEND_NULL_LABEL,
55392 (void*)&&ZEND_NULL_LABEL,
55393 (void*)&&ZEND_NULL_LABEL,
55394 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_LABEL,
55395 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_LABEL,
55396 (void*)&&ZEND_NULL_LABEL,
55397 (void*)&&ZEND_NULL_LABEL,
55398 (void*)&&ZEND_NULL_LABEL,
55399 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_LABEL,
55400 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_LABEL,
55401 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_LABEL,
55402 (void*)&&ZEND_NULL_LABEL,
55403 (void*)&&ZEND_NULL_LABEL,
55404 (void*)&&ZEND_NULL_LABEL,
55405 (void*)&&ZEND_NULL_LABEL,
55406 (void*)&&ZEND_NULL_LABEL,
55407 (void*)&&ZEND_NULL_LABEL,
55408 (void*)&&ZEND_NULL_LABEL,
55409 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_LABEL,
55410 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_LABEL,
55411 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_LABEL,
55412 (void*)&&ZEND_NULL_LABEL,
55413 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_LABEL,
55414 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55415 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55416 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
55417 (void*)&&ZEND_NULL_LABEL,
55418 (void*)&&ZEND_NULL_LABEL,
55419 (void*)&&ZEND_NULL_LABEL,
55420 (void*)&&ZEND_NULL_LABEL,
55421 (void*)&&ZEND_NULL_LABEL,
55422 (void*)&&ZEND_NULL_LABEL,
55423 (void*)&&ZEND_NULL_LABEL,
55424 (void*)&&ZEND_NULL_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_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55430 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55431 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55432 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55433 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55434 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55435 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55436 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55437 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55445 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55446 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55447 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55448 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55449 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55450 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55451 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55452 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55453 (void*)&&ZEND_NULL_LABEL,
55454 (void*)&&ZEND_NULL_LABEL,
55455 (void*)&&ZEND_NULL_LABEL,
55456 (void*)&&ZEND_NULL_LABEL,
55457 (void*)&&ZEND_NULL_LABEL,
55458 (void*)&&ZEND_NULL_LABEL,
55459 (void*)&&ZEND_NULL_LABEL,
55460 (void*)&&ZEND_NULL_LABEL,
55461 (void*)&&ZEND_NULL_LABEL,
55462 (void*)&&ZEND_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_NULL_LABEL,
55470 (void*)&&ZEND_NULL_LABEL,
55471 (void*)&&ZEND_NULL_LABEL,
55472 (void*)&&ZEND_NULL_LABEL,
55473 (void*)&&ZEND_NULL_LABEL,
55474 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_LABEL,
55475 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
55476 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
55477 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
55478 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55479 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55480 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
55481 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55482 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55483 (void*)&&ZEND_NULL_LABEL,
55484 (void*)&&ZEND_NULL_LABEL,
55485 (void*)&&ZEND_NULL_LABEL,
55486 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_LABEL,
55487 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
55488 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
55489 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55490 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55491 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
55492 (void*)&&ZEND_NULL_LABEL,
55493 (void*)&&ZEND_NULL_LABEL,
55494 (void*)&&ZEND_NULL_LABEL,
55495 (void*)&&ZEND_NULL_LABEL,
55496 (void*)&&ZEND_NULL_LABEL,
55497 (void*)&&ZEND_NULL_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_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55505 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55506 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55507 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55508 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55509 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55510 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55511 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55512 (void*)&&ZEND_IS_NOT_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_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
55520 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
55521 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
55522 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55523 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55524 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
55525 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
55526 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
55527 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_NULL_LABEL,
55535 (void*)&&ZEND_NULL_LABEL,
55536 (void*)&&ZEND_NULL_LABEL,
55537 (void*)&&ZEND_NULL_LABEL,
55538 (void*)&&ZEND_NULL_LABEL,
55539 (void*)&&ZEND_NULL_LABEL,
55540 (void*)&&ZEND_NULL_LABEL,
55541 (void*)&&ZEND_NULL_LABEL,
55542 (void*)&&ZEND_NULL_LABEL,
55543 (void*)&&ZEND_NULL_LABEL,
55544 (void*)&&ZEND_NULL_LABEL,
55545 (void*)&&ZEND_NULL_LABEL,
55546 (void*)&&ZEND_NULL_LABEL,
55547 (void*)&&ZEND_NULL_LABEL,
55548 (void*)&&ZEND_NULL_LABEL,
55549 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_LABEL,
55550 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
55551 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
55552 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
55553 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55554 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55555 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
55556 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
55557 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
55558 (void*)&&ZEND_NULL_LABEL,
55559 (void*)&&ZEND_NULL_LABEL,
55560 (void*)&&ZEND_NULL_LABEL,
55561 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_LABEL,
55562 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
55563 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
55564 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55565 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55566 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
55567 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55568 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55569 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55570 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55571 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55572 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55573 (void*)&&ZEND_NULL_LABEL,
55574 (void*)&&ZEND_NULL_LABEL,
55575 (void*)&&ZEND_NULL_LABEL,
55576 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
55577 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55578 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55579 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55580 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55581 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55582 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55583 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55584 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55585 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55586 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55587 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55588 (void*)&&ZEND_NULL_LABEL,
55589 (void*)&&ZEND_NULL_LABEL,
55590 (void*)&&ZEND_NULL_LABEL,
55591 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55592 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55593 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55594 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55595 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55596 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55597 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55598 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55599 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55600 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55601 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55602 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55603 (void*)&&ZEND_NULL_LABEL,
55604 (void*)&&ZEND_NULL_LABEL,
55605 (void*)&&ZEND_NULL_LABEL,
55606 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55607 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55608 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55609 (void*)&&ZEND_NULL_LABEL,
55610 (void*)&&ZEND_NULL_LABEL,
55611 (void*)&&ZEND_NULL_LABEL,
55612 (void*)&&ZEND_NULL_LABEL,
55613 (void*)&&ZEND_NULL_LABEL,
55614 (void*)&&ZEND_NULL_LABEL,
55615 (void*)&&ZEND_NULL_LABEL,
55616 (void*)&&ZEND_NULL_LABEL,
55617 (void*)&&ZEND_NULL_LABEL,
55618 (void*)&&ZEND_NULL_LABEL,
55619 (void*)&&ZEND_NULL_LABEL,
55620 (void*)&&ZEND_NULL_LABEL,
55621 (void*)&&ZEND_NULL_LABEL,
55622 (void*)&&ZEND_NULL_LABEL,
55623 (void*)&&ZEND_NULL_LABEL,
55624 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
55625 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55626 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55627 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55628 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55629 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55630 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55631 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55632 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55633 (void*)&&ZEND_NULL_LABEL,
55634 (void*)&&ZEND_NULL_LABEL,
55635 (void*)&&ZEND_NULL_LABEL,
55636 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
55637 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55638 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55639 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55640 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55641 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
55642 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55643 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55644 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55645 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55646 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55647 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55648 (void*)&&ZEND_NULL_LABEL,
55649 (void*)&&ZEND_NULL_LABEL,
55650 (void*)&&ZEND_NULL_LABEL,
55651 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
55652 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
55653 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
55654 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55655 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55656 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55657 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55658 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55659 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55660 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55661 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55662 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_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_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55667 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55668 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55669 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55670 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55671 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55672 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55673 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55674 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55675 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55676 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55677 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55678 (void*)&&ZEND_NULL_LABEL,
55679 (void*)&&ZEND_NULL_LABEL,
55680 (void*)&&ZEND_NULL_LABEL,
55681 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55682 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55683 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55684 (void*)&&ZEND_NULL_LABEL,
55685 (void*)&&ZEND_NULL_LABEL,
55686 (void*)&&ZEND_NULL_LABEL,
55687 (void*)&&ZEND_NULL_LABEL,
55688 (void*)&&ZEND_NULL_LABEL,
55689 (void*)&&ZEND_NULL_LABEL,
55690 (void*)&&ZEND_NULL_LABEL,
55691 (void*)&&ZEND_NULL_LABEL,
55692 (void*)&&ZEND_NULL_LABEL,
55693 (void*)&&ZEND_NULL_LABEL,
55694 (void*)&&ZEND_NULL_LABEL,
55695 (void*)&&ZEND_NULL_LABEL,
55696 (void*)&&ZEND_NULL_LABEL,
55697 (void*)&&ZEND_NULL_LABEL,
55698 (void*)&&ZEND_NULL_LABEL,
55699 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
55700 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
55701 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
55702 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55703 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55704 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55705 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
55706 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55707 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_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_TMPVARCV_TMPVARCV_LABEL,
55712 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
55713 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
55714 (void*)&&ZEND_NULL_LABEL,
55715 (void*)&&ZEND_NULL_LABEL,
55716 (void*)&&ZEND_NULL_LABEL,
55717 (void*)&&ZEND_NULL_LABEL,
55718 (void*)&&ZEND_NULL_LABEL,
55719 (void*)&&ZEND_NULL_LABEL,
55720 (void*)&&ZEND_NULL_LABEL,
55721 (void*)&&ZEND_NULL_LABEL,
55722 (void*)&&ZEND_NULL_LABEL,
55723 (void*)&&ZEND_NULL_LABEL,
55724 (void*)&&ZEND_NULL_LABEL,
55725 (void*)&&ZEND_NULL_LABEL,
55726 (void*)&&ZEND_NULL_LABEL,
55727 (void*)&&ZEND_NULL_LABEL,
55728 (void*)&&ZEND_NULL_LABEL,
55729 (void*)&&ZEND_NULL_LABEL,
55730 (void*)&&ZEND_NULL_LABEL,
55731 (void*)&&ZEND_NULL_LABEL,
55732 (void*)&&ZEND_NULL_LABEL,
55733 (void*)&&ZEND_NULL_LABEL,
55734 (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_LABEL,
55735 (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_LABEL,
55736 (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_LABEL,
55737 (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_LABEL,
55738 (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_LABEL,
55739 (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_LABEL,
55740 (void*)&&ZEND_NULL_LABEL,
55741 (void*)&&ZEND_NULL_LABEL,
55742 (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
55743 (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_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_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_LABEL,
55755 (void*)&&ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_LABEL,
55756 (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_LABEL,
55757 (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_LABEL,
55758 (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_LABEL,
55759 (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_LABEL,
55760 (void*)&&ZEND_NULL_LABEL,
55761 (void*)&&ZEND_NULL_LABEL,
55762 (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_LABEL,
55763 (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_LABEL,
55764 (void*)&&ZEND_NULL_LABEL,
55765 (void*)&&ZEND_NULL_LABEL,
55766 (void*)&&ZEND_NULL_LABEL,
55767 (void*)&&ZEND_NULL_LABEL,
55768 (void*)&&ZEND_NULL_LABEL,
55769 (void*)&&ZEND_NULL_LABEL,
55770 (void*)&&ZEND_NULL_LABEL,
55771 (void*)&&ZEND_NULL_LABEL,
55772 (void*)&&ZEND_NULL_LABEL,
55773 (void*)&&ZEND_NULL_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_NULL_LABEL,
55795 (void*)&&ZEND_NULL_LABEL,
55796 (void*)&&ZEND_NULL_LABEL,
55797 (void*)&&ZEND_NULL_LABEL,
55798 (void*)&&ZEND_NULL_LABEL,
55799 (void*)&&ZEND_NULL_LABEL,
55800 (void*)&&ZEND_NULL_LABEL,
55801 (void*)&&ZEND_NULL_LABEL,
55802 (void*)&&ZEND_NULL_LABEL,
55803 (void*)&&ZEND_NULL_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_DIM_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
55815 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
55816 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
55817 (void*)&&ZEND_NULL_LABEL,
55818 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
55819 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
55820 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
55821 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
55822 (void*)&&ZEND_NULL_LABEL,
55823 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
55824 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
55825 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
55826 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
55827 (void*)&&ZEND_NULL_LABEL,
55828 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
55829 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_LABEL,
55830 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_LABEL,
55831 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_LABEL,
55832 (void*)&&ZEND_NULL_LABEL,
55833 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_LABEL,
55834 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
55835 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
55836 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
55837 (void*)&&ZEND_NULL_LABEL,
55838 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_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_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
55865 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
55866 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
55867 (void*)&&ZEND_NULL_LABEL,
55868 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_LABEL,
55869 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
55870 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
55871 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
55872 (void*)&&ZEND_NULL_LABEL,
55873 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
55874 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
55875 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
55876 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
55877 (void*)&&ZEND_NULL_LABEL,
55878 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
55879 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_LABEL,
55880 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_LABEL,
55881 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_LABEL,
55882 (void*)&&ZEND_NULL_LABEL,
55883 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_LABEL,
55884 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_LABEL,
55885 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_LABEL,
55886 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_LABEL,
55887 (void*)&&ZEND_NULL_LABEL,
55888 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_LABEL,
55889 (void*)&&ZEND_NULL_LABEL,
55890 (void*)&&ZEND_NULL_LABEL,
55891 (void*)&&ZEND_NULL_LABEL,
55892 (void*)&&ZEND_NULL_LABEL,
55893 (void*)&&ZEND_NULL_LABEL,
55894 (void*)&&ZEND_NULL_LABEL,
55895 (void*)&&ZEND_NULL_LABEL,
55896 (void*)&&ZEND_NULL_LABEL,
55897 (void*)&&ZEND_NULL_LABEL,
55898 (void*)&&ZEND_NULL_LABEL,
55899 (void*)&&ZEND_NULL_LABEL,
55900 (void*)&&ZEND_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_NULL_LABEL,
55925 (void*)&&ZEND_NULL_LABEL,
55926 (void*)&&ZEND_NULL_LABEL,
55927 (void*)&&ZEND_NULL_LABEL,
55928 (void*)&&ZEND_NULL_LABEL,
55929 (void*)&&ZEND_NULL_LABEL,
55930 (void*)&&ZEND_NULL_LABEL,
55931 (void*)&&ZEND_NULL_LABEL,
55932 (void*)&&ZEND_NULL_LABEL,
55933 (void*)&&ZEND_NULL_LABEL,
55934 (void*)&&ZEND_NULL_LABEL,
55935 (void*)&&ZEND_NULL_LABEL,
55936 (void*)&&ZEND_NULL_LABEL,
55937 (void*)&&ZEND_NULL_LABEL,
55938 (void*)&&ZEND_NULL_LABEL,
55939 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
55940 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
55941 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
55942 (void*)&&ZEND_NULL_LABEL,
55943 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
55944 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
55945 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
55946 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
55947 (void*)&&ZEND_NULL_LABEL,
55948 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
55949 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
55950 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
55951 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
55952 (void*)&&ZEND_NULL_LABEL,
55953 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_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_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
55960 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
55961 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
55962 (void*)&&ZEND_NULL_LABEL,
55963 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_LABEL,
55964 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_LABEL,
55965 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_LABEL,
55966 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
55967 (void*)&&ZEND_NULL_LABEL,
55968 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
55969 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
55970 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
55971 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
55972 (void*)&&ZEND_NULL_LABEL,
55973 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
55974 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
55975 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
55976 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
55977 (void*)&&ZEND_NULL_LABEL,
55978 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_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_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_LABEL,
55985 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_LABEL,
55986 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
55987 (void*)&&ZEND_NULL_LABEL,
55988 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
55989 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
55990 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
55991 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
55992 (void*)&&ZEND_NULL_LABEL,
55993 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_LABEL,
55994 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
55995 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
55996 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
55997 (void*)&&ZEND_NULL_LABEL,
55998 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
55999 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
56000 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
56001 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56002 (void*)&&ZEND_NULL_LABEL,
56003 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56004 (void*)&&ZEND_NULL_LABEL,
56005 (void*)&&ZEND_NULL_LABEL,
56006 (void*)&&ZEND_NULL_LABEL,
56007 (void*)&&ZEND_NULL_LABEL,
56008 (void*)&&ZEND_NULL_LABEL,
56009 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_LABEL,
56010 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_LABEL,
56011 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_LABEL,
56012 (void*)&&ZEND_NULL_LABEL,
56013 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_LABEL,
56014 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_LABEL,
56015 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_LABEL,
56016 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_LABEL,
56017 (void*)&&ZEND_NULL_LABEL,
56018 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_LABEL,
56019 (void*)&&ZEND_NULL_LABEL,
56020 (void*)&&ZEND_NULL_LABEL,
56021 (void*)&&ZEND_NULL_LABEL,
56022 (void*)&&ZEND_NULL_LABEL,
56023 (void*)&&ZEND_NULL_LABEL,
56024 (void*)&&ZEND_NULL_LABEL,
56025 (void*)&&ZEND_NULL_LABEL,
56026 (void*)&&ZEND_NULL_LABEL,
56027 (void*)&&ZEND_NULL_LABEL,
56028 (void*)&&ZEND_NULL_LABEL,
56029 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CONST_LABEL,
56030 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
56031 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
56032 (void*)&&ZEND_NULL_LABEL,
56033 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CV_LABEL,
56034 (void*)&&ZEND_NULL_LABEL,
56035 (void*)&&ZEND_NULL_LABEL,
56036 (void*)&&ZEND_NULL_LABEL,
56037 (void*)&&ZEND_NULL_LABEL,
56038 (void*)&&ZEND_NULL_LABEL,
56039 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CONST_LABEL,
56040 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
56041 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
56042 (void*)&&ZEND_NULL_LABEL,
56043 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CV_LABEL,
56044 (void*)&&ZEND_NULL_LABEL,
56045 (void*)&&ZEND_NULL_LABEL,
56046 (void*)&&ZEND_NULL_LABEL,
56047 (void*)&&ZEND_NULL_LABEL,
56048 (void*)&&ZEND_NULL_LABEL,
56049 (void*)&&ZEND_NULL_LABEL,
56050 (void*)&&ZEND_NULL_LABEL,
56051 (void*)&&ZEND_NULL_LABEL,
56052 (void*)&&ZEND_NULL_LABEL,
56053 (void*)&&ZEND_NULL_LABEL,
56054 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_LABEL,
56055 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
56056 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
56057 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_LABEL,
56058 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_LABEL,
56059 (void*)&&ZEND_NULL_LABEL,
56060 (void*)&&ZEND_NULL_LABEL,
56061 (void*)&&ZEND_NULL_LABEL,
56062 (void*)&&ZEND_NULL_LABEL,
56063 (void*)&&ZEND_NULL_LABEL,
56064 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_LABEL,
56065 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
56066 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
56067 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_LABEL,
56068 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_LABEL,
56069 (void*)&&ZEND_NULL_LABEL,
56070 (void*)&&ZEND_NULL_LABEL,
56071 (void*)&&ZEND_NULL_LABEL,
56072 (void*)&&ZEND_NULL_LABEL,
56073 (void*)&&ZEND_NULL_LABEL,
56074 (void*)&&ZEND_NULL_LABEL,
56075 (void*)&&ZEND_NULL_LABEL,
56076 (void*)&&ZEND_NULL_LABEL,
56077 (void*)&&ZEND_NULL_LABEL,
56078 (void*)&&ZEND_NULL_LABEL,
56079 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_LABEL,
56080 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
56081 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
56082 (void*)&&ZEND_NULL_LABEL,
56083 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_LABEL,
56084 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_LABEL,
56085 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
56086 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
56087 (void*)&&ZEND_NULL_LABEL,
56088 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_LABEL,
56089 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_LABEL,
56090 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
56091 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
56092 (void*)&&ZEND_NULL_LABEL,
56093 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_LABEL,
56094 (void*)&&ZEND_ASSIGN_STATIC_PROP_OP_SPEC_LABEL,
56095 (void*)&&ZEND_NULL_LABEL,
56096 (void*)&&ZEND_NULL_LABEL,
56097 (void*)&&ZEND_NULL_LABEL,
56098 (void*)&&ZEND_NULL_LABEL,
56099 (void*)&&ZEND_NULL_LABEL,
56100 (void*)&&ZEND_NULL_LABEL,
56101 (void*)&&ZEND_NULL_LABEL,
56102 (void*)&&ZEND_NULL_LABEL,
56103 (void*)&&ZEND_NULL_LABEL,
56104 (void*)&&ZEND_NULL_LABEL,
56105 (void*)&&ZEND_NULL_LABEL,
56106 (void*)&&ZEND_NULL_LABEL,
56107 (void*)&&ZEND_ASSIGN_REF_SPEC_VAR_VAR_LABEL,
56108 (void*)&&ZEND_NULL_LABEL,
56109 (void*)&&ZEND_ASSIGN_REF_SPEC_VAR_CV_LABEL,
56110 (void*)&&ZEND_NULL_LABEL,
56111 (void*)&&ZEND_NULL_LABEL,
56112 (void*)&&ZEND_NULL_LABEL,
56113 (void*)&&ZEND_NULL_LABEL,
56114 (void*)&&ZEND_NULL_LABEL,
56115 (void*)&&ZEND_NULL_LABEL,
56116 (void*)&&ZEND_NULL_LABEL,
56117 (void*)&&ZEND_ASSIGN_REF_SPEC_CV_VAR_LABEL,
56118 (void*)&&ZEND_NULL_LABEL,
56119 (void*)&&ZEND_ASSIGN_REF_SPEC_CV_CV_LABEL,
56120 (void*)&&ZEND_QM_ASSIGN_SPEC_CONST_LABEL,
56121 (void*)&&ZEND_QM_ASSIGN_SPEC_TMP_LABEL,
56122 (void*)&&ZEND_QM_ASSIGN_SPEC_VAR_LABEL,
56123 (void*)&&ZEND_NULL_LABEL,
56124 (void*)&&ZEND_QM_ASSIGN_SPEC_CV_LABEL,
56125 (void*)&&ZEND_NULL_LABEL,
56126 (void*)&&ZEND_NULL_LABEL,
56127 (void*)&&ZEND_NULL_LABEL,
56128 (void*)&&ZEND_NULL_LABEL,
56129 (void*)&&ZEND_NULL_LABEL,
56130 (void*)&&ZEND_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_NULL_LABEL,
56140 (void*)&&ZEND_NULL_LABEL,
56141 (void*)&&ZEND_NULL_LABEL,
56142 (void*)&&ZEND_NULL_LABEL,
56143 (void*)&&ZEND_NULL_LABEL,
56144 (void*)&&ZEND_NULL_LABEL,
56145 (void*)&&ZEND_NULL_LABEL,
56146 (void*)&&ZEND_NULL_LABEL,
56147 (void*)&&ZEND_NULL_LABEL,
56148 (void*)&&ZEND_NULL_LABEL,
56149 (void*)&&ZEND_NULL_LABEL,
56150 (void*)&&ZEND_NULL_LABEL,
56151 (void*)&&ZEND_NULL_LABEL,
56152 (void*)&&ZEND_NULL_LABEL,
56153 (void*)&&ZEND_NULL_LABEL,
56154 (void*)&&ZEND_NULL_LABEL,
56155 (void*)&&ZEND_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_NULL_LABEL,
56168 (void*)&&ZEND_NULL_LABEL,
56169 (void*)&&ZEND_NULL_LABEL,
56170 (void*)&&ZEND_NULL_LABEL,
56171 (void*)&&ZEND_NULL_LABEL,
56172 (void*)&&ZEND_NULL_LABEL,
56173 (void*)&&ZEND_NULL_LABEL,
56174 (void*)&&ZEND_NULL_LABEL,
56175 (void*)&&ZEND_NULL_LABEL,
56176 (void*)&&ZEND_NULL_LABEL,
56177 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
56178 (void*)&&ZEND_NULL_LABEL,
56179 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
56180 (void*)&&ZEND_NULL_LABEL,
56181 (void*)&&ZEND_NULL_LABEL,
56182 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56183 (void*)&&ZEND_NULL_LABEL,
56184 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56185 (void*)&&ZEND_NULL_LABEL,
56186 (void*)&&ZEND_NULL_LABEL,
56187 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
56188 (void*)&&ZEND_NULL_LABEL,
56189 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
56190 (void*)&&ZEND_NULL_LABEL,
56191 (void*)&&ZEND_NULL_LABEL,
56192 (void*)&&ZEND_NULL_LABEL,
56193 (void*)&&ZEND_NULL_LABEL,
56194 (void*)&&ZEND_NULL_LABEL,
56195 (void*)&&ZEND_NULL_LABEL,
56196 (void*)&&ZEND_NULL_LABEL,
56197 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
56198 (void*)&&ZEND_NULL_LABEL,
56199 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_LABEL,
56200 (void*)&&ZEND_NULL_LABEL,
56201 (void*)&&ZEND_NULL_LABEL,
56202 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
56203 (void*)&&ZEND_NULL_LABEL,
56204 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
56205 (void*)&&ZEND_NULL_LABEL,
56206 (void*)&&ZEND_NULL_LABEL,
56207 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56208 (void*)&&ZEND_NULL_LABEL,
56209 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56210 (void*)&&ZEND_NULL_LABEL,
56211 (void*)&&ZEND_NULL_LABEL,
56212 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
56213 (void*)&&ZEND_NULL_LABEL,
56214 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
56215 (void*)&&ZEND_NULL_LABEL,
56216 (void*)&&ZEND_NULL_LABEL,
56217 (void*)&&ZEND_NULL_LABEL,
56218 (void*)&&ZEND_NULL_LABEL,
56219 (void*)&&ZEND_NULL_LABEL,
56220 (void*)&&ZEND_NULL_LABEL,
56221 (void*)&&ZEND_NULL_LABEL,
56222 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
56223 (void*)&&ZEND_NULL_LABEL,
56224 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
56225 (void*)&&ZEND_NULL_LABEL,
56226 (void*)&&ZEND_NULL_LABEL,
56227 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
56228 (void*)&&ZEND_NULL_LABEL,
56229 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_LABEL,
56230 (void*)&&ZEND_NULL_LABEL,
56231 (void*)&&ZEND_NULL_LABEL,
56232 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56233 (void*)&&ZEND_NULL_LABEL,
56234 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56235 (void*)&&ZEND_NULL_LABEL,
56236 (void*)&&ZEND_NULL_LABEL,
56237 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
56238 (void*)&&ZEND_NULL_LABEL,
56239 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
56240 (void*)&&ZEND_NULL_LABEL,
56241 (void*)&&ZEND_NULL_LABEL,
56242 (void*)&&ZEND_NULL_LABEL,
56243 (void*)&&ZEND_NULL_LABEL,
56244 (void*)&&ZEND_NULL_LABEL,
56245 (void*)&&ZEND_NULL_LABEL,
56246 (void*)&&ZEND_NULL_LABEL,
56247 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_LABEL,
56248 (void*)&&ZEND_NULL_LABEL,
56249 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_LABEL,
56250 (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_LABEL,
56251 (void*)&&ZEND_NULL_LABEL,
56252 (void*)&&ZEND_NULL_LABEL,
56253 (void*)&&ZEND_NULL_LABEL,
56254 (void*)&&ZEND_NULL_LABEL,
56255 (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_LABEL,
56256 (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_LABEL,
56257 (void*)&&ZEND_NULL_LABEL,
56258 (void*)&&ZEND_NULL_LABEL,
56259 (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_LABEL,
56260 (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_USED_LABEL,
56261 (void*)&&ZEND_NULL_LABEL,
56262 (void*)&&ZEND_NULL_LABEL,
56263 (void*)&&ZEND_NULL_LABEL,
56264 (void*)&&ZEND_NULL_LABEL,
56265 (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_LABEL,
56266 (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_LABEL,
56267 (void*)&&ZEND_NULL_LABEL,
56268 (void*)&&ZEND_NULL_LABEL,
56269 (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_LABEL,
56270 (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_LABEL,
56271 (void*)&&ZEND_NULL_LABEL,
56272 (void*)&&ZEND_NULL_LABEL,
56273 (void*)&&ZEND_POST_INC_SPEC_VAR_LABEL,
56274 (void*)&&ZEND_NULL_LABEL,
56275 (void*)&&ZEND_POST_INC_SPEC_CV_LABEL,
56276 (void*)&&ZEND_NULL_LABEL,
56277 (void*)&&ZEND_NULL_LABEL,
56278 (void*)&&ZEND_POST_DEC_SPEC_VAR_LABEL,
56279 (void*)&&ZEND_NULL_LABEL,
56280 (void*)&&ZEND_POST_DEC_SPEC_CV_LABEL,
56281 (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_LABEL,
56282 (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_LABEL,
56283 (void*)&&ZEND_JMP_SPEC_LABEL,
56284 (void*)&&ZEND_JMPZ_SPEC_CONST_LABEL,
56285 (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
56286 (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
56287 (void*)&&ZEND_NULL_LABEL,
56288 (void*)&&ZEND_JMPZ_SPEC_CV_LABEL,
56289 (void*)&&ZEND_JMPNZ_SPEC_CONST_LABEL,
56290 (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
56291 (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
56292 (void*)&&ZEND_NULL_LABEL,
56293 (void*)&&ZEND_JMPNZ_SPEC_CV_LABEL,
56294 (void*)&&ZEND_JMPZ_EX_SPEC_CONST_LABEL,
56295 (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
56296 (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
56297 (void*)&&ZEND_NULL_LABEL,
56298 (void*)&&ZEND_JMPZ_EX_SPEC_CV_LABEL,
56299 (void*)&&ZEND_JMPNZ_EX_SPEC_CONST_LABEL,
56300 (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
56301 (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
56302 (void*)&&ZEND_NULL_LABEL,
56303 (void*)&&ZEND_JMPNZ_EX_SPEC_CV_LABEL,
56304 (void*)&&ZEND_CASE_SPEC_TMPVAR_CONST_LABEL,
56305 (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
56306 (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
56307 (void*)&&ZEND_NULL_LABEL,
56308 (void*)&&ZEND_CASE_SPEC_TMPVAR_CV_LABEL,
56309 (void*)&&ZEND_CHECK_VAR_SPEC_CV_UNUSED_LABEL,
56310 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
56311 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
56312 (void*)&&ZEND_NULL_LABEL,
56313 (void*)&&ZEND_NULL_LABEL,
56314 (void*)&&ZEND_NULL_LABEL,
56315 (void*)&&ZEND_NULL_LABEL,
56316 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_LABEL,
56317 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
56318 (void*)&&ZEND_NULL_LABEL,
56319 (void*)&&ZEND_NULL_LABEL,
56320 (void*)&&ZEND_CAST_SPEC_CONST_LABEL,
56321 (void*)&&ZEND_CAST_SPEC_TMP_LABEL,
56322 (void*)&&ZEND_CAST_SPEC_VAR_LABEL,
56323 (void*)&&ZEND_NULL_LABEL,
56324 (void*)&&ZEND_CAST_SPEC_CV_LABEL,
56325 (void*)&&ZEND_BOOL_SPEC_CONST_LABEL,
56326 (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
56327 (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
56328 (void*)&&ZEND_NULL_LABEL,
56329 (void*)&&ZEND_BOOL_SPEC_CV_LABEL,
56330 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CONST_LABEL,
56331 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
56332 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
56333 (void*)&&ZEND_NULL_LABEL,
56334 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CV_LABEL,
56335 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
56336 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56337 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56338 (void*)&&ZEND_NULL_LABEL,
56339 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
56340 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
56341 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56342 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
56343 (void*)&&ZEND_NULL_LABEL,
56344 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
56345 (void*)&&ZEND_NULL_LABEL,
56346 (void*)&&ZEND_NULL_LABEL,
56347 (void*)&&ZEND_NULL_LABEL,
56348 (void*)&&ZEND_NULL_LABEL,
56349 (void*)&&ZEND_NULL_LABEL,
56350 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CONST_LABEL,
56351 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
56352 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
56353 (void*)&&ZEND_NULL_LABEL,
56354 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CV_LABEL,
56355 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CONST_LABEL,
56356 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
56357 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
56358 (void*)&&ZEND_NULL_LABEL,
56359 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CV_LABEL,
56360 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CONST_LABEL,
56361 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
56362 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
56363 (void*)&&ZEND_NULL_LABEL,
56364 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CV_LABEL,
56365 (void*)&&ZEND_ROPE_END_SPEC_TMP_CONST_LABEL,
56366 (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
56367 (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
56368 (void*)&&ZEND_NULL_LABEL,
56369 (void*)&&ZEND_ROPE_END_SPEC_TMP_CV_LABEL,
56370 (void*)&&ZEND_BEGIN_SILENCE_SPEC_LABEL,
56371 (void*)&&ZEND_END_SILENCE_SPEC_TMP_LABEL,
56372 (void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_LABEL,
56373 (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_LABEL,
56374 (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_LABEL,
56375 (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
56376 (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
56377 (void*)&&ZEND_INIT_FCALL_SPEC_CONST_LABEL,
56378 (void*)&&ZEND_RETURN_SPEC_CONST_LABEL,
56379 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56380 (void*)&&ZEND_RETURN_SPEC_TMP_LABEL,
56381 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56382 (void*)&&ZEND_RETURN_SPEC_VAR_LABEL,
56383 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56384 (void*)&&ZEND_NULL_LABEL,
56385 (void*)&&ZEND_NULL_LABEL,
56386 (void*)&&ZEND_RETURN_SPEC_CV_LABEL,
56387 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
56388 (void*)&&ZEND_RECV_SPEC_UNUSED_LABEL,
56389 (void*)&&ZEND_RECV_INIT_SPEC_CONST_LABEL,
56390 (void*)&&ZEND_SEND_VAL_SPEC_CONST_CONST_LABEL,
56391 (void*)&&ZEND_NULL_LABEL,
56392 (void*)&&ZEND_NULL_LABEL,
56393 (void*)&&ZEND_SEND_VAL_SPEC_CONST_UNUSED_LABEL,
56394 (void*)&&ZEND_NULL_LABEL,
56395 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
56396 (void*)&&ZEND_NULL_LABEL,
56397 (void*)&&ZEND_NULL_LABEL,
56398 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_LABEL,
56399 (void*)&&ZEND_NULL_LABEL,
56400 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
56401 (void*)&&ZEND_NULL_LABEL,
56402 (void*)&&ZEND_NULL_LABEL,
56403 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_LABEL,
56404 (void*)&&ZEND_NULL_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_NULL_LABEL,
56411 (void*)&&ZEND_NULL_LABEL,
56412 (void*)&&ZEND_NULL_LABEL,
56413 (void*)&&ZEND_NULL_LABEL,
56414 (void*)&&ZEND_NULL_LABEL,
56415 (void*)&&ZEND_NULL_LABEL,
56416 (void*)&&ZEND_NULL_LABEL,
56417 (void*)&&ZEND_NULL_LABEL,
56418 (void*)&&ZEND_NULL_LABEL,
56419 (void*)&&ZEND_NULL_LABEL,
56420 (void*)&&ZEND_NULL_LABEL,
56421 (void*)&&ZEND_NULL_LABEL,
56422 (void*)&&ZEND_NULL_LABEL,
56423 (void*)&&ZEND_NULL_LABEL,
56424 (void*)&&ZEND_NULL_LABEL,
56425 (void*)&&ZEND_NULL_LABEL,
56426 (void*)&&ZEND_NULL_LABEL,
56427 (void*)&&ZEND_NULL_LABEL,
56428 (void*)&&ZEND_NULL_LABEL,
56429 (void*)&&ZEND_NULL_LABEL,
56430 (void*)&&ZEND_NULL_LABEL,
56431 (void*)&&ZEND_NULL_LABEL,
56432 (void*)&&ZEND_NULL_LABEL,
56433 (void*)&&ZEND_NULL_LABEL,
56434 (void*)&&ZEND_NULL_LABEL,
56435 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
56436 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
56437 (void*)&&ZEND_NULL_LABEL,
56438 (void*)&&ZEND_NULL_LABEL,
56439 (void*)&&ZEND_NULL_LABEL,
56440 (void*)&&ZEND_NULL_LABEL,
56441 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_LABEL,
56442 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
56443 (void*)&&ZEND_NULL_LABEL,
56444 (void*)&&ZEND_NULL_LABEL,
56445 (void*)&&ZEND_NULL_LABEL,
56446 (void*)&&ZEND_NULL_LABEL,
56447 (void*)&&ZEND_NULL_LABEL,
56448 (void*)&&ZEND_NULL_LABEL,
56449 (void*)&&ZEND_NULL_LABEL,
56450 (void*)&&ZEND_NULL_LABEL,
56451 (void*)&&ZEND_NULL_LABEL,
56452 (void*)&&ZEND_NULL_LABEL,
56453 (void*)&&ZEND_NULL_LABEL,
56454 (void*)&&ZEND_NULL_LABEL,
56455 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
56456 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
56457 (void*)&&ZEND_NULL_LABEL,
56458 (void*)&&ZEND_NULL_LABEL,
56459 (void*)&&ZEND_NULL_LABEL,
56460 (void*)&&ZEND_NULL_LABEL,
56461 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_LABEL,
56462 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_LABEL,
56463 (void*)&&ZEND_NULL_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_SEND_REF_SPEC_VAR_CONST_LABEL,
56476 (void*)&&ZEND_NULL_LABEL,
56477 (void*)&&ZEND_NULL_LABEL,
56478 (void*)&&ZEND_SEND_REF_SPEC_VAR_UNUSED_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_SEND_REF_SPEC_CV_CONST_LABEL,
56486 (void*)&&ZEND_NULL_LABEL,
56487 (void*)&&ZEND_NULL_LABEL,
56488 (void*)&&ZEND_SEND_REF_SPEC_CV_UNUSED_LABEL,
56489 (void*)&&ZEND_NULL_LABEL,
56490 (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_LABEL,
56491 (void*)&&ZEND_NULL_LABEL,
56492 (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_LABEL,
56493 (void*)&&ZEND_NEW_SPEC_UNUSED_UNUSED_LABEL,
56494 (void*)&&ZEND_NULL_LABEL,
56495 (void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_LABEL,
56496 (void*)&&ZEND_FREE_SPEC_TMPVAR_LABEL,
56497 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CONST_LABEL,
56498 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
56499 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
56500 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_LABEL,
56501 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CV_LABEL,
56502 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CONST_LABEL,
56503 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
56504 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
56505 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_LABEL,
56506 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CV_LABEL,
56507 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CONST_LABEL,
56508 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
56509 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
56510 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_LABEL,
56511 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CV_LABEL,
56512 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_LABEL,
56513 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
56514 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
56515 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_LABEL,
56516 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CV_LABEL,
56517 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CONST_LABEL,
56518 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
56519 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
56520 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_UNUSED_LABEL,
56521 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CV_LABEL,
56522 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_LABEL,
56523 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
56524 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
56525 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_LABEL,
56526 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_LABEL,
56527 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_LABEL,
56528 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
56529 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
56530 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_LABEL,
56531 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_LABEL,
56532 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_LABEL,
56533 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
56534 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
56535 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_LABEL,
56536 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_LABEL,
56537 (void*)&&ZEND_NULL_LABEL,
56538 (void*)&&ZEND_NULL_LABEL,
56539 (void*)&&ZEND_NULL_LABEL,
56540 (void*)&&ZEND_NULL_LABEL,
56541 (void*)&&ZEND_NULL_LABEL,
56542 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_LABEL,
56543 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
56544 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
56545 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_LABEL,
56546 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_LABEL,
56547 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CONST_LABEL,
56548 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56549 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
56550 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56551 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
56552 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56553 (void*)&&ZEND_NULL_LABEL,
56554 (void*)&&ZEND_NULL_LABEL,
56555 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CV_LABEL,
56556 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
56557 (void*)&&ZEND_UNSET_VAR_SPEC_CONST_UNUSED_LABEL,
56558 (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
56559 (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
56560 (void*)&&ZEND_NULL_LABEL,
56561 (void*)&&ZEND_UNSET_VAR_SPEC_CV_UNUSED_LABEL,
56562 (void*)&&ZEND_NULL_LABEL,
56563 (void*)&&ZEND_NULL_LABEL,
56564 (void*)&&ZEND_NULL_LABEL,
56565 (void*)&&ZEND_NULL_LABEL,
56566 (void*)&&ZEND_NULL_LABEL,
56567 (void*)&&ZEND_NULL_LABEL,
56568 (void*)&&ZEND_NULL_LABEL,
56569 (void*)&&ZEND_NULL_LABEL,
56570 (void*)&&ZEND_NULL_LABEL,
56571 (void*)&&ZEND_NULL_LABEL,
56572 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CONST_LABEL,
56573 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
56574 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
56575 (void*)&&ZEND_NULL_LABEL,
56576 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CV_LABEL,
56577 (void*)&&ZEND_NULL_LABEL,
56578 (void*)&&ZEND_NULL_LABEL,
56579 (void*)&&ZEND_NULL_LABEL,
56580 (void*)&&ZEND_NULL_LABEL,
56581 (void*)&&ZEND_NULL_LABEL,
56582 (void*)&&ZEND_UNSET_DIM_SPEC_CV_CONST_LABEL,
56583 (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
56584 (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
56585 (void*)&&ZEND_NULL_LABEL,
56586 (void*)&&ZEND_UNSET_DIM_SPEC_CV_CV_LABEL,
56587 (void*)&&ZEND_NULL_LABEL,
56588 (void*)&&ZEND_NULL_LABEL,
56589 (void*)&&ZEND_NULL_LABEL,
56590 (void*)&&ZEND_NULL_LABEL,
56591 (void*)&&ZEND_NULL_LABEL,
56592 (void*)&&ZEND_NULL_LABEL,
56593 (void*)&&ZEND_NULL_LABEL,
56594 (void*)&&ZEND_NULL_LABEL,
56595 (void*)&&ZEND_NULL_LABEL,
56596 (void*)&&ZEND_NULL_LABEL,
56597 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CONST_LABEL,
56598 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
56599 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
56600 (void*)&&ZEND_NULL_LABEL,
56601 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CV_LABEL,
56602 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_LABEL,
56603 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
56604 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
56605 (void*)&&ZEND_NULL_LABEL,
56606 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CV_LABEL,
56607 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CONST_LABEL,
56608 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
56609 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
56610 (void*)&&ZEND_NULL_LABEL,
56611 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CV_LABEL,
56612 (void*)&&ZEND_FE_RESET_R_SPEC_CONST_LABEL,
56613 (void*)&&ZEND_FE_RESET_R_SPEC_TMP_LABEL,
56614 (void*)&&ZEND_FE_RESET_R_SPEC_VAR_LABEL,
56615 (void*)&&ZEND_NULL_LABEL,
56616 (void*)&&ZEND_FE_RESET_R_SPEC_CV_LABEL,
56617 (void*)&&ZEND_FE_FETCH_R_SPEC_VAR_LABEL,
56618 (void*)&&ZEND_FETCH_R_SPEC_CONST_UNUSED_LABEL,
56619 (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
56620 (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
56621 (void*)&&ZEND_NULL_LABEL,
56622 (void*)&&ZEND_FETCH_R_SPEC_CV_UNUSED_LABEL,
56623 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CONST_LABEL,
56624 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
56625 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
56626 (void*)&&ZEND_NULL_LABEL,
56627 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CV_LABEL,
56628 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
56629 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56630 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56631 (void*)&&ZEND_NULL_LABEL,
56632 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
56633 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
56634 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56635 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
56636 (void*)&&ZEND_NULL_LABEL,
56637 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
56638 (void*)&&ZEND_NULL_LABEL,
56639 (void*)&&ZEND_NULL_LABEL,
56640 (void*)&&ZEND_NULL_LABEL,
56641 (void*)&&ZEND_NULL_LABEL,
56642 (void*)&&ZEND_NULL_LABEL,
56643 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CONST_LABEL,
56644 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
56645 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
56646 (void*)&&ZEND_NULL_LABEL,
56647 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CV_LABEL,
56648 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_LABEL,
56649 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
56650 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
56651 (void*)&&ZEND_NULL_LABEL,
56652 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CV_LABEL,
56653 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
56654 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56655 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56656 (void*)&&ZEND_NULL_LABEL,
56657 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
56658 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
56659 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56660 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
56661 (void*)&&ZEND_NULL_LABEL,
56662 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
56663 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_LABEL,
56664 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
56665 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
56666 (void*)&&ZEND_NULL_LABEL,
56667 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_LABEL,
56668 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CONST_LABEL,
56669 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
56670 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
56671 (void*)&&ZEND_NULL_LABEL,
56672 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CV_LABEL,
56673 (void*)&&ZEND_FETCH_W_SPEC_CONST_UNUSED_LABEL,
56674 (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
56675 (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
56676 (void*)&&ZEND_NULL_LABEL,
56677 (void*)&&ZEND_FETCH_W_SPEC_CV_UNUSED_LABEL,
56678 (void*)&&ZEND_NULL_LABEL,
56679 (void*)&&ZEND_NULL_LABEL,
56680 (void*)&&ZEND_NULL_LABEL,
56681 (void*)&&ZEND_NULL_LABEL,
56682 (void*)&&ZEND_NULL_LABEL,
56683 (void*)&&ZEND_NULL_LABEL,
56684 (void*)&&ZEND_NULL_LABEL,
56685 (void*)&&ZEND_NULL_LABEL,
56686 (void*)&&ZEND_NULL_LABEL,
56687 (void*)&&ZEND_NULL_LABEL,
56688 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CONST_LABEL,
56689 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
56690 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
56691 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_LABEL,
56692 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CV_LABEL,
56693 (void*)&&ZEND_NULL_LABEL,
56694 (void*)&&ZEND_NULL_LABEL,
56695 (void*)&&ZEND_NULL_LABEL,
56696 (void*)&&ZEND_NULL_LABEL,
56697 (void*)&&ZEND_NULL_LABEL,
56698 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CONST_LABEL,
56699 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
56700 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
56701 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_LABEL,
56702 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CV_LABEL,
56703 (void*)&&ZEND_NULL_LABEL,
56704 (void*)&&ZEND_NULL_LABEL,
56705 (void*)&&ZEND_NULL_LABEL,
56706 (void*)&&ZEND_NULL_LABEL,
56707 (void*)&&ZEND_NULL_LABEL,
56708 (void*)&&ZEND_NULL_LABEL,
56709 (void*)&&ZEND_NULL_LABEL,
56710 (void*)&&ZEND_NULL_LABEL,
56711 (void*)&&ZEND_NULL_LABEL,
56712 (void*)&&ZEND_NULL_LABEL,
56713 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_LABEL,
56714 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
56715 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
56716 (void*)&&ZEND_NULL_LABEL,
56717 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CV_LABEL,
56718 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_LABEL,
56719 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
56720 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
56721 (void*)&&ZEND_NULL_LABEL,
56722 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_LABEL,
56723 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CONST_LABEL,
56724 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
56725 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
56726 (void*)&&ZEND_NULL_LABEL,
56727 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CV_LABEL,
56728 (void*)&&ZEND_FETCH_RW_SPEC_CONST_UNUSED_LABEL,
56729 (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
56730 (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
56731 (void*)&&ZEND_NULL_LABEL,
56732 (void*)&&ZEND_FETCH_RW_SPEC_CV_UNUSED_LABEL,
56733 (void*)&&ZEND_NULL_LABEL,
56734 (void*)&&ZEND_NULL_LABEL,
56735 (void*)&&ZEND_NULL_LABEL,
56736 (void*)&&ZEND_NULL_LABEL,
56737 (void*)&&ZEND_NULL_LABEL,
56738 (void*)&&ZEND_NULL_LABEL,
56739 (void*)&&ZEND_NULL_LABEL,
56740 (void*)&&ZEND_NULL_LABEL,
56741 (void*)&&ZEND_NULL_LABEL,
56742 (void*)&&ZEND_NULL_LABEL,
56743 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_LABEL,
56744 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
56745 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
56746 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_LABEL,
56747 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CV_LABEL,
56748 (void*)&&ZEND_NULL_LABEL,
56749 (void*)&&ZEND_NULL_LABEL,
56750 (void*)&&ZEND_NULL_LABEL,
56751 (void*)&&ZEND_NULL_LABEL,
56752 (void*)&&ZEND_NULL_LABEL,
56753 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CONST_LABEL,
56754 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
56755 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
56756 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_LABEL,
56757 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CV_LABEL,
56758 (void*)&&ZEND_NULL_LABEL,
56759 (void*)&&ZEND_NULL_LABEL,
56760 (void*)&&ZEND_NULL_LABEL,
56761 (void*)&&ZEND_NULL_LABEL,
56762 (void*)&&ZEND_NULL_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_FETCH_OBJ_RW_SPEC_VAR_CONST_LABEL,
56769 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
56770 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
56771 (void*)&&ZEND_NULL_LABEL,
56772 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_LABEL,
56773 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_LABEL,
56774 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
56775 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
56776 (void*)&&ZEND_NULL_LABEL,
56777 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_LABEL,
56778 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_LABEL,
56779 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
56780 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
56781 (void*)&&ZEND_NULL_LABEL,
56782 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CV_LABEL,
56783 (void*)&&ZEND_FETCH_IS_SPEC_CONST_UNUSED_LABEL,
56784 (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
56785 (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
56786 (void*)&&ZEND_NULL_LABEL,
56787 (void*)&&ZEND_FETCH_IS_SPEC_CV_UNUSED_LABEL,
56788 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_LABEL,
56789 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
56790 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
56791 (void*)&&ZEND_NULL_LABEL,
56792 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CV_LABEL,
56793 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
56794 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56795 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56796 (void*)&&ZEND_NULL_LABEL,
56797 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
56798 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
56799 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56800 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56801 (void*)&&ZEND_NULL_LABEL,
56802 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
56803 (void*)&&ZEND_NULL_LABEL,
56804 (void*)&&ZEND_NULL_LABEL,
56805 (void*)&&ZEND_NULL_LABEL,
56806 (void*)&&ZEND_NULL_LABEL,
56807 (void*)&&ZEND_NULL_LABEL,
56808 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CONST_LABEL,
56809 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
56810 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
56811 (void*)&&ZEND_NULL_LABEL,
56812 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CV_LABEL,
56813 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_LABEL,
56814 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
56815 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
56816 (void*)&&ZEND_NULL_LABEL,
56817 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_LABEL,
56818 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
56819 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56820 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56821 (void*)&&ZEND_NULL_LABEL,
56822 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
56823 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
56824 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56825 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
56826 (void*)&&ZEND_NULL_LABEL,
56827 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
56828 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_LABEL,
56829 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
56830 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
56831 (void*)&&ZEND_NULL_LABEL,
56832 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_LABEL,
56833 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_LABEL,
56834 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
56835 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
56836 (void*)&&ZEND_NULL_LABEL,
56837 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CV_LABEL,
56838 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
56839 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
56840 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
56841 (void*)&&ZEND_NULL_LABEL,
56842 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
56843 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_LABEL,
56844 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56845 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56846 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
56847 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_LABEL,
56848 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_LABEL,
56849 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56850 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56851 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_LABEL,
56852 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_LABEL,
56853 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_LABEL,
56854 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
56855 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
56856 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
56857 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_LABEL,
56858 (void*)&&ZEND_NULL_LABEL,
56859 (void*)&&ZEND_NULL_LABEL,
56860 (void*)&&ZEND_NULL_LABEL,
56861 (void*)&&ZEND_NULL_LABEL,
56862 (void*)&&ZEND_NULL_LABEL,
56863 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_LABEL,
56864 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
56865 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
56866 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
56867 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_LABEL,
56868 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_LABEL,
56869 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56870 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
56871 (void*)&&ZEND_NULL_LABEL,
56872 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_LABEL,
56873 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_LABEL,
56874 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56875 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
56876 (void*)&&ZEND_NULL_LABEL,
56877 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_LABEL,
56878 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_LABEL,
56879 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
56880 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
56881 (void*)&&ZEND_NULL_LABEL,
56882 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_LABEL,
56883 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
56884 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
56885 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
56886 (void*)&&ZEND_NULL_LABEL,
56887 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_LABEL,
56888 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_LABEL,
56889 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
56890 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
56891 (void*)&&ZEND_NULL_LABEL,
56892 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_LABEL,
56893 (void*)&&ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_LABEL,
56894 (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
56895 (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
56896 (void*)&&ZEND_NULL_LABEL,
56897 (void*)&&ZEND_FETCH_UNSET_SPEC_CV_UNUSED_LABEL,
56898 (void*)&&ZEND_NULL_LABEL,
56899 (void*)&&ZEND_NULL_LABEL,
56900 (void*)&&ZEND_NULL_LABEL,
56901 (void*)&&ZEND_NULL_LABEL,
56902 (void*)&&ZEND_NULL_LABEL,
56903 (void*)&&ZEND_NULL_LABEL,
56904 (void*)&&ZEND_NULL_LABEL,
56905 (void*)&&ZEND_NULL_LABEL,
56906 (void*)&&ZEND_NULL_LABEL,
56907 (void*)&&ZEND_NULL_LABEL,
56908 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_LABEL,
56909 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
56910 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
56911 (void*)&&ZEND_NULL_LABEL,
56912 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_LABEL,
56913 (void*)&&ZEND_NULL_LABEL,
56914 (void*)&&ZEND_NULL_LABEL,
56915 (void*)&&ZEND_NULL_LABEL,
56916 (void*)&&ZEND_NULL_LABEL,
56917 (void*)&&ZEND_NULL_LABEL,
56918 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_LABEL,
56919 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
56920 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
56921 (void*)&&ZEND_NULL_LABEL,
56922 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_LABEL,
56923 (void*)&&ZEND_NULL_LABEL,
56924 (void*)&&ZEND_NULL_LABEL,
56925 (void*)&&ZEND_NULL_LABEL,
56926 (void*)&&ZEND_NULL_LABEL,
56927 (void*)&&ZEND_NULL_LABEL,
56928 (void*)&&ZEND_NULL_LABEL,
56929 (void*)&&ZEND_NULL_LABEL,
56930 (void*)&&ZEND_NULL_LABEL,
56931 (void*)&&ZEND_NULL_LABEL,
56932 (void*)&&ZEND_NULL_LABEL,
56933 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_LABEL,
56934 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
56935 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
56936 (void*)&&ZEND_NULL_LABEL,
56937 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_LABEL,
56938 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_LABEL,
56939 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
56940 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
56941 (void*)&&ZEND_NULL_LABEL,
56942 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_LABEL,
56943 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_LABEL,
56944 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
56945 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
56946 (void*)&&ZEND_NULL_LABEL,
56947 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_LABEL,
56948 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CONST_LABEL,
56949 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
56950 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
56951 (void*)&&ZEND_NULL_LABEL,
56952 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CV_LABEL,
56953 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
56954 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
56955 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
56956 (void*)&&ZEND_NULL_LABEL,
56957 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
56958 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
56959 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
56960 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
56961 (void*)&&ZEND_NULL_LABEL,
56962 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_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_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
56969 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
56970 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
56971 (void*)&&ZEND_NULL_LABEL,
56972 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
56973 (void*)&&ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_LABEL,
56974 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
56975 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
56976 (void*)&&ZEND_NULL_LABEL,
56977 (void*)&&ZEND_NULL_LABEL,
56978 (void*)&&ZEND_NULL_LABEL,
56979 (void*)&&ZEND_NULL_LABEL,
56980 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_LABEL,
56981 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_LABEL,
56982 (void*)&&ZEND_NULL_LABEL,
56983 (void*)&&ZEND_NULL_LABEL,
56984 (void*)&&ZEND_EXT_STMT_SPEC_LABEL,
56985 (void*)&&ZEND_EXT_FCALL_BEGIN_SPEC_LABEL,
56986 (void*)&&ZEND_EXT_FCALL_END_SPEC_LABEL,
56987 (void*)&&ZEND_EXT_NOP_SPEC_LABEL,
56988 (void*)&&ZEND_TICKS_SPEC_LABEL,
56989 (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_LABEL,
56990 (void*)&&ZEND_NULL_LABEL,
56991 (void*)&&ZEND_NULL_LABEL,
56992 (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_LABEL,
56993 (void*)&&ZEND_NULL_LABEL,
56994 (void*)&&ZEND_CATCH_SPEC_CONST_LABEL,
56995 (void*)&&ZEND_THROW_SPEC_CONST_LABEL,
56996 (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
56997 (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
56998 (void*)&&ZEND_NULL_LABEL,
56999 (void*)&&ZEND_THROW_SPEC_CV_LABEL,
57000 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_LABEL,
57001 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
57002 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
57003 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57004 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CV_LABEL,
57005 (void*)&&ZEND_CLONE_SPEC_CONST_LABEL,
57006 (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
57007 (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
57008 (void*)&&ZEND_CLONE_SPEC_UNUSED_LABEL,
57009 (void*)&&ZEND_CLONE_SPEC_CV_LABEL,
57010 (void*)&&ZEND_RETURN_BY_REF_SPEC_CONST_LABEL,
57011 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57012 (void*)&&ZEND_RETURN_BY_REF_SPEC_TMP_LABEL,
57013 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57014 (void*)&&ZEND_RETURN_BY_REF_SPEC_VAR_LABEL,
57015 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57016 (void*)&&ZEND_NULL_LABEL,
57017 (void*)&&ZEND_NULL_LABEL,
57018 (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_LABEL,
57019 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
57020 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_LABEL,
57021 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57022 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57023 (void*)&&ZEND_NULL_LABEL,
57024 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_LABEL,
57025 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
57026 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57027 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57028 (void*)&&ZEND_NULL_LABEL,
57029 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
57030 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
57031 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57032 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
57033 (void*)&&ZEND_NULL_LABEL,
57034 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
57035 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
57036 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57037 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57038 (void*)&&ZEND_NULL_LABEL,
57039 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
57040 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_LABEL,
57041 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
57042 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
57043 (void*)&&ZEND_NULL_LABEL,
57044 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CV_LABEL,
57045 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_LABEL,
57046 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57047 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
57048 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_LABEL,
57049 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_LABEL,
57050 (void*)&&ZEND_NULL_LABEL,
57051 (void*)&&ZEND_NULL_LABEL,
57052 (void*)&&ZEND_NULL_LABEL,
57053 (void*)&&ZEND_NULL_LABEL,
57054 (void*)&&ZEND_NULL_LABEL,
57055 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_LABEL,
57056 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
57057 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
57058 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_LABEL,
57059 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_LABEL,
57060 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
57061 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57062 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
57063 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_LABEL,
57064 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
57065 (void*)&&ZEND_NULL_LABEL,
57066 (void*)&&ZEND_NULL_LABEL,
57067 (void*)&&ZEND_NULL_LABEL,
57068 (void*)&&ZEND_NULL_LABEL,
57069 (void*)&&ZEND_NULL_LABEL,
57070 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_LABEL,
57071 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
57072 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
57073 (void*)&&ZEND_NULL_LABEL,
57074 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_LABEL,
57075 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_LABEL,
57076 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
57077 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
57078 (void*)&&ZEND_NULL_LABEL,
57079 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_LABEL,
57080 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
57081 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57082 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57083 (void*)&&ZEND_NULL_LABEL,
57084 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
57085 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
57086 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57087 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57088 (void*)&&ZEND_NULL_LABEL,
57089 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
57090 (void*)&&ZEND_NULL_LABEL,
57091 (void*)&&ZEND_NULL_LABEL,
57092 (void*)&&ZEND_NULL_LABEL,
57093 (void*)&&ZEND_NULL_LABEL,
57094 (void*)&&ZEND_NULL_LABEL,
57095 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_LABEL,
57096 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
57097 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
57098 (void*)&&ZEND_NULL_LABEL,
57099 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_LABEL,
57100 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
57101 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
57102 (void*)&&ZEND_NULL_LABEL,
57103 (void*)&&ZEND_NULL_LABEL,
57104 (void*)&&ZEND_NULL_LABEL,
57105 (void*)&&ZEND_NULL_LABEL,
57106 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_LABEL,
57107 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_LABEL,
57108 (void*)&&ZEND_NULL_LABEL,
57109 (void*)&&ZEND_NULL_LABEL,
57110 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
57111 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
57112 (void*)&&ZEND_NULL_LABEL,
57113 (void*)&&ZEND_NULL_LABEL,
57114 (void*)&&ZEND_NULL_LABEL,
57115 (void*)&&ZEND_NULL_LABEL,
57116 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_LABEL,
57117 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_LABEL,
57118 (void*)&&ZEND_NULL_LABEL,
57119 (void*)&&ZEND_NULL_LABEL,
57120 (void*)&&ZEND_NULL_LABEL,
57121 (void*)&&ZEND_NULL_LABEL,
57122 (void*)&&ZEND_NULL_LABEL,
57123 (void*)&&ZEND_NULL_LABEL,
57124 (void*)&&ZEND_NULL_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_NULL_LABEL,
57131 (void*)&&ZEND_NULL_LABEL,
57132 (void*)&&ZEND_NULL_LABEL,
57133 (void*)&&ZEND_NULL_LABEL,
57134 (void*)&&ZEND_NULL_LABEL,
57135 (void*)&&ZEND_NULL_LABEL,
57136 (void*)&&ZEND_NULL_LABEL,
57137 (void*)&&ZEND_NULL_LABEL,
57138 (void*)&&ZEND_NULL_LABEL,
57139 (void*)&&ZEND_NULL_LABEL,
57140 (void*)&&ZEND_NULL_LABEL,
57141 (void*)&&ZEND_NULL_LABEL,
57142 (void*)&&ZEND_NULL_LABEL,
57143 (void*)&&ZEND_NULL_LABEL,
57144 (void*)&&ZEND_NULL_LABEL,
57145 (void*)&&ZEND_NULL_LABEL,
57146 (void*)&&ZEND_NULL_LABEL,
57147 (void*)&&ZEND_NULL_LABEL,
57148 (void*)&&ZEND_NULL_LABEL,
57149 (void*)&&ZEND_NULL_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_NULL_LABEL,
57156 (void*)&&ZEND_NULL_LABEL,
57157 (void*)&&ZEND_NULL_LABEL,
57158 (void*)&&ZEND_NULL_LABEL,
57159 (void*)&&ZEND_NULL_LABEL,
57160 (void*)&&ZEND_SEND_VAR_SPEC_VAR_CONST_LABEL,
57161 (void*)&&ZEND_NULL_LABEL,
57162 (void*)&&ZEND_NULL_LABEL,
57163 (void*)&&ZEND_SEND_VAR_SPEC_VAR_UNUSED_LABEL,
57164 (void*)&&ZEND_NULL_LABEL,
57165 (void*)&&ZEND_NULL_LABEL,
57166 (void*)&&ZEND_NULL_LABEL,
57167 (void*)&&ZEND_NULL_LABEL,
57168 (void*)&&ZEND_NULL_LABEL,
57169 (void*)&&ZEND_NULL_LABEL,
57170 (void*)&&ZEND_SEND_VAR_SPEC_CV_CONST_LABEL,
57171 (void*)&&ZEND_NULL_LABEL,
57172 (void*)&&ZEND_NULL_LABEL,
57173 (void*)&&ZEND_SEND_VAR_SPEC_CV_UNUSED_LABEL,
57174 (void*)&&ZEND_NULL_LABEL,
57175 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_LABEL,
57176 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
57177 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
57178 (void*)&&ZEND_NULL_LABEL,
57179 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_LABEL,
57180 (void*)&&ZEND_SEND_ARRAY_SPEC_LABEL,
57181 (void*)&&ZEND_SEND_USER_SPEC_CONST_LABEL,
57182 (void*)&&ZEND_SEND_USER_SPEC_TMP_LABEL,
57183 (void*)&&ZEND_SEND_USER_SPEC_VAR_LABEL,
57184 (void*)&&ZEND_NULL_LABEL,
57185 (void*)&&ZEND_SEND_USER_SPEC_CV_LABEL,
57186 (void*)&&ZEND_STRLEN_SPEC_CONST_LABEL,
57187 (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
57188 (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
57189 (void*)&&ZEND_NULL_LABEL,
57190 (void*)&&ZEND_STRLEN_SPEC_CV_LABEL,
57191 (void*)&&ZEND_DEFINED_SPEC_CONST_LABEL,
57192 (void*)&&ZEND_TYPE_CHECK_SPEC_CONST_LABEL,
57193 (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
57194 (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
57195 (void*)&&ZEND_NULL_LABEL,
57196 (void*)&&ZEND_TYPE_CHECK_SPEC_CV_LABEL,
57197 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_LABEL,
57198 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_LABEL,
57199 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_LABEL,
57200 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_LABEL,
57201 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_LABEL,
57202 (void*)&&ZEND_FE_RESET_RW_SPEC_CONST_LABEL,
57203 (void*)&&ZEND_FE_RESET_RW_SPEC_TMP_LABEL,
57204 (void*)&&ZEND_FE_RESET_RW_SPEC_VAR_LABEL,
57205 (void*)&&ZEND_NULL_LABEL,
57206 (void*)&&ZEND_FE_RESET_RW_SPEC_CV_LABEL,
57207 (void*)&&ZEND_FE_FETCH_RW_SPEC_VAR_LABEL,
57208 (void*)&&ZEND_FE_FREE_SPEC_TMPVAR_LABEL,
57209 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_LABEL,
57210 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
57211 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
57212 (void*)&&ZEND_NULL_LABEL,
57213 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CV_LABEL,
57214 (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_LABEL,
57215 (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_USED_LABEL,
57216 (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
57217 (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
57218 (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_LABEL,
57219 (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_USED_LABEL,
57220 (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
57221 (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
57222 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_LABEL,
57223 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_LABEL,
57224 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_LABEL,
57225 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_LABEL,
57226 (void*)&&ZEND_NULL_LABEL,
57227 (void*)&&ZEND_NULL_LABEL,
57228 (void*)&&ZEND_NULL_LABEL,
57229 (void*)&&ZEND_NULL_LABEL,
57230 (void*)&&ZEND_NULL_LABEL,
57231 (void*)&&ZEND_NULL_LABEL,
57232 (void*)&&ZEND_NULL_LABEL,
57233 (void*)&&ZEND_NULL_LABEL,
57234 (void*)&&ZEND_NULL_LABEL,
57235 (void*)&&ZEND_NULL_LABEL,
57236 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_LABEL,
57237 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57238 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57239 (void*)&&ZEND_NULL_LABEL,
57240 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CV_LABEL,
57241 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
57242 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57243 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57244 (void*)&&ZEND_NULL_LABEL,
57245 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_LABEL,
57246 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CONST_LABEL,
57247 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57248 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57249 (void*)&&ZEND_NULL_LABEL,
57250 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CV_LABEL,
57251 (void*)&&ZEND_NULL_LABEL,
57252 (void*)&&ZEND_NULL_LABEL,
57253 (void*)&&ZEND_NULL_LABEL,
57254 (void*)&&ZEND_NULL_LABEL,
57255 (void*)&&ZEND_NULL_LABEL,
57256 (void*)&&ZEND_NULL_LABEL,
57257 (void*)&&ZEND_NULL_LABEL,
57258 (void*)&&ZEND_NULL_LABEL,
57259 (void*)&&ZEND_NULL_LABEL,
57260 (void*)&&ZEND_NULL_LABEL,
57261 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CONST_LABEL,
57262 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57263 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
57264 (void*)&&ZEND_NULL_LABEL,
57265 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CV_LABEL,
57266 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
57267 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57268 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57269 (void*)&&ZEND_NULL_LABEL,
57270 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_LABEL,
57271 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CONST_LABEL,
57272 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57273 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
57274 (void*)&&ZEND_NULL_LABEL,
57275 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CV_LABEL,
57276 (void*)&&ZEND_ECHO_SPEC_CONST_LABEL,
57277 (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
57278 (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
57279 (void*)&&ZEND_NULL_LABEL,
57280 (void*)&&ZEND_ECHO_SPEC_CV_LABEL,
57281 (void*)&&ZEND_NULL_LABEL,
57282 (void*)&&ZEND_NULL_LABEL,
57283 (void*)&&ZEND_NULL_LABEL,
57284 (void*)&&ZEND_NULL_LABEL,
57285 (void*)&&ZEND_NULL_LABEL,
57286 (void*)&&ZEND_NULL_LABEL,
57287 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
57288 (void*)&&ZEND_NULL_LABEL,
57289 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
57290 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
57291 (void*)&&ZEND_NULL_LABEL,
57292 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
57293 (void*)&&ZEND_NULL_LABEL,
57294 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
57295 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
57296 (void*)&&ZEND_NULL_LABEL,
57297 (void*)&&ZEND_NULL_LABEL,
57298 (void*)&&ZEND_NULL_LABEL,
57299 (void*)&&ZEND_NULL_LABEL,
57300 (void*)&&ZEND_NULL_LABEL,
57301 (void*)&&ZEND_NULL_LABEL,
57302 (void*)&&ZEND_INSTANCEOF_SPEC_CV_CONST_LABEL,
57303 (void*)&&ZEND_NULL_LABEL,
57304 (void*)&&ZEND_INSTANCEOF_SPEC_CV_VAR_LABEL,
57305 (void*)&&ZEND_INSTANCEOF_SPEC_CV_UNUSED_LABEL,
57306 (void*)&&ZEND_NULL_LABEL,
57307 (void*)&&ZEND_GENERATOR_CREATE_SPEC_LABEL,
57308 (void*)&&ZEND_NULL_LABEL,
57309 (void*)&&ZEND_NULL_LABEL,
57310 (void*)&&ZEND_MAKE_REF_SPEC_VAR_UNUSED_LABEL,
57311 (void*)&&ZEND_NULL_LABEL,
57312 (void*)&&ZEND_MAKE_REF_SPEC_CV_UNUSED_LABEL,
57313 (void*)&&ZEND_DECLARE_FUNCTION_SPEC_LABEL,
57314 (void*)&&ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_LABEL,
57315 (void*)&&ZEND_DECLARE_CONST_SPEC_CONST_CONST_LABEL,
57316 (void*)&&ZEND_DECLARE_CLASS_SPEC_CONST_LABEL,
57317 (void*)&&ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_LABEL,
57318 (void*)&&ZEND_DECLARE_ANON_CLASS_SPEC_LABEL,
57319 (void*)&&ZEND_ADD_ARRAY_UNPACK_SPEC_LABEL,
57320 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_LABEL,
57321 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
57322 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
57323 (void*)&&ZEND_NULL_LABEL,
57324 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_LABEL,
57325 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
57326 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57327 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57328 (void*)&&ZEND_NULL_LABEL,
57329 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
57330 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
57331 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57332 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
57333 (void*)&&ZEND_NULL_LABEL,
57334 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
57335 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_LABEL,
57336 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57337 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
57338 (void*)&&ZEND_NULL_LABEL,
57339 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_LABEL,
57340 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_LABEL,
57341 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
57342 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
57343 (void*)&&ZEND_NULL_LABEL,
57344 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_LABEL,
57345 (void*)&&ZEND_HANDLE_EXCEPTION_SPEC_LABEL,
57346 (void*)&&ZEND_USER_OPCODE_SPEC_LABEL,
57347 (void*)&&ZEND_ASSERT_CHECK_SPEC_LABEL,
57348 (void*)&&ZEND_JMP_SET_SPEC_CONST_LABEL,
57349 (void*)&&ZEND_JMP_SET_SPEC_TMP_LABEL,
57350 (void*)&&ZEND_JMP_SET_SPEC_VAR_LABEL,
57351 (void*)&&ZEND_NULL_LABEL,
57352 (void*)&&ZEND_JMP_SET_SPEC_CV_LABEL,
57353 (void*)&&ZEND_UNSET_CV_SPEC_CV_UNUSED_LABEL,
57354 (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_LABEL,
57355 (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_LABEL,
57356 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CONST_LABEL,
57357 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
57358 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
57359 (void*)&&ZEND_NULL_LABEL,
57360 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CV_LABEL,
57361 (void*)&&ZEND_SEPARATE_SPEC_VAR_UNUSED_LABEL,
57362 (void*)&&ZEND_NULL_LABEL,
57363 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
57364 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
57365 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_LABEL,
57366 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_CV_LABEL,
57367 (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_LABEL,
57368 (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_LABEL,
57369 (void*)&&ZEND_DISCARD_EXCEPTION_SPEC_LABEL,
57370 (void*)&&ZEND_YIELD_SPEC_CONST_CONST_LABEL,
57371 (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
57372 (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
57373 (void*)&&ZEND_YIELD_SPEC_CONST_UNUSED_LABEL,
57374 (void*)&&ZEND_YIELD_SPEC_CONST_CV_LABEL,
57375 (void*)&&ZEND_YIELD_SPEC_TMP_CONST_LABEL,
57376 (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
57377 (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
57378 (void*)&&ZEND_YIELD_SPEC_TMP_UNUSED_LABEL,
57379 (void*)&&ZEND_YIELD_SPEC_TMP_CV_LABEL,
57380 (void*)&&ZEND_YIELD_SPEC_VAR_CONST_LABEL,
57381 (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
57382 (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
57383 (void*)&&ZEND_YIELD_SPEC_VAR_UNUSED_LABEL,
57384 (void*)&&ZEND_YIELD_SPEC_VAR_CV_LABEL,
57385 (void*)&&ZEND_YIELD_SPEC_UNUSED_CONST_LABEL,
57386 (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
57387 (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
57388 (void*)&&ZEND_YIELD_SPEC_UNUSED_UNUSED_LABEL,
57389 (void*)&&ZEND_YIELD_SPEC_UNUSED_CV_LABEL,
57390 (void*)&&ZEND_YIELD_SPEC_CV_CONST_LABEL,
57391 (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
57392 (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
57393 (void*)&&ZEND_YIELD_SPEC_CV_UNUSED_LABEL,
57394 (void*)&&ZEND_YIELD_SPEC_CV_CV_LABEL,
57395 (void*)&&ZEND_GENERATOR_RETURN_SPEC_CONST_LABEL,
57396 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57397 (void*)&&ZEND_GENERATOR_RETURN_SPEC_TMP_LABEL,
57398 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57399 (void*)&&ZEND_GENERATOR_RETURN_SPEC_VAR_LABEL,
57400 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57401 (void*)&&ZEND_NULL_LABEL,
57402 (void*)&&ZEND_NULL_LABEL,
57403 (void*)&&ZEND_GENERATOR_RETURN_SPEC_CV_LABEL,
57404 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
57405 (void*)&&ZEND_FAST_CALL_SPEC_LABEL,
57406 (void*)&&ZEND_FAST_RET_SPEC_LABEL,
57407 (void*)&&ZEND_RECV_VARIADIC_SPEC_UNUSED_LABEL,
57408 (void*)&&ZEND_SEND_UNPACK_SPEC_LABEL,
57409 (void*)&&ZEND_YIELD_FROM_SPEC_CONST_LABEL,
57410 (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
57411 (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
57412 (void*)&&ZEND_NULL_LABEL,
57413 (void*)&&ZEND_YIELD_FROM_SPEC_CV_LABEL,
57414 (void*)&&ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_LABEL,
57415 (void*)&&ZEND_BIND_GLOBAL_SPEC_CV_CONST_LABEL,
57416 (void*)&&ZEND_COALESCE_SPEC_CONST_LABEL,
57417 (void*)&&ZEND_COALESCE_SPEC_TMP_LABEL,
57418 (void*)&&ZEND_COALESCE_SPEC_VAR_LABEL,
57419 (void*)&&ZEND_NULL_LABEL,
57420 (void*)&&ZEND_COALESCE_SPEC_CV_LABEL,
57421 (void*)&&ZEND_SPACESHIP_SPEC_CONST_CONST_LABEL,
57422 (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
57423 (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
57424 (void*)&&ZEND_NULL_LABEL,
57425 (void*)&&ZEND_SPACESHIP_SPEC_CONST_CV_LABEL,
57426 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
57427 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57428 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57429 (void*)&&ZEND_NULL_LABEL,
57430 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
57431 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
57432 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57433 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
57434 (void*)&&ZEND_NULL_LABEL,
57435 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
57436 (void*)&&ZEND_NULL_LABEL,
57437 (void*)&&ZEND_NULL_LABEL,
57438 (void*)&&ZEND_NULL_LABEL,
57439 (void*)&&ZEND_NULL_LABEL,
57440 (void*)&&ZEND_NULL_LABEL,
57441 (void*)&&ZEND_SPACESHIP_SPEC_CV_CONST_LABEL,
57442 (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
57443 (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
57444 (void*)&&ZEND_NULL_LABEL,
57445 (void*)&&ZEND_SPACESHIP_SPEC_CV_CV_LABEL,
57446 (void*)&&ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57447 (void*)&&ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_LABEL,
57448 (void*)&&ZEND_NULL_LABEL,
57449 (void*)&&ZEND_NULL_LABEL,
57450 (void*)&&ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57451 (void*)&&ZEND_NULL_LABEL,
57452 (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_LABEL,
57453 (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_LABEL,
57454 (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_LABEL,
57455 (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_LABEL,
57456 (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_LABEL,
57457 (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_LABEL,
57458 (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_LABEL,
57459 (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_LABEL,
57460 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_LABEL,
57461 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57462 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57463 (void*)&&ZEND_NULL_LABEL,
57464 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
57465 (void*)&&ZEND_NULL_LABEL,
57466 (void*)&&ZEND_NULL_LABEL,
57467 (void*)&&ZEND_NULL_LABEL,
57468 (void*)&&ZEND_NULL_LABEL,
57469 (void*)&&ZEND_NULL_LABEL,
57470 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_LABEL,
57471 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57472 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57473 (void*)&&ZEND_NULL_LABEL,
57474 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
57475 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_LABEL,
57476 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57477 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57478 (void*)&&ZEND_NULL_LABEL,
57479 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
57480 (void*)&&ZEND_NULL_LABEL,
57481 (void*)&&ZEND_NULL_LABEL,
57482 (void*)&&ZEND_NULL_LABEL,
57483 (void*)&&ZEND_NULL_LABEL,
57484 (void*)&&ZEND_NULL_LABEL,
57485 (void*)&&ZEND_BIND_LEXICAL_SPEC_TMP_CV_LABEL,
57486 (void*)&&ZEND_BIND_STATIC_SPEC_CV_LABEL,
57487 (void*)&&ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_LABEL,
57488 (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_LABEL,
57489 (void*)&&ZEND_NULL_LABEL,
57490 (void*)&&ZEND_NULL_LABEL,
57491 (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
57492 (void*)&&ZEND_NULL_LABEL,
57493 (void*)&&ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_LABEL,
57494 (void*)&&ZEND_SWITCH_LONG_SPEC_CONST_CONST_LABEL,
57495 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57496 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57497 (void*)&&ZEND_NULL_LABEL,
57498 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
57499 (void*)&&ZEND_SWITCH_STRING_SPEC_CONST_CONST_LABEL,
57500 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57501 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57502 (void*)&&ZEND_NULL_LABEL,
57503 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
57504 (void*)&&ZEND_IN_ARRAY_SPEC_CONST_CONST_LABEL,
57505 (void*)&&ZEND_IN_ARRAY_SPEC_TMP_CONST_LABEL,
57506 (void*)&&ZEND_IN_ARRAY_SPEC_VAR_CONST_LABEL,
57507 (void*)&&ZEND_NULL_LABEL,
57508 (void*)&&ZEND_IN_ARRAY_SPEC_CV_CONST_LABEL,
57509 (void*)&&ZEND_COUNT_SPEC_CONST_UNUSED_LABEL,
57510 (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
57511 (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
57512 (void*)&&ZEND_NULL_LABEL,
57513 (void*)&&ZEND_COUNT_SPEC_CV_UNUSED_LABEL,
57514 (void*)&&ZEND_GET_CLASS_SPEC_CONST_UNUSED_LABEL,
57515 (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
57516 (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
57517 (void*)&&ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57518 (void*)&&ZEND_GET_CLASS_SPEC_CV_UNUSED_LABEL,
57519 (void*)&&ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_LABEL,
57520 (void*)&&ZEND_GET_TYPE_SPEC_CONST_UNUSED_LABEL,
57521 (void*)&&ZEND_GET_TYPE_SPEC_TMP_UNUSED_LABEL,
57522 (void*)&&ZEND_GET_TYPE_SPEC_VAR_UNUSED_LABEL,
57523 (void*)&&ZEND_NULL_LABEL,
57524 (void*)&&ZEND_GET_TYPE_SPEC_CV_UNUSED_LABEL,
57525 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_LABEL,
57526 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
57527 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
57528 (void*)&&ZEND_NULL_LABEL,
57529 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_LABEL,
57530 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
57531 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57532 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57533 (void*)&&ZEND_NULL_LABEL,
57534 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
57535 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
57536 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57537 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
57538 (void*)&&ZEND_NULL_LABEL,
57539 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_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_ARRAY_KEY_EXISTS_SPEC_CV_CONST_LABEL,
57546 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
57547 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
57548 (void*)&&ZEND_NULL_LABEL,
57549 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL,
57550 (void*)&&ZEND_MATCH_SPEC_CONST_CONST_LABEL,
57551 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57552 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57553 (void*)&&ZEND_NULL_LABEL,
57554 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
57555 (void*)&&ZEND_NULL_LABEL,
57556 (void*)&&ZEND_NULL_LABEL,
57557 (void*)&&ZEND_NULL_LABEL,
57558 (void*)&&ZEND_NULL_LABEL,
57559 (void*)&&ZEND_NULL_LABEL,
57560 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CONST_LABEL,
57561 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_TMP_LABEL,
57562 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_VAR_LABEL,
57563 (void*)&&ZEND_NULL_LABEL,
57564 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CV_LABEL,
57565 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CONST_LABEL,
57566 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_TMP_LABEL,
57567 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_VAR_LABEL,
57568 (void*)&&ZEND_NULL_LABEL,
57569 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CV_LABEL,
57570 (void*)&&ZEND_NULL_LABEL,
57571 (void*)&&ZEND_NULL_LABEL,
57572 (void*)&&ZEND_NULL_LABEL,
57573 (void*)&&ZEND_NULL_LABEL,
57574 (void*)&&ZEND_NULL_LABEL,
57575 (void*)&&ZEND_NULL_LABEL,
57576 (void*)&&ZEND_NULL_LABEL,
57577 (void*)&&ZEND_NULL_LABEL,
57578 (void*)&&ZEND_NULL_LABEL,
57579 (void*)&&ZEND_NULL_LABEL,
57580 (void*)&&ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_LABEL,
57581 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57582 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57583 (void*)&&ZEND_NULL_LABEL,
57584 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
57585 (void*)&&ZEND_JMP_NULL_SPEC_CONST_LABEL,
57586 (void*)&&ZEND_JMP_NULL_SPEC_TMP_LABEL,
57587 (void*)&&ZEND_JMP_NULL_SPEC_VAR_LABEL,
57588 (void*)&&ZEND_NULL_LABEL,
57589 (void*)&&ZEND_JMP_NULL_SPEC_CV_LABEL,
57590 (void*)&&ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_LABEL,
57591 (void*)&&ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_LABEL,
57592 (void*)&&ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_LABEL,
57593 (void*)&&ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_LABEL,
57594 (void*)&&ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_LABEL,
57595 (void*)&&ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_LABEL,
57596 (void*)&&ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_LABEL,
57597 (void*)&&ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_LABEL,
57598 (void*)&&ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_LABEL,
57599 (void*)&&ZEND_FRAMELESS_ICALL_2_SPEC_LABEL,
57600 (void*)&&ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_LABEL,
57601 (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_LABEL,
57602 (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_LABEL,
57603 (void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL,
57604 (void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL,
57605 (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL,
57606 (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL,
57607 (void*)&&ZEND_NULL_LABEL,
57608 (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
57609 (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
57610 (void*)&&ZEND_NULL_LABEL,
57611 (void*)&&ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_LABEL,
57612 (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL,
57613 (void*)&&ZEND_NULL_LABEL,
57614 (void*)&&ZEND_NULL_LABEL,
57615 (void*)&&ZEND_NULL_LABEL,
57616 (void*)&&ZEND_NULL_LABEL,
57617 (void*)&&ZEND_NULL_LABEL,
57618 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57619 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57620 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57621 (void*)&&ZEND_NULL_LABEL,
57622 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57623 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57624 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57625 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57626 (void*)&&ZEND_NULL_LABEL,
57627 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57628 (void*)&&ZEND_NULL_LABEL,
57629 (void*)&&ZEND_NULL_LABEL,
57630 (void*)&&ZEND_NULL_LABEL,
57631 (void*)&&ZEND_NULL_LABEL,
57632 (void*)&&ZEND_NULL_LABEL,
57633 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57634 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57635 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57636 (void*)&&ZEND_NULL_LABEL,
57637 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57638 (void*)&&ZEND_NULL_LABEL,
57639 (void*)&&ZEND_NULL_LABEL,
57640 (void*)&&ZEND_NULL_LABEL,
57641 (void*)&&ZEND_NULL_LABEL,
57642 (void*)&&ZEND_NULL_LABEL,
57643 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57644 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57645 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57646 (void*)&&ZEND_NULL_LABEL,
57647 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57648 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57649 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57650 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57651 (void*)&&ZEND_NULL_LABEL,
57652 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57653 (void*)&&ZEND_NULL_LABEL,
57654 (void*)&&ZEND_NULL_LABEL,
57655 (void*)&&ZEND_NULL_LABEL,
57656 (void*)&&ZEND_NULL_LABEL,
57657 (void*)&&ZEND_NULL_LABEL,
57658 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
57659 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57660 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57661 (void*)&&ZEND_NULL_LABEL,
57662 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57663 (void*)&&ZEND_NULL_LABEL,
57664 (void*)&&ZEND_NULL_LABEL,
57665 (void*)&&ZEND_NULL_LABEL,
57666 (void*)&&ZEND_NULL_LABEL,
57667 (void*)&&ZEND_NULL_LABEL,
57668 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57669 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57670 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57671 (void*)&&ZEND_NULL_LABEL,
57672 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57673 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57674 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57675 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57676 (void*)&&ZEND_NULL_LABEL,
57677 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57678 (void*)&&ZEND_NULL_LABEL,
57679 (void*)&&ZEND_NULL_LABEL,
57680 (void*)&&ZEND_NULL_LABEL,
57681 (void*)&&ZEND_NULL_LABEL,
57682 (void*)&&ZEND_NULL_LABEL,
57683 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57684 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57685 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57686 (void*)&&ZEND_NULL_LABEL,
57687 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57688 (void*)&&ZEND_NULL_LABEL,
57689 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57690 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57691 (void*)&&ZEND_NULL_LABEL,
57692 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
57693 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57694 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57695 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57696 (void*)&&ZEND_NULL_LABEL,
57697 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57698 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57699 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57700 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57701 (void*)&&ZEND_NULL_LABEL,
57702 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57703 (void*)&&ZEND_NULL_LABEL,
57704 (void*)&&ZEND_NULL_LABEL,
57705 (void*)&&ZEND_NULL_LABEL,
57706 (void*)&&ZEND_NULL_LABEL,
57707 (void*)&&ZEND_NULL_LABEL,
57708 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57709 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57710 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57711 (void*)&&ZEND_NULL_LABEL,
57712 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57713 (void*)&&ZEND_NULL_LABEL,
57714 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57715 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57716 (void*)&&ZEND_NULL_LABEL,
57717 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
57718 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57719 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57720 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57721 (void*)&&ZEND_NULL_LABEL,
57722 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57723 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57724 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57725 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57726 (void*)&&ZEND_NULL_LABEL,
57727 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57728 (void*)&&ZEND_NULL_LABEL,
57729 (void*)&&ZEND_NULL_LABEL,
57730 (void*)&&ZEND_NULL_LABEL,
57731 (void*)&&ZEND_NULL_LABEL,
57732 (void*)&&ZEND_NULL_LABEL,
57733 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
57734 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57735 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57736 (void*)&&ZEND_NULL_LABEL,
57737 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57738 (void*)&&ZEND_NULL_LABEL,
57739 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57740 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57741 (void*)&&ZEND_NULL_LABEL,
57742 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
57743 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57744 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57745 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57746 (void*)&&ZEND_NULL_LABEL,
57747 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57748 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57749 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57750 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57751 (void*)&&ZEND_NULL_LABEL,
57752 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57753 (void*)&&ZEND_NULL_LABEL,
57754 (void*)&&ZEND_NULL_LABEL,
57755 (void*)&&ZEND_NULL_LABEL,
57756 (void*)&&ZEND_NULL_LABEL,
57757 (void*)&&ZEND_NULL_LABEL,
57758 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57759 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57760 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57761 (void*)&&ZEND_NULL_LABEL,
57762 (void*)&&ZEND_SUB_DOUBLE_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_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57769 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57770 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57771 (void*)&&ZEND_NULL_LABEL,
57772 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57773 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57774 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57775 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57776 (void*)&&ZEND_NULL_LABEL,
57777 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57778 (void*)&&ZEND_NULL_LABEL,
57779 (void*)&&ZEND_NULL_LABEL,
57780 (void*)&&ZEND_NULL_LABEL,
57781 (void*)&&ZEND_NULL_LABEL,
57782 (void*)&&ZEND_NULL_LABEL,
57783 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
57784 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57785 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
57786 (void*)&&ZEND_NULL_LABEL,
57787 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_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_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57794 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57795 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57796 (void*)&&ZEND_NULL_LABEL,
57797 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57798 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57799 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57800 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57801 (void*)&&ZEND_NULL_LABEL,
57802 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57803 (void*)&&ZEND_NULL_LABEL,
57804 (void*)&&ZEND_NULL_LABEL,
57805 (void*)&&ZEND_NULL_LABEL,
57806 (void*)&&ZEND_NULL_LABEL,
57807 (void*)&&ZEND_NULL_LABEL,
57808 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57809 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57810 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57811 (void*)&&ZEND_NULL_LABEL,
57812 (void*)&&ZEND_MUL_LONG_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_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57819 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57820 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57821 (void*)&&ZEND_NULL_LABEL,
57822 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57823 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57824 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57825 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57826 (void*)&&ZEND_NULL_LABEL,
57827 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57828 (void*)&&ZEND_NULL_LABEL,
57829 (void*)&&ZEND_NULL_LABEL,
57830 (void*)&&ZEND_NULL_LABEL,
57831 (void*)&&ZEND_NULL_LABEL,
57832 (void*)&&ZEND_NULL_LABEL,
57833 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57834 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57835 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57836 (void*)&&ZEND_NULL_LABEL,
57837 (void*)&&ZEND_MUL_DOUBLE_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_NULL_LABEL,
57844 (void*)&&ZEND_NULL_LABEL,
57845 (void*)&&ZEND_NULL_LABEL,
57846 (void*)&&ZEND_NULL_LABEL,
57847 (void*)&&ZEND_NULL_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_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57854 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57855 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57856 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57857 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57858 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57859 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57860 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57861 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57862 (void*)&&ZEND_NULL_LABEL,
57863 (void*)&&ZEND_NULL_LABEL,
57864 (void*)&&ZEND_NULL_LABEL,
57865 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57866 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57867 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57868 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57869 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57870 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57871 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57872 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57873 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57874 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57875 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57876 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57877 (void*)&&ZEND_NULL_LABEL,
57878 (void*)&&ZEND_NULL_LABEL,
57879 (void*)&&ZEND_NULL_LABEL,
57880 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57881 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57882 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57883 (void*)&&ZEND_NULL_LABEL,
57884 (void*)&&ZEND_NULL_LABEL,
57885 (void*)&&ZEND_NULL_LABEL,
57886 (void*)&&ZEND_NULL_LABEL,
57887 (void*)&&ZEND_NULL_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_NULL_LABEL,
57894 (void*)&&ZEND_NULL_LABEL,
57895 (void*)&&ZEND_NULL_LABEL,
57896 (void*)&&ZEND_NULL_LABEL,
57897 (void*)&&ZEND_NULL_LABEL,
57898 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
57899 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57900 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57901 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57902 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57903 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57904 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57905 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57906 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57907 (void*)&&ZEND_NULL_LABEL,
57908 (void*)&&ZEND_NULL_LABEL,
57909 (void*)&&ZEND_NULL_LABEL,
57910 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
57911 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57912 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57913 (void*)&&ZEND_NULL_LABEL,
57914 (void*)&&ZEND_NULL_LABEL,
57915 (void*)&&ZEND_NULL_LABEL,
57916 (void*)&&ZEND_NULL_LABEL,
57917 (void*)&&ZEND_NULL_LABEL,
57918 (void*)&&ZEND_NULL_LABEL,
57919 (void*)&&ZEND_NULL_LABEL,
57920 (void*)&&ZEND_NULL_LABEL,
57921 (void*)&&ZEND_NULL_LABEL,
57922 (void*)&&ZEND_NULL_LABEL,
57923 (void*)&&ZEND_NULL_LABEL,
57924 (void*)&&ZEND_NULL_LABEL,
57925 (void*)&&ZEND_NULL_LABEL,
57926 (void*)&&ZEND_NULL_LABEL,
57927 (void*)&&ZEND_NULL_LABEL,
57928 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57929 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57930 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57931 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57932 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57933 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57934 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57935 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57936 (void*)&&ZEND_IS_EQUAL_DOUBLE_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_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57941 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57942 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57943 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57944 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57945 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57946 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57947 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57948 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57949 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57950 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57951 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57952 (void*)&&ZEND_NULL_LABEL,
57953 (void*)&&ZEND_NULL_LABEL,
57954 (void*)&&ZEND_NULL_LABEL,
57955 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57956 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57957 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57958 (void*)&&ZEND_NULL_LABEL,
57959 (void*)&&ZEND_NULL_LABEL,
57960 (void*)&&ZEND_NULL_LABEL,
57961 (void*)&&ZEND_NULL_LABEL,
57962 (void*)&&ZEND_NULL_LABEL,
57963 (void*)&&ZEND_NULL_LABEL,
57964 (void*)&&ZEND_NULL_LABEL,
57965 (void*)&&ZEND_NULL_LABEL,
57966 (void*)&&ZEND_NULL_LABEL,
57967 (void*)&&ZEND_NULL_LABEL,
57968 (void*)&&ZEND_NULL_LABEL,
57969 (void*)&&ZEND_NULL_LABEL,
57970 (void*)&&ZEND_NULL_LABEL,
57971 (void*)&&ZEND_NULL_LABEL,
57972 (void*)&&ZEND_NULL_LABEL,
57973 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57974 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57975 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57976 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57977 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57978 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57979 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57980 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57981 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57982 (void*)&&ZEND_NULL_LABEL,
57983 (void*)&&ZEND_NULL_LABEL,
57984 (void*)&&ZEND_NULL_LABEL,
57985 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57986 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57987 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57988 (void*)&&ZEND_NULL_LABEL,
57989 (void*)&&ZEND_NULL_LABEL,
57990 (void*)&&ZEND_NULL_LABEL,
57991 (void*)&&ZEND_NULL_LABEL,
57992 (void*)&&ZEND_NULL_LABEL,
57993 (void*)&&ZEND_NULL_LABEL,
57994 (void*)&&ZEND_NULL_LABEL,
57995 (void*)&&ZEND_NULL_LABEL,
57996 (void*)&&ZEND_NULL_LABEL,
57997 (void*)&&ZEND_NULL_LABEL,
57998 (void*)&&ZEND_NULL_LABEL,
57999 (void*)&&ZEND_NULL_LABEL,
58000 (void*)&&ZEND_NULL_LABEL,
58001 (void*)&&ZEND_NULL_LABEL,
58002 (void*)&&ZEND_NULL_LABEL,
58003 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58004 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58005 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58006 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58007 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58008 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58009 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58010 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58011 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58012 (void*)&&ZEND_NULL_LABEL,
58013 (void*)&&ZEND_NULL_LABEL,
58014 (void*)&&ZEND_NULL_LABEL,
58015 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58016 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58017 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58018 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58019 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58020 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58021 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58022 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58023 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58024 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58025 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58026 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58027 (void*)&&ZEND_NULL_LABEL,
58028 (void*)&&ZEND_NULL_LABEL,
58029 (void*)&&ZEND_NULL_LABEL,
58030 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58031 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58032 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58033 (void*)&&ZEND_NULL_LABEL,
58034 (void*)&&ZEND_NULL_LABEL,
58035 (void*)&&ZEND_NULL_LABEL,
58036 (void*)&&ZEND_NULL_LABEL,
58037 (void*)&&ZEND_NULL_LABEL,
58038 (void*)&&ZEND_NULL_LABEL,
58039 (void*)&&ZEND_NULL_LABEL,
58040 (void*)&&ZEND_NULL_LABEL,
58041 (void*)&&ZEND_NULL_LABEL,
58042 (void*)&&ZEND_NULL_LABEL,
58043 (void*)&&ZEND_NULL_LABEL,
58044 (void*)&&ZEND_NULL_LABEL,
58045 (void*)&&ZEND_NULL_LABEL,
58046 (void*)&&ZEND_NULL_LABEL,
58047 (void*)&&ZEND_NULL_LABEL,
58048 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58049 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58050 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58051 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58052 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58053 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58054 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58055 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58056 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58057 (void*)&&ZEND_NULL_LABEL,
58058 (void*)&&ZEND_NULL_LABEL,
58059 (void*)&&ZEND_NULL_LABEL,
58060 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58061 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58062 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58063 (void*)&&ZEND_NULL_LABEL,
58064 (void*)&&ZEND_NULL_LABEL,
58065 (void*)&&ZEND_NULL_LABEL,
58066 (void*)&&ZEND_NULL_LABEL,
58067 (void*)&&ZEND_NULL_LABEL,
58068 (void*)&&ZEND_NULL_LABEL,
58069 (void*)&&ZEND_NULL_LABEL,
58070 (void*)&&ZEND_NULL_LABEL,
58071 (void*)&&ZEND_NULL_LABEL,
58072 (void*)&&ZEND_NULL_LABEL,
58073 (void*)&&ZEND_NULL_LABEL,
58074 (void*)&&ZEND_NULL_LABEL,
58075 (void*)&&ZEND_NULL_LABEL,
58076 (void*)&&ZEND_NULL_LABEL,
58077 (void*)&&ZEND_NULL_LABEL,
58078 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58079 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58080 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58081 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58082 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58083 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58084 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58085 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58086 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_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_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58091 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58092 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58093 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58094 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58095 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58096 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58097 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58098 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58099 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58100 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58101 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58102 (void*)&&ZEND_NULL_LABEL,
58103 (void*)&&ZEND_NULL_LABEL,
58104 (void*)&&ZEND_NULL_LABEL,
58105 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58106 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58107 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58108 (void*)&&ZEND_NULL_LABEL,
58109 (void*)&&ZEND_NULL_LABEL,
58110 (void*)&&ZEND_NULL_LABEL,
58111 (void*)&&ZEND_NULL_LABEL,
58112 (void*)&&ZEND_NULL_LABEL,
58113 (void*)&&ZEND_NULL_LABEL,
58114 (void*)&&ZEND_NULL_LABEL,
58115 (void*)&&ZEND_NULL_LABEL,
58116 (void*)&&ZEND_NULL_LABEL,
58117 (void*)&&ZEND_NULL_LABEL,
58118 (void*)&&ZEND_NULL_LABEL,
58119 (void*)&&ZEND_NULL_LABEL,
58120 (void*)&&ZEND_NULL_LABEL,
58121 (void*)&&ZEND_NULL_LABEL,
58122 (void*)&&ZEND_NULL_LABEL,
58123 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58124 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58125 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58126 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58127 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58128 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58129 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58130 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58131 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58132 (void*)&&ZEND_NULL_LABEL,
58133 (void*)&&ZEND_NULL_LABEL,
58134 (void*)&&ZEND_NULL_LABEL,
58135 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58136 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58137 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58138 (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
58139 (void*)&&ZEND_NULL_LABEL,
58140 (void*)&&ZEND_NULL_LABEL,
58141 (void*)&&ZEND_NULL_LABEL,
58142 (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
58143 (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
58144 (void*)&&ZEND_NULL_LABEL,
58145 (void*)&&ZEND_NULL_LABEL,
58146 (void*)&&ZEND_NULL_LABEL,
58147 (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
58148 (void*)&&ZEND_NULL_LABEL,
58149 (void*)&&ZEND_NULL_LABEL,
58150 (void*)&&ZEND_NULL_LABEL,
58151 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58152 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58153 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58154 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58155 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58156 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58157 (void*)&&ZEND_NULL_LABEL,
58158 (void*)&&ZEND_NULL_LABEL,
58159 (void*)&&ZEND_NULL_LABEL,
58160 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
58161 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58162 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58163 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58164 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58165 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58166 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58167 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58168 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58169 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58170 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58171 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58172 (void*)&&ZEND_NULL_LABEL,
58173 (void*)&&ZEND_NULL_LABEL,
58174 (void*)&&ZEND_NULL_LABEL,
58175 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58176 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58177 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58178 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58179 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58180 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58181 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58182 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58183 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58184 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58185 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58186 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58187 (void*)&&ZEND_NULL_LABEL,
58188 (void*)&&ZEND_NULL_LABEL,
58189 (void*)&&ZEND_NULL_LABEL,
58190 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58191 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58192 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58193 (void*)&&ZEND_NULL_LABEL,
58194 (void*)&&ZEND_NULL_LABEL,
58195 (void*)&&ZEND_NULL_LABEL,
58196 (void*)&&ZEND_NULL_LABEL,
58197 (void*)&&ZEND_NULL_LABEL,
58198 (void*)&&ZEND_NULL_LABEL,
58199 (void*)&&ZEND_NULL_LABEL,
58200 (void*)&&ZEND_NULL_LABEL,
58201 (void*)&&ZEND_NULL_LABEL,
58202 (void*)&&ZEND_NULL_LABEL,
58203 (void*)&&ZEND_NULL_LABEL,
58204 (void*)&&ZEND_NULL_LABEL,
58205 (void*)&&ZEND_NULL_LABEL,
58206 (void*)&&ZEND_NULL_LABEL,
58207 (void*)&&ZEND_NULL_LABEL,
58208 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
58209 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58210 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58211 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58212 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58213 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58214 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58215 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58216 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_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_TMPVARCV_TMPVARCV_LABEL,
58221 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58222 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58223 (void*)&&ZEND_NULL_LABEL,
58224 (void*)&&ZEND_NULL_LABEL,
58225 (void*)&&ZEND_NULL_LABEL,
58226 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58227 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58228 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58229 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58230 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58231 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58232 (void*)&&ZEND_NULL_LABEL,
58233 (void*)&&ZEND_NULL_LABEL,
58234 (void*)&&ZEND_NULL_LABEL,
58235 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58236 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58237 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58238 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58239 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58240 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58241 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58242 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58243 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58244 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58245 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58246 (void*)&&ZEND_IS_SMALLER_DOUBLE_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_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58251 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58252 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58253 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58254 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58255 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58256 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58257 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58258 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58259 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58260 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58261 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58262 (void*)&&ZEND_NULL_LABEL,
58263 (void*)&&ZEND_NULL_LABEL,
58264 (void*)&&ZEND_NULL_LABEL,
58265 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58266 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58267 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58268 (void*)&&ZEND_NULL_LABEL,
58269 (void*)&&ZEND_NULL_LABEL,
58270 (void*)&&ZEND_NULL_LABEL,
58271 (void*)&&ZEND_NULL_LABEL,
58272 (void*)&&ZEND_NULL_LABEL,
58273 (void*)&&ZEND_NULL_LABEL,
58274 (void*)&&ZEND_NULL_LABEL,
58275 (void*)&&ZEND_NULL_LABEL,
58276 (void*)&&ZEND_NULL_LABEL,
58277 (void*)&&ZEND_NULL_LABEL,
58278 (void*)&&ZEND_NULL_LABEL,
58279 (void*)&&ZEND_NULL_LABEL,
58280 (void*)&&ZEND_NULL_LABEL,
58281 (void*)&&ZEND_NULL_LABEL,
58282 (void*)&&ZEND_NULL_LABEL,
58283 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58284 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58285 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58286 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58287 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58288 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58289 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58290 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58291 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_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_TMPVARCV_TMPVARCV_LABEL,
58296 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58297 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58298 (void*)&&ZEND_NULL_LABEL,
58299 (void*)&&ZEND_NULL_LABEL,
58300 (void*)&&ZEND_NULL_LABEL,
58301 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58302 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58303 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58304 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58305 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58306 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58307 (void*)&&ZEND_NULL_LABEL,
58308 (void*)&&ZEND_NULL_LABEL,
58309 (void*)&&ZEND_NULL_LABEL,
58310 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
58311 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58312 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58313 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58314 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58315 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58316 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58317 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58318 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58319 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58320 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58321 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_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_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58326 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58327 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58328 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58329 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58330 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58331 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58332 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58333 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58334 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58335 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58336 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58337 (void*)&&ZEND_NULL_LABEL,
58338 (void*)&&ZEND_NULL_LABEL,
58339 (void*)&&ZEND_NULL_LABEL,
58340 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58341 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58342 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58343 (void*)&&ZEND_NULL_LABEL,
58344 (void*)&&ZEND_NULL_LABEL,
58345 (void*)&&ZEND_NULL_LABEL,
58346 (void*)&&ZEND_NULL_LABEL,
58347 (void*)&&ZEND_NULL_LABEL,
58348 (void*)&&ZEND_NULL_LABEL,
58349 (void*)&&ZEND_NULL_LABEL,
58350 (void*)&&ZEND_NULL_LABEL,
58351 (void*)&&ZEND_NULL_LABEL,
58352 (void*)&&ZEND_NULL_LABEL,
58353 (void*)&&ZEND_NULL_LABEL,
58354 (void*)&&ZEND_NULL_LABEL,
58355 (void*)&&ZEND_NULL_LABEL,
58356 (void*)&&ZEND_NULL_LABEL,
58357 (void*)&&ZEND_NULL_LABEL,
58358 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
58359 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58360 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58361 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58362 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58363 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58364 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
58365 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58366 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_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_TMPVARCV_TMPVARCV_LABEL,
58371 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58372 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58373 (void*)&&ZEND_NULL_LABEL,
58374 (void*)&&ZEND_NULL_LABEL,
58375 (void*)&&ZEND_NULL_LABEL,
58376 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58377 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58378 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58379 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58380 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58381 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_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_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
58386 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
58387 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
58388 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58389 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58390 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58391 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58392 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58393 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58394 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58395 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58396 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_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_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58401 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58402 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58403 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58404 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58405 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58406 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58407 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58408 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58409 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58410 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58411 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58412 (void*)&&ZEND_NULL_LABEL,
58413 (void*)&&ZEND_NULL_LABEL,
58414 (void*)&&ZEND_NULL_LABEL,
58415 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58416 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58417 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58418 (void*)&&ZEND_NULL_LABEL,
58419 (void*)&&ZEND_NULL_LABEL,
58420 (void*)&&ZEND_NULL_LABEL,
58421 (void*)&&ZEND_NULL_LABEL,
58422 (void*)&&ZEND_NULL_LABEL,
58423 (void*)&&ZEND_NULL_LABEL,
58424 (void*)&&ZEND_NULL_LABEL,
58425 (void*)&&ZEND_NULL_LABEL,
58426 (void*)&&ZEND_NULL_LABEL,
58427 (void*)&&ZEND_NULL_LABEL,
58428 (void*)&&ZEND_NULL_LABEL,
58429 (void*)&&ZEND_NULL_LABEL,
58430 (void*)&&ZEND_NULL_LABEL,
58431 (void*)&&ZEND_NULL_LABEL,
58432 (void*)&&ZEND_NULL_LABEL,
58433 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
58434 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
58435 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
58436 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58437 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58438 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58439 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
58440 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58441 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_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_TMPVARCV_TMPVARCV_LABEL,
58446 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
58447 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
58448 (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
58449 (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
58450 (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
58451 (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_LABEL,
58452 (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
58453 (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
58454 (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
58455 (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_LABEL,
58456 (void*)&&ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
58457 (void*)&&ZEND_POST_INC_LONG_SPEC_CV_LABEL,
58458 (void*)&&ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
58459 (void*)&&ZEND_POST_DEC_LONG_SPEC_CV_LABEL,
58460 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_CONST_LABEL,
58461 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58462 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58463 (void*)&&ZEND_NULL_LABEL,
58464 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
58465 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_LABEL,
58466 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58467 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58468 (void*)&&ZEND_NULL_LABEL,
58469 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
58470 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_CONST_LABEL,
58471 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58472 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58473 (void*)&&ZEND_NULL_LABEL,
58474 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
58475 (void*)&&ZEND_NULL_LABEL,
58476 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58477 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58478 (void*)&&ZEND_NULL_LABEL,
58479 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
58480 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
58481 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58482 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58483 (void*)&&ZEND_NULL_LABEL,
58484 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58485 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
58486 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58487 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58488 (void*)&&ZEND_NULL_LABEL,
58489 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
58490 (void*)&&ZEND_NULL_LABEL,
58491 (void*)&&ZEND_NULL_LABEL,
58492 (void*)&&ZEND_NULL_LABEL,
58493 (void*)&&ZEND_NULL_LABEL,
58494 (void*)&&ZEND_NULL_LABEL,
58495 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_LABEL,
58496 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58497 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58498 (void*)&&ZEND_NULL_LABEL,
58499 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
58500 (void*)&&ZEND_NULL_LABEL,
58501 (void*)&&ZEND_NULL_LABEL,
58502 (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_VAR_LABEL,
58503 (void*)&&ZEND_NULL_LABEL,
58504 (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_CV_LABEL,
58505 (void*)&&ZEND_NULL_LABEL,
58506 (void*)&&ZEND_NULL_LABEL,
58507 (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_LABEL,
58508 (void*)&&ZEND_NULL_LABEL,
58509 (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_LABEL,
58510 (void*)&&ZEND_SEND_VAL_SIMPLE_SPEC_CONST_LABEL,
58511 (void*)&&ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_LABEL,
58512 (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
58513 (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_LABEL,
58514 (void*)&&ZEND_NULL_LABEL
58515 };
58516 zend_opcode_handlers = (const void **) labels;
58517 zend_handlers_count = sizeof(labels) / sizeof(void*);
58518 memset(&hybrid_halt_op, 0, sizeof(hybrid_halt_op));
58519 hybrid_halt_op.handler = (void*)&&HYBRID_HALT_LABEL;
58520 #ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
58521 memset(vm_stack_data.hybrid_jit_red_zone, 0, ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE);
58522 #endif
58523 if (zend_touch_vm_stack_data) {
58524 zend_touch_vm_stack_data(&vm_stack_data);
58525 }
58526 goto HYBRID_HALT_LABEL;
58527 }
58528 #endif
58529
58530 LOAD_OPLINE();
58531 ZEND_VM_LOOP_INTERRUPT_CHECK();
58532
58533 #ifdef ZEND_CHECK_STACK_LIMIT
58534 if (UNEXPECTED(zend_call_stack_overflowed(EG(stack_limit)))) {
58535 zend_call_stack_size_error();
58536 /* No opline was executed before exception */
58537 EG(opline_before_exception) = NULL;
58538 LOAD_OPLINE();
58539 /* Fall through to handle exception below. */
58540 }
58541 #endif /* ZEND_CHECK_STACK_LIMIT */
58542
58543 while (1) {
58544 #if !defined(ZEND_VM_FP_GLOBAL_REG) || !defined(ZEND_VM_IP_GLOBAL_REG)
58545 int ret;
58546 #endif
58547 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
58548 HYBRID_SWITCH() {
58549 #else
58550 #if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
58551 ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58552 if (UNEXPECTED(!OPLINE)) {
58553 #else
58554 if (UNEXPECTED((ret = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)) != 0)) {
58555 #endif
58556 #endif
58557 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
58558 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC):
58559 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
58560 ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58561 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
58562 HYBRID_BREAK();
58563 HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC):
58564 VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC)
58565 ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58566 VM_TRACE_OP_END(ZEND_PRE_INC_STATIC_PROP_SPEC)
58567 HYBRID_BREAK();
58568 HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC):
58569 VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC)
58570 ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58571 VM_TRACE_OP_END(ZEND_POST_INC_STATIC_PROP_SPEC)
58572 HYBRID_BREAK();
58573 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC):
58574 VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC)
58575 ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58576 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_R_SPEC)
58577 HYBRID_BREAK();
58578 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_W_SPEC):
58579 VM_TRACE(ZEND_FETCH_STATIC_PROP_W_SPEC)
58580 ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58581 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_W_SPEC)
58582 HYBRID_BREAK();
58583 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_RW_SPEC):
58584 VM_TRACE(ZEND_FETCH_STATIC_PROP_RW_SPEC)
58585 ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58586 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_RW_SPEC)
58587 HYBRID_BREAK();
58588 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC):
58589 VM_TRACE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
58590 ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58591 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
58592 HYBRID_BREAK();
58593 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC):
58594 VM_TRACE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
58595 ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58596 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
58597 HYBRID_BREAK();
58598 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_IS_SPEC):
58599 VM_TRACE(ZEND_FETCH_STATIC_PROP_IS_SPEC)
58600 ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58601 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_IS_SPEC)
58602 HYBRID_BREAK();
58603 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST):
58604 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
58605 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58606 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
58607 HYBRID_BREAK();
58608 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP):
58609 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
58610 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58611 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
58612 HYBRID_BREAK();
58613 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR):
58614 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
58615 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58616 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
58617 HYBRID_BREAK();
58618 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV):
58619 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
58620 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58621 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
58622 HYBRID_BREAK();
58623 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC):
58624 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
58625 ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58626 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
58627 HYBRID_BREAK();
58628 zend_leave_helper_SPEC_LABEL:
58629 {
58630 zend_execute_data *old_execute_data;
58631 uint32_t call_info = EX_CALL_INFO();
58632 SAVE_OPLINE();
58633
58634 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)) {
58635 EG(current_execute_data) = EX(prev_execute_data);
58636 i_free_compiled_variables(execute_data);
58637
58638 #ifdef ZEND_PREFER_RELOAD
58639 call_info = EX_CALL_INFO();
58640 #endif
58641 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
58642 OBJ_RELEASE(Z_OBJ(execute_data->This));
58643 } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58644 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58645 }
58646 EG(vm_stack_top) = (zval*)execute_data;
58647 execute_data = EX(prev_execute_data);
58648
58649 if (UNEXPECTED(EG(exception) != NULL)) {
58650 zend_rethrow_exception(execute_data);
58651 HANDLE_EXCEPTION_LEAVE();
58652 }
58653
58654 LOAD_NEXT_OPLINE();
58655 ZEND_VM_LEAVE();
58656 } else if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP)) == 0)) {
58657 EG(current_execute_data) = EX(prev_execute_data);
58658 i_free_compiled_variables(execute_data);
58659
58660 #ifdef ZEND_PREFER_RELOAD
58661 call_info = EX_CALL_INFO();
58662 #endif
58663 if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58664 zend_clean_and_cache_symbol_table(EX(symbol_table));
58665 }
58666
58667 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
58668 zend_free_extra_named_params(EX(extra_named_params));
58669 }
58670
58671 /* Free extra args before releasing the closure,
58672 * as that may free the op_array. */
58673 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
58674
58675 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
58676 OBJ_RELEASE(Z_OBJ(execute_data->This));
58677 } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58678 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58679 }
58680
58681 old_execute_data = execute_data;
58682 execute_data = EX(prev_execute_data);
58683 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
58684
58685 if (UNEXPECTED(EG(exception) != NULL)) {
58686 zend_rethrow_exception(execute_data);
58687 HANDLE_EXCEPTION_LEAVE();
58688 }
58689
58690 LOAD_NEXT_OPLINE();
58691 ZEND_VM_LEAVE();
58692 } else if (EXPECTED((call_info & ZEND_CALL_TOP) == 0)) {
58693 if (EX(func)->op_array.last_var > 0) {
58694 zend_detach_symbol_table(execute_data);
58695 call_info |= ZEND_CALL_NEEDS_REATTACH;
58696 }
58697 zend_destroy_static_vars(&EX(func)->op_array);
58698 destroy_op_array(&EX(func)->op_array);
58699 efree_size(EX(func), sizeof(zend_op_array));
58700 old_execute_data = execute_data;
58701 execute_data = EG(current_execute_data) = EX(prev_execute_data);
58702 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
58703
58704 if (call_info & ZEND_CALL_NEEDS_REATTACH) {
58705 if (EX(func)->op_array.last_var > 0) {
58706 zend_attach_symbol_table(execute_data);
58707 } else {
58708 ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_NEEDS_REATTACH);
58709 }
58710 }
58711 if (UNEXPECTED(EG(exception) != NULL)) {
58712 zend_rethrow_exception(execute_data);
58713 HANDLE_EXCEPTION_LEAVE();
58714 }
58715
58716 LOAD_NEXT_OPLINE();
58717 ZEND_VM_LEAVE();
58718 } else {
58719 if (EXPECTED((call_info & ZEND_CALL_CODE) == 0)) {
58720 EG(current_execute_data) = EX(prev_execute_data);
58721 i_free_compiled_variables(execute_data);
58722 #ifdef ZEND_PREFER_RELOAD
58723 call_info = EX_CALL_INFO();
58724 #endif
58725 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) {
58726 if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58727 zend_clean_and_cache_symbol_table(EX(symbol_table));
58728 }
58729 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
58730 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
58731 zend_free_extra_named_params(EX(extra_named_params));
58732 }
58733 }
58734 if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
58735 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
58736 }
58737 ZEND_VM_RETURN();
58738 } else /* if (call_kind == ZEND_CALL_TOP_CODE) */ {
58739 zend_array *symbol_table = EX(symbol_table);
58740
58741 if (EX(func)->op_array.last_var > 0) {
58742 zend_detach_symbol_table(execute_data);
58743 call_info |= ZEND_CALL_NEEDS_REATTACH;
58744 }
58745 if (call_info & ZEND_CALL_NEEDS_REATTACH) {
58746 old_execute_data = EX(prev_execute_data);
58747 while (old_execute_data) {
58748 if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) {
58749 if (old_execute_data->symbol_table == symbol_table) {
58750 if (old_execute_data->func->op_array.last_var > 0) {
58751 zend_attach_symbol_table(old_execute_data);
58752 } else {
58753 ZEND_ADD_CALL_FLAG(old_execute_data, ZEND_CALL_NEEDS_REATTACH);
58754 }
58755 }
58756 break;
58757 }
58758 old_execute_data = old_execute_data->prev_execute_data;
58759 }
58760 }
58761 EG(current_execute_data) = EX(prev_execute_data);
58762 ZEND_VM_RETURN();
58763 }
58764 }
58765 }
58766
58767 HYBRID_CASE(ZEND_JMP_SPEC):
58768 VM_TRACE(ZEND_JMP_SPEC)
58769 ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58770 VM_TRACE_OP_END(ZEND_JMP_SPEC)
58771 HYBRID_BREAK();
58772 HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED):
58773 VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
58774 ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58775 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
58776 HYBRID_BREAK();
58777 HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_USED):
58778 VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_USED)
58779 ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58780 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_USED)
58781 HYBRID_BREAK();
58782 HYBRID_CASE(ZEND_DO_ICALL_SPEC_OBSERVER):
58783 VM_TRACE(ZEND_DO_ICALL_SPEC_OBSERVER)
58784 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58785 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_OBSERVER)
58786 HYBRID_BREAK();
58787 HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED):
58788 VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
58789 ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58790 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
58791 HYBRID_BREAK();
58792 HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_USED):
58793 VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_USED)
58794 ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58795 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_USED)
58796 HYBRID_BREAK();
58797 HYBRID_CASE(ZEND_DO_UCALL_SPEC_OBSERVER):
58798 VM_TRACE(ZEND_DO_UCALL_SPEC_OBSERVER)
58799 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58800 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_OBSERVER)
58801 HYBRID_BREAK();
58802 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED):
58803 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
58804 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58805 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
58806 HYBRID_BREAK();
58807 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED):
58808 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
58809 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58810 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
58811 HYBRID_BREAK();
58812 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER):
58813 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
58814 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58815 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
58816 HYBRID_BREAK();
58817 HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED):
58818 VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
58819 ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58820 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
58821 HYBRID_BREAK();
58822 HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_USED):
58823 VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_USED)
58824 ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58825 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_USED)
58826 HYBRID_BREAK();
58827 HYBRID_CASE(ZEND_DO_FCALL_SPEC_OBSERVER):
58828 VM_TRACE(ZEND_DO_FCALL_SPEC_OBSERVER)
58829 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58830 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_OBSERVER)
58831 HYBRID_BREAK();
58832 HYBRID_CASE(ZEND_GENERATOR_CREATE_SPEC):
58833 VM_TRACE(ZEND_GENERATOR_CREATE_SPEC)
58834 ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58835 VM_TRACE_OP_END(ZEND_GENERATOR_CREATE_SPEC)
58836 HYBRID_BREAK();
58837 HYBRID_CASE(ZEND_SEND_UNPACK_SPEC):
58838 VM_TRACE(ZEND_SEND_UNPACK_SPEC)
58839 ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58840 VM_TRACE_OP_END(ZEND_SEND_UNPACK_SPEC)
58841 HYBRID_BREAK();
58842 HYBRID_CASE(ZEND_SEND_ARRAY_SPEC):
58843 VM_TRACE(ZEND_SEND_ARRAY_SPEC)
58844 ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58845 VM_TRACE_OP_END(ZEND_SEND_ARRAY_SPEC)
58846 HYBRID_BREAK();
58847 HYBRID_CASE(ZEND_RECV_NOTYPE_SPEC):
58848 VM_TRACE(ZEND_RECV_NOTYPE_SPEC)
58849 ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58850 VM_TRACE_OP_END(ZEND_RECV_NOTYPE_SPEC)
58851 HYBRID_BREAK();
58852 HYBRID_CASE(ZEND_ADD_ARRAY_UNPACK_SPEC):
58853 VM_TRACE(ZEND_ADD_ARRAY_UNPACK_SPEC)
58854 ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58855 VM_TRACE_OP_END(ZEND_ADD_ARRAY_UNPACK_SPEC)
58856 HYBRID_BREAK();
58857 HYBRID_CASE(ZEND_UNSET_STATIC_PROP_SPEC):
58858 VM_TRACE(ZEND_UNSET_STATIC_PROP_SPEC)
58859 ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58860 VM_TRACE_OP_END(ZEND_UNSET_STATIC_PROP_SPEC)
58861 HYBRID_BREAK();
58862 HYBRID_CASE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC):
58863 VM_TRACE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
58864 ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58865 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
58866 HYBRID_BREAK();
58867 HYBRID_CASE(ZEND_BEGIN_SILENCE_SPEC):
58868 VM_TRACE(ZEND_BEGIN_SILENCE_SPEC)
58869 ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58870 VM_TRACE_OP_END(ZEND_BEGIN_SILENCE_SPEC)
58871 HYBRID_BREAK();
58872 HYBRID_CASE(ZEND_EXT_STMT_SPEC):
58873 VM_TRACE(ZEND_EXT_STMT_SPEC)
58874 ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58875 VM_TRACE_OP_END(ZEND_EXT_STMT_SPEC)
58876 HYBRID_BREAK();
58877 HYBRID_CASE(ZEND_EXT_FCALL_BEGIN_SPEC):
58878 VM_TRACE(ZEND_EXT_FCALL_BEGIN_SPEC)
58879 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58880 VM_TRACE_OP_END(ZEND_EXT_FCALL_BEGIN_SPEC)
58881 HYBRID_BREAK();
58882 HYBRID_CASE(ZEND_EXT_FCALL_END_SPEC):
58883 VM_TRACE(ZEND_EXT_FCALL_END_SPEC)
58884 ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58885 VM_TRACE_OP_END(ZEND_EXT_FCALL_END_SPEC)
58886 HYBRID_BREAK();
58887 HYBRID_CASE(ZEND_DECLARE_ANON_CLASS_SPEC):
58888 VM_TRACE(ZEND_DECLARE_ANON_CLASS_SPEC)
58889 ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58890 VM_TRACE_OP_END(ZEND_DECLARE_ANON_CLASS_SPEC)
58891 HYBRID_BREAK();
58892 HYBRID_CASE(ZEND_DECLARE_FUNCTION_SPEC):
58893 VM_TRACE(ZEND_DECLARE_FUNCTION_SPEC)
58894 ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58895 VM_TRACE_OP_END(ZEND_DECLARE_FUNCTION_SPEC)
58896 HYBRID_BREAK();
58897 HYBRID_CASE(ZEND_TICKS_SPEC):
58898 VM_TRACE(ZEND_TICKS_SPEC)
58899 ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58900 VM_TRACE_OP_END(ZEND_TICKS_SPEC)
58901 HYBRID_BREAK();
58902 HYBRID_CASE(ZEND_EXT_NOP_SPEC):
58903 VM_TRACE(ZEND_EXT_NOP_SPEC)
58904 ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58905 VM_TRACE_OP_END(ZEND_EXT_NOP_SPEC)
58906 HYBRID_BREAK();
58907 HYBRID_CASE(ZEND_NOP_SPEC):
58908 VM_TRACE(ZEND_NOP_SPEC)
58909 ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58910 VM_TRACE_OP_END(ZEND_NOP_SPEC)
58911 HYBRID_BREAK();
58912 HYBRID_CASE(ZEND_HANDLE_EXCEPTION_SPEC):
58913 VM_TRACE(ZEND_HANDLE_EXCEPTION_SPEC)
58914 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58915 VM_TRACE_OP_END(ZEND_HANDLE_EXCEPTION_SPEC)
58916 HYBRID_BREAK();
58917 HYBRID_CASE(ZEND_USER_OPCODE_SPEC):
58918 VM_TRACE(ZEND_USER_OPCODE_SPEC)
58919 ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58920 VM_TRACE_OP_END(ZEND_USER_OPCODE_SPEC)
58921 HYBRID_BREAK();
58922 HYBRID_CASE(ZEND_DISCARD_EXCEPTION_SPEC):
58923 VM_TRACE(ZEND_DISCARD_EXCEPTION_SPEC)
58924 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58925 VM_TRACE_OP_END(ZEND_DISCARD_EXCEPTION_SPEC)
58926 HYBRID_BREAK();
58927 HYBRID_CASE(ZEND_FAST_CALL_SPEC):
58928 VM_TRACE(ZEND_FAST_CALL_SPEC)
58929 ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58930 VM_TRACE_OP_END(ZEND_FAST_CALL_SPEC)
58931 HYBRID_BREAK();
58932 HYBRID_CASE(ZEND_FAST_RET_SPEC):
58933 VM_TRACE(ZEND_FAST_RET_SPEC)
58934 ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58935 VM_TRACE_OP_END(ZEND_FAST_RET_SPEC)
58936 HYBRID_BREAK();
58937 HYBRID_CASE(ZEND_ASSERT_CHECK_SPEC):
58938 VM_TRACE(ZEND_ASSERT_CHECK_SPEC)
58939 ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58940 VM_TRACE_OP_END(ZEND_ASSERT_CHECK_SPEC)
58941 HYBRID_BREAK();
58942 HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC):
58943 VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC)
58944 ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58945 VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC)
58946 HYBRID_BREAK();
58947 HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER):
58948 VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
58949 ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58950 VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
58951 HYBRID_BREAK();
58952 HYBRID_CASE(ZEND_FRAMELESS_ICALL_2_SPEC):
58953 VM_TRACE(ZEND_FRAMELESS_ICALL_2_SPEC)
58954 ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58955 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_2_SPEC)
58956 HYBRID_BREAK();
58957 HYBRID_CASE(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER):
58958 VM_TRACE(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER)
58959 ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58960 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER)
58961 HYBRID_BREAK();
58962 HYBRID_CASE(ZEND_FRAMELESS_ICALL_3_SPEC):
58963 VM_TRACE(ZEND_FRAMELESS_ICALL_3_SPEC)
58964 ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58965 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_3_SPEC)
58966 HYBRID_BREAK();
58967 HYBRID_CASE(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER):
58968 VM_TRACE(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER)
58969 ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58970 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER)
58971 HYBRID_BREAK();
58972 HYBRID_CASE(ZEND_JMP_FORWARD_SPEC):
58973 VM_TRACE(ZEND_JMP_FORWARD_SPEC)
58974 ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58975 VM_TRACE_OP_END(ZEND_JMP_FORWARD_SPEC)
58976 HYBRID_BREAK();
58977 HYBRID_CASE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST):
58978 VM_TRACE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
58979 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58980 VM_TRACE_OP_END(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
58981 HYBRID_BREAK();
58982 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST):
58983 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
58984 ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58985 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
58986 HYBRID_BREAK();
58987 HYBRID_CASE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST):
58988 VM_TRACE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
58989 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58990 VM_TRACE_OP_END(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
58991 HYBRID_BREAK();
58992 HYBRID_CASE(ZEND_INIT_FCALL_SPEC_CONST):
58993 VM_TRACE(ZEND_INIT_FCALL_SPEC_CONST)
58994 ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58995 VM_TRACE_OP_END(ZEND_INIT_FCALL_SPEC_CONST)
58996 HYBRID_BREAK();
58997 HYBRID_CASE(ZEND_INIT_FCALL_OFFSET_SPEC_CONST):
58998 VM_TRACE(ZEND_INIT_FCALL_OFFSET_SPEC_CONST)
58999 ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59000 VM_TRACE_OP_END(ZEND_INIT_FCALL_OFFSET_SPEC_CONST)
59001 HYBRID_BREAK();
59002 HYBRID_CASE(ZEND_RECV_INIT_SPEC_CONST):
59003 VM_TRACE(ZEND_RECV_INIT_SPEC_CONST)
59004 ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59005 VM_TRACE_OP_END(ZEND_RECV_INIT_SPEC_CONST)
59006 HYBRID_BREAK();
59007 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR):
59008 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
59009 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59010 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
59011 HYBRID_BREAK();
59012 HYBRID_CASE(ZEND_RECV_SPEC_UNUSED):
59013 VM_TRACE(ZEND_RECV_SPEC_UNUSED)
59014 ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59015 VM_TRACE_OP_END(ZEND_RECV_SPEC_UNUSED)
59016 HYBRID_BREAK();
59017 HYBRID_CASE(ZEND_RECV_VARIADIC_SPEC_UNUSED):
59018 VM_TRACE(ZEND_RECV_VARIADIC_SPEC_UNUSED)
59019 ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59020 VM_TRACE_OP_END(ZEND_RECV_VARIADIC_SPEC_UNUSED)
59021 HYBRID_BREAK();
59022 HYBRID_CASE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED):
59023 VM_TRACE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
59024 ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59025 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
59026 HYBRID_BREAK();
59027 HYBRID_CASE(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER):
59028 VM_TRACE(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER)
59029 ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59030 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER)
59031 HYBRID_BREAK();
59032 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV):
59033 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
59034 ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59035 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
59036 HYBRID_BREAK();
59037 HYBRID_CASE(ZEND_BW_NOT_SPEC_CONST):
59038 VM_TRACE(ZEND_BW_NOT_SPEC_CONST)
59039 ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59040 VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_CONST)
59041 HYBRID_BREAK();
59042 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CONST):
59043 VM_TRACE(ZEND_BOOL_NOT_SPEC_CONST)
59044 ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59045 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CONST)
59046 HYBRID_BREAK();
59047 HYBRID_CASE(ZEND_ECHO_SPEC_CONST):
59048 VM_TRACE(ZEND_ECHO_SPEC_CONST)
59049 ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59050 VM_TRACE_OP_END(ZEND_ECHO_SPEC_CONST)
59051 HYBRID_BREAK();
59052 HYBRID_CASE(ZEND_JMPZ_SPEC_CONST):
59053 VM_TRACE(ZEND_JMPZ_SPEC_CONST)
59054 ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59055 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CONST)
59056 HYBRID_BREAK();
59057 HYBRID_CASE(ZEND_JMPNZ_SPEC_CONST):
59058 VM_TRACE(ZEND_JMPNZ_SPEC_CONST)
59059 ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59060 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CONST)
59061 HYBRID_BREAK();
59062 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CONST):
59063 VM_TRACE(ZEND_JMPZ_EX_SPEC_CONST)
59064 ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59065 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CONST)
59066 HYBRID_BREAK();
59067 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CONST):
59068 VM_TRACE(ZEND_JMPNZ_EX_SPEC_CONST)
59069 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59070 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CONST)
59071 HYBRID_BREAK();
59072 HYBRID_CASE(ZEND_RETURN_SPEC_CONST):
59073 VM_TRACE(ZEND_RETURN_SPEC_CONST)
59074 {
59075 USE_OPLINE
59076 zval *retval_ptr;
59077 zval *return_value;
59078
59079 retval_ptr = RT_CONSTANT(opline, opline->op1);
59080 return_value = EX(return_value);
59081
59082 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
59083 SAVE_OPLINE();
59084 retval_ptr = ZVAL_UNDEFINED_OP1();
59085 if (return_value) {
59086 ZVAL_NULL(return_value);
59087 }
59088 } else if (!return_value) {
59089 if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
59090 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
59091 SAVE_OPLINE();
59092 rc_dtor_func(Z_COUNTED_P(retval_ptr));
59093 }
59094 }
59095 } else {
59096 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
59097 ZVAL_COPY_VALUE(return_value, retval_ptr);
59098 if (IS_CONST == IS_CONST) {
59099 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
59100 Z_ADDREF_P(return_value);
59101 }
59102 }
59103 } else if (IS_CONST == IS_CV) {
59104 do {
59105 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59106 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
59107 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
59108 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59109 ZVAL_COPY_VALUE(return_value, retval_ptr);
59110 if (GC_MAY_LEAK(ref)) {
59111 SAVE_OPLINE();
59112 gc_possible_root(ref);
59113 }
59114 ZVAL_NULL(retval_ptr);
59115 break;
59116 } else {
59117 Z_ADDREF_P(retval_ptr);
59118 }
59119 } else {
59120 retval_ptr = Z_REFVAL_P(retval_ptr);
59121 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59122 Z_ADDREF_P(retval_ptr);
59123 }
59124 }
59125 }
59126 ZVAL_COPY_VALUE(return_value, retval_ptr);
59127 } while (0);
59128 } else /* if (IS_CONST == IS_VAR) */ {
59129 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
59130 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59131
59132 retval_ptr = Z_REFVAL_P(retval_ptr);
59133 ZVAL_COPY_VALUE(return_value, retval_ptr);
59134 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
59135 efree_size(ref, sizeof(zend_reference));
59136 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59137 Z_ADDREF_P(retval_ptr);
59138 }
59139 } else {
59140 ZVAL_COPY_VALUE(return_value, retval_ptr);
59141 }
59142 }
59143 }
59144
59145
59146
59147 goto zend_leave_helper_SPEC_LABEL;
59148 }
59149
59150 VM_TRACE_OP_END(ZEND_RETURN_SPEC_CONST)
59151 HYBRID_CASE(ZEND_RETURN_SPEC_OBSERVER):
59152 VM_TRACE(ZEND_RETURN_SPEC_OBSERVER)
59153 {
59154 USE_OPLINE
59155 zval *retval_ptr;
59156 zval *return_value;
59157 zval observer_retval;
59158
59159 retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
59160 return_value = EX(return_value);
59161 if (!return_value) { return_value = &observer_retval; };
59162 if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
59163 SAVE_OPLINE();
59164 retval_ptr = ZVAL_UNDEFINED_OP1();
59165 if (return_value) {
59166 ZVAL_NULL(return_value);
59167 }
59168 } else if (!return_value) {
59169 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
59170 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
59171 SAVE_OPLINE();
59172 rc_dtor_func(Z_COUNTED_P(retval_ptr));
59173 }
59174 }
59175 } else {
59176 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
59177 ZVAL_COPY_VALUE(return_value, retval_ptr);
59178 if (opline->op1_type == IS_CONST) {
59179 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
59180 Z_ADDREF_P(return_value);
59181 }
59182 }
59183 } else if (opline->op1_type == IS_CV) {
59184 do {
59185 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59186 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
59187 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
59188 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59189 ZVAL_COPY_VALUE(return_value, retval_ptr);
59190 if (GC_MAY_LEAK(ref)) {
59191 SAVE_OPLINE();
59192 gc_possible_root(ref);
59193 }
59194 ZVAL_NULL(retval_ptr);
59195 break;
59196 } else {
59197 Z_ADDREF_P(retval_ptr);
59198 }
59199 } else {
59200 retval_ptr = Z_REFVAL_P(retval_ptr);
59201 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59202 Z_ADDREF_P(retval_ptr);
59203 }
59204 }
59205 }
59206 ZVAL_COPY_VALUE(return_value, retval_ptr);
59207 } while (0);
59208 } else /* if (opline->op1_type == IS_VAR) */ {
59209 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
59210 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59211
59212 retval_ptr = Z_REFVAL_P(retval_ptr);
59213 ZVAL_COPY_VALUE(return_value, retval_ptr);
59214 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
59215 efree_size(ref, sizeof(zend_reference));
59216 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59217 Z_ADDREF_P(retval_ptr);
59218 }
59219 } else {
59220 ZVAL_COPY_VALUE(return_value, retval_ptr);
59221 }
59222 }
59223 }
59224 SAVE_OPLINE();
59225 zend_observer_fcall_end(execute_data, return_value);
59226 if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
59227 goto zend_leave_helper_SPEC_LABEL;
59228 }
59229
59230 VM_TRACE_OP_END(ZEND_RETURN_SPEC_OBSERVER)
59231 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CONST):
59232 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CONST)
59233 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59234 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CONST)
59235 HYBRID_BREAK();
59236 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_OBSERVER):
59237 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
59238 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59239 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
59240 HYBRID_BREAK();
59241 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CONST):
59242 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CONST)
59243 ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59244 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CONST)
59245 HYBRID_BREAK();
59246 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER):
59247 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
59248 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59249 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
59250 HYBRID_BREAK();
59251 HYBRID_CASE(ZEND_THROW_SPEC_CONST):
59252 VM_TRACE(ZEND_THROW_SPEC_CONST)
59253 ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59254 VM_TRACE_OP_END(ZEND_THROW_SPEC_CONST)
59255 HYBRID_BREAK();
59256 HYBRID_CASE(ZEND_CATCH_SPEC_CONST):
59257 VM_TRACE(ZEND_CATCH_SPEC_CONST)
59258 ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59259 VM_TRACE_OP_END(ZEND_CATCH_SPEC_CONST)
59260 HYBRID_BREAK();
59261 HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST):
59262 VM_TRACE(ZEND_SEND_USER_SPEC_CONST)
59263 ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59264 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST)
59265 HYBRID_BREAK();
59266 HYBRID_CASE(ZEND_BOOL_SPEC_CONST):
59267 VM_TRACE(ZEND_BOOL_SPEC_CONST)
59268 ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59269 VM_TRACE_OP_END(ZEND_BOOL_SPEC_CONST)
59270 HYBRID_BREAK();
59271 HYBRID_CASE(ZEND_CLONE_SPEC_CONST):
59272 VM_TRACE(ZEND_CLONE_SPEC_CONST)
59273 ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59274 VM_TRACE_OP_END(ZEND_CLONE_SPEC_CONST)
59275 HYBRID_BREAK();
59276 HYBRID_CASE(ZEND_CAST_SPEC_CONST):
59277 VM_TRACE(ZEND_CAST_SPEC_CONST)
59278 ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59279 VM_TRACE_OP_END(ZEND_CAST_SPEC_CONST)
59280 HYBRID_BREAK();
59281 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST):
59282 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
59283 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59284 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
59285 HYBRID_BREAK();
59286 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER):
59287 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
59288 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59289 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
59290 HYBRID_BREAK();
59291 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CONST):
59292 VM_TRACE(ZEND_FE_RESET_R_SPEC_CONST)
59293 ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59294 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CONST)
59295 HYBRID_BREAK();
59296 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CONST):
59297 VM_TRACE(ZEND_FE_RESET_RW_SPEC_CONST)
59298 ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59299 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CONST)
59300 HYBRID_BREAK();
59301 HYBRID_CASE(ZEND_JMP_SET_SPEC_CONST):
59302 VM_TRACE(ZEND_JMP_SET_SPEC_CONST)
59303 ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59304 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CONST)
59305 HYBRID_BREAK();
59306 HYBRID_CASE(ZEND_COALESCE_SPEC_CONST):
59307 VM_TRACE(ZEND_COALESCE_SPEC_CONST)
59308 ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59309 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CONST)
59310 HYBRID_BREAK();
59311 HYBRID_CASE(ZEND_JMP_NULL_SPEC_CONST):
59312 VM_TRACE(ZEND_JMP_NULL_SPEC_CONST)
59313 ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59314 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CONST)
59315 HYBRID_BREAK();
59316 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CONST):
59317 VM_TRACE(ZEND_QM_ASSIGN_SPEC_CONST)
59318 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59319 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CONST)
59320 HYBRID_BREAK();
59321 HYBRID_CASE(ZEND_DECLARE_CLASS_SPEC_CONST):
59322 VM_TRACE(ZEND_DECLARE_CLASS_SPEC_CONST)
59323 ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59324 VM_TRACE_OP_END(ZEND_DECLARE_CLASS_SPEC_CONST)
59325 HYBRID_BREAK();
59326 HYBRID_CASE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST):
59327 VM_TRACE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
59328 ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59329 VM_TRACE_OP_END(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
59330 HYBRID_BREAK();
59331 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CONST):
59332 VM_TRACE(ZEND_YIELD_FROM_SPEC_CONST)
59333 ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59334 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CONST)
59335 HYBRID_BREAK();
59336 HYBRID_CASE(ZEND_STRLEN_SPEC_CONST):
59337 VM_TRACE(ZEND_STRLEN_SPEC_CONST)
59338 ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59339 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CONST)
59340 HYBRID_BREAK();
59341 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CONST):
59342 VM_TRACE(ZEND_TYPE_CHECK_SPEC_CONST)
59343 ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59344 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CONST)
59345 HYBRID_BREAK();
59346 HYBRID_CASE(ZEND_DEFINED_SPEC_CONST):
59347 VM_TRACE(ZEND_DEFINED_SPEC_CONST)
59348 ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59349 VM_TRACE_OP_END(ZEND_DEFINED_SPEC_CONST)
59350 HYBRID_BREAK();
59351 HYBRID_CASE(ZEND_JMP_FRAMELESS_SPEC_CONST):
59352 VM_TRACE(ZEND_JMP_FRAMELESS_SPEC_CONST)
59353 ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59354 VM_TRACE_OP_END(ZEND_JMP_FRAMELESS_SPEC_CONST)
59355 HYBRID_BREAK();
59356 HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_CONST):
59357 VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
59358 ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59359 VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
59360 HYBRID_BREAK();
59361 HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST):
59362 VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
59363 ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59364 VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
59365 HYBRID_BREAK();
59366 HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST):
59367 VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
59368 ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59369 VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
59370 HYBRID_BREAK();
59371 HYBRID_CASE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST):
59372 VM_TRACE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
59373 ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59374 VM_TRACE_OP_END(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
59375 HYBRID_BREAK();
59376 HYBRID_CASE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST):
59377 VM_TRACE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
59378 ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59379 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
59380 HYBRID_BREAK();
59381 HYBRID_CASE(ZEND_ADD_SPEC_CONST_CONST):
59382 VM_TRACE(ZEND_ADD_SPEC_CONST_CONST)
59383 ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59384 VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_CONST)
59385 HYBRID_BREAK();
59386 HYBRID_CASE(ZEND_SUB_SPEC_CONST_CONST):
59387 VM_TRACE(ZEND_SUB_SPEC_CONST_CONST)
59388 ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59389 VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_CONST)
59390 HYBRID_BREAK();
59391 HYBRID_CASE(ZEND_MUL_SPEC_CONST_CONST):
59392 VM_TRACE(ZEND_MUL_SPEC_CONST_CONST)
59393 ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59394 VM_TRACE_OP_END(ZEND_MUL_SPEC_CONST_CONST)
59395 HYBRID_BREAK();
59396 HYBRID_CASE(ZEND_DIV_SPEC_CONST_CONST):
59397 VM_TRACE(ZEND_DIV_SPEC_CONST_CONST)
59398 ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59399 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CONST)
59400 HYBRID_BREAK();
59401 HYBRID_CASE(ZEND_MOD_SPEC_CONST_CONST):
59402 VM_TRACE(ZEND_MOD_SPEC_CONST_CONST)
59403 ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59404 VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_CONST)
59405 HYBRID_BREAK();
59406 HYBRID_CASE(ZEND_SL_SPEC_CONST_CONST):
59407 VM_TRACE(ZEND_SL_SPEC_CONST_CONST)
59408 ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59409 VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_CONST)
59410 HYBRID_BREAK();
59411 HYBRID_CASE(ZEND_SR_SPEC_CONST_CONST):
59412 VM_TRACE(ZEND_SR_SPEC_CONST_CONST)
59413 ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59414 VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_CONST)
59415 HYBRID_BREAK();
59416 HYBRID_CASE(ZEND_POW_SPEC_CONST_CONST):
59417 VM_TRACE(ZEND_POW_SPEC_CONST_CONST)
59418 ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59419 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CONST)
59420 HYBRID_BREAK();
59421 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST):
59422 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
59423 ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59424 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
59425 HYBRID_BREAK();
59426 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST):
59427 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
59428 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59429 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
59430 HYBRID_BREAK();
59431 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CONST_CONST):
59432 VM_TRACE(ZEND_IS_EQUAL_SPEC_CONST_CONST)
59433 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59434 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CONST_CONST)
59435 HYBRID_BREAK();
59436 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST):
59437 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
59438 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59439 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
59440 HYBRID_BREAK();
59441 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_CONST):
59442 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_CONST)
59443 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59444 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_CONST)
59445 HYBRID_BREAK();
59446 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST):
59447 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
59448 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59449 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
59450 HYBRID_BREAK();
59451 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CONST):
59452 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CONST)
59453 ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59454 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CONST)
59455 HYBRID_BREAK();
59456 HYBRID_CASE(ZEND_BW_OR_SPEC_CONST_CONST):
59457 VM_TRACE(ZEND_BW_OR_SPEC_CONST_CONST)
59458 ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59459 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_CONST_CONST)
59460 HYBRID_BREAK();
59461 HYBRID_CASE(ZEND_BW_AND_SPEC_CONST_CONST):
59462 VM_TRACE(ZEND_BW_AND_SPEC_CONST_CONST)
59463 ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59464 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_CONST_CONST)
59465 HYBRID_BREAK();
59466 HYBRID_CASE(ZEND_BW_XOR_SPEC_CONST_CONST):
59467 VM_TRACE(ZEND_BW_XOR_SPEC_CONST_CONST)
59468 ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59469 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_CONST_CONST)
59470 HYBRID_BREAK();
59471 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CONST_CONST):
59472 VM_TRACE(ZEND_BOOL_XOR_SPEC_CONST_CONST)
59473 ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59474 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CONST_CONST)
59475 HYBRID_BREAK();
59476 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST):
59477 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
59478 ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59479 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
59480 HYBRID_BREAK();
59481 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST):
59482 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
59483 ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59484 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
59485 HYBRID_BREAK();
59486 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST):
59487 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
59488 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59489 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
59490 HYBRID_BREAK();
59491 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST):
59492 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
59493 ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59494 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
59495 HYBRID_BREAK();
59496 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST):
59497 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
59498 ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59499 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
59500 HYBRID_BREAK();
59501 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST):
59502 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
59503 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59504 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
59505 HYBRID_BREAK();
59506 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST):
59507 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
59508 ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59509 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
59510 HYBRID_BREAK();
59511 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CONST):
59512 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
59513 ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59514 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
59515 HYBRID_BREAK();
59516 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST):
59517 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
59518 ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59519 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
59520 HYBRID_BREAK();
59521 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST):
59522 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
59523 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59524 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
59525 HYBRID_BREAK();
59526 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST):
59527 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
59528 ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59529 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
59530 HYBRID_BREAK();
59531 HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_CONST):
59532 VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_CONST)
59533 ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59534 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_CONST)
59535 HYBRID_BREAK();
59536 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST):
59537 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
59538 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59539 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
59540 HYBRID_BREAK();
59541 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST):
59542 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
59543 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59544 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
59545 HYBRID_BREAK();
59546 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST):
59547 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
59548 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59549 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
59550 HYBRID_BREAK();
59551 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CONST):
59552 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
59553 ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59554 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
59555 HYBRID_BREAK();
59556 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST):
59557 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
59558 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59559 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
59560 HYBRID_BREAK();
59561 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST):
59562 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
59563 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59564 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
59565 HYBRID_BREAK();
59566 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST):
59567 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
59568 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59569 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
59570 HYBRID_BREAK();
59571 HYBRID_CASE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST):
59572 VM_TRACE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
59573 ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59574 VM_TRACE_OP_END(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
59575 HYBRID_BREAK();
59576 HYBRID_CASE(ZEND_DECLARE_CONST_SPEC_CONST_CONST):
59577 VM_TRACE(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
59578 ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59579 VM_TRACE_OP_END(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
59580 HYBRID_BREAK();
59581 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CONST):
59582 VM_TRACE(ZEND_YIELD_SPEC_CONST_CONST)
59583 ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59584 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CONST)
59585 HYBRID_BREAK();
59586 HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_CONST_CONST):
59587 VM_TRACE(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
59588 ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59589 VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
59590 HYBRID_BREAK();
59591 HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_CONST_CONST):
59592 VM_TRACE(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
59593 ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59594 VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
59595 HYBRID_BREAK();
59596 HYBRID_CASE(ZEND_MATCH_SPEC_CONST_CONST):
59597 VM_TRACE(ZEND_MATCH_SPEC_CONST_CONST)
59598 ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59599 VM_TRACE_OP_END(ZEND_MATCH_SPEC_CONST_CONST)
59600 HYBRID_BREAK();
59601 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CONST_CONST):
59602 VM_TRACE(ZEND_IN_ARRAY_SPEC_CONST_CONST)
59603 ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59604 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CONST_CONST)
59605 HYBRID_BREAK();
59606 HYBRID_CASE(ZEND_ADD_SPEC_CONST_TMPVARCV):
59607 VM_TRACE(ZEND_ADD_SPEC_CONST_TMPVARCV)
59608 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59609 VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_TMPVARCV)
59610 HYBRID_BREAK();
59611 HYBRID_CASE(ZEND_SUB_SPEC_CONST_TMPVARCV):
59612 VM_TRACE(ZEND_SUB_SPEC_CONST_TMPVARCV)
59613 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59614 VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_TMPVARCV)
59615 HYBRID_BREAK();
59616 HYBRID_CASE(ZEND_MOD_SPEC_CONST_TMPVARCV):
59617 VM_TRACE(ZEND_MOD_SPEC_CONST_TMPVARCV)
59618 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59619 VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_TMPVARCV)
59620 HYBRID_BREAK();
59621 HYBRID_CASE(ZEND_SL_SPEC_CONST_TMPVARCV):
59622 VM_TRACE(ZEND_SL_SPEC_CONST_TMPVARCV)
59623 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59624 VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_TMPVARCV)
59625 HYBRID_BREAK();
59626 HYBRID_CASE(ZEND_SR_SPEC_CONST_TMPVARCV):
59627 VM_TRACE(ZEND_SR_SPEC_CONST_TMPVARCV)
59628 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59629 VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_TMPVARCV)
59630 HYBRID_BREAK();
59631 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV):
59632 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
59633 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59634 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
59635 HYBRID_BREAK();
59636 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ):
59637 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
59638 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59639 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
59640 HYBRID_BREAK();
59641 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ):
59642 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
59643 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59644 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
59645 HYBRID_BREAK();
59646 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV):
59647 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
59648 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59649 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
59650 HYBRID_BREAK();
59651 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ):
59652 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
59653 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59654 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
59655 HYBRID_BREAK();
59656 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ):
59657 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
59658 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59659 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
59660 HYBRID_BREAK();
59661 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV):
59662 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
59663 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59664 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
59665 HYBRID_BREAK();
59666 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV):
59667 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
59668 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59669 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
59670 HYBRID_BREAK();
59671 HYBRID_CASE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV):
59672 VM_TRACE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
59673 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59674 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
59675 HYBRID_BREAK();
59676 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV):
59677 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
59678 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59679 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
59680 HYBRID_BREAK();
59681 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV):
59682 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
59683 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59684 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
59685 HYBRID_BREAK();
59686 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ):
59687 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59688 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59689 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59690 HYBRID_BREAK();
59691 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
59692 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59693 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59694 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59695 HYBRID_BREAK();
59696 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV):
59697 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
59698 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59699 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
59700 HYBRID_BREAK();
59701 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
59702 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59703 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59704 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59705 HYBRID_BREAK();
59706 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
59707 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59708 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59709 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59710 HYBRID_BREAK();
59711 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV):
59712 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
59713 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59714 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
59715 HYBRID_BREAK();
59716 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ):
59717 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59718 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59719 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
59720 HYBRID_BREAK();
59721 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
59722 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59723 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59724 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
59725 HYBRID_BREAK();
59726 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV):
59727 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
59728 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59729 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
59730 HYBRID_BREAK();
59731 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
59732 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59733 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59734 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
59735 HYBRID_BREAK();
59736 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
59737 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59738 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59739 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
59740 HYBRID_BREAK();
59741 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV):
59742 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
59743 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59744 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
59745 HYBRID_BREAK();
59746 HYBRID_CASE(ZEND_DIV_SPEC_CONST_TMPVAR):
59747 VM_TRACE(ZEND_DIV_SPEC_CONST_TMPVAR)
59748 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59749 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_TMPVAR)
59750 HYBRID_BREAK();
59751 HYBRID_CASE(ZEND_POW_SPEC_CONST_TMPVAR):
59752 VM_TRACE(ZEND_POW_SPEC_CONST_TMPVAR)
59753 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59754 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_TMPVAR)
59755 HYBRID_BREAK();
59756 HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_TMPVAR):
59757 VM_TRACE(ZEND_CONCAT_SPEC_CONST_TMPVAR)
59758 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59759 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_TMPVAR)
59760 HYBRID_BREAK();
59761 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR):
59762 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
59763 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59764 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
59765 HYBRID_BREAK();
59766 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR):
59767 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
59768 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59769 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
59770 HYBRID_BREAK();
59771 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR):
59772 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
59773 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59774 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
59775 HYBRID_BREAK();
59776 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR):
59777 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
59778 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59779 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
59780 HYBRID_BREAK();
59781 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR):
59782 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
59783 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59784 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
59785 HYBRID_BREAK();
59786 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR):
59787 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
59788 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59789 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
59790 HYBRID_BREAK();
59791 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR):
59792 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
59793 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59794 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
59795 HYBRID_BREAK();
59796 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR):
59797 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
59798 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59799 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
59800 HYBRID_BREAK();
59801 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR):
59802 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
59803 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59804 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
59805 HYBRID_BREAK();
59806 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR):
59807 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
59808 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59809 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
59810 HYBRID_BREAK();
59811 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR):
59812 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
59813 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59814 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
59815 HYBRID_BREAK();
59816 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR):
59817 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
59818 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59819 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
59820 HYBRID_BREAK();
59821 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR):
59822 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
59823 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59824 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
59825 HYBRID_BREAK();
59826 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR):
59827 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
59828 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59829 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
59830 HYBRID_BREAK();
59831 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR):
59832 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
59833 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59834 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
59835 HYBRID_BREAK();
59836 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR):
59837 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
59838 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59839 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
59840 HYBRID_BREAK();
59841 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR):
59842 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
59843 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59844 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
59845 HYBRID_BREAK();
59846 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_TMPVAR):
59847 VM_TRACE(ZEND_YIELD_SPEC_CONST_TMPVAR)
59848 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59849 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_TMPVAR)
59850 HYBRID_BREAK();
59851 HYBRID_CASE(ZEND_FETCH_R_SPEC_CONST_UNUSED):
59852 VM_TRACE(ZEND_FETCH_R_SPEC_CONST_UNUSED)
59853 ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59854 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CONST_UNUSED)
59855 HYBRID_BREAK();
59856 HYBRID_CASE(ZEND_FETCH_W_SPEC_CONST_UNUSED):
59857 VM_TRACE(ZEND_FETCH_W_SPEC_CONST_UNUSED)
59858 ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59859 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CONST_UNUSED)
59860 HYBRID_BREAK();
59861 HYBRID_CASE(ZEND_FETCH_RW_SPEC_CONST_UNUSED):
59862 VM_TRACE(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
59863 ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59864 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
59865 HYBRID_BREAK();
59866 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED):
59867 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
59868 ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59869 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
59870 HYBRID_BREAK();
59871 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED):
59872 VM_TRACE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
59873 ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59874 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
59875 HYBRID_BREAK();
59876 HYBRID_CASE(ZEND_FETCH_IS_SPEC_CONST_UNUSED):
59877 VM_TRACE(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
59878 ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59879 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
59880 HYBRID_BREAK();
59881 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED):
59882 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
59883 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59884 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
59885 HYBRID_BREAK();
59886 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED):
59887 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
59888 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59889 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
59890 HYBRID_BREAK();
59891 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED):
59892 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
59893 ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59894 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
59895 HYBRID_BREAK();
59896 HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_UNUSED):
59897 VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
59898 ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59899 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
59900 HYBRID_BREAK();
59901 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED):
59902 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
59903 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59904 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
59905 HYBRID_BREAK();
59906 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK):
59907 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
59908 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59909 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
59910 HYBRID_BREAK();
59911 HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED):
59912 VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED)
59913 ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59914 VM_TRACE_OP_END(ZEND_NEW_SPEC_CONST_UNUSED)
59915 HYBRID_BREAK();
59916 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED):
59917 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
59918 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59919 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
59920 HYBRID_BREAK();
59921 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED):
59922 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
59923 ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59924 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
59925 HYBRID_BREAK();
59926 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED):
59927 VM_TRACE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
59928 ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59929 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
59930 HYBRID_BREAK();
59931 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED):
59932 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
59933 ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59934 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
59935 HYBRID_BREAK();
59936 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_UNUSED):
59937 VM_TRACE(ZEND_YIELD_SPEC_CONST_UNUSED)
59938 ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59939 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_UNUSED)
59940 HYBRID_BREAK();
59941 HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED):
59942 VM_TRACE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
59943 ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59944 VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
59945 HYBRID_BREAK();
59946 HYBRID_CASE(ZEND_COUNT_SPEC_CONST_UNUSED):
59947 VM_TRACE(ZEND_COUNT_SPEC_CONST_UNUSED)
59948 ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59949 VM_TRACE_OP_END(ZEND_COUNT_SPEC_CONST_UNUSED)
59950 HYBRID_BREAK();
59951 HYBRID_CASE(ZEND_GET_CLASS_SPEC_CONST_UNUSED):
59952 VM_TRACE(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
59953 ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59954 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
59955 HYBRID_BREAK();
59956 HYBRID_CASE(ZEND_GET_TYPE_SPEC_CONST_UNUSED):
59957 VM_TRACE(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
59958 ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59959 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
59960 HYBRID_BREAK();
59961 HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED):
59962 VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
59963 ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59964 VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
59965 HYBRID_BREAK();
59966 HYBRID_CASE(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED):
59967 VM_TRACE(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED)
59968 ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59969 VM_TRACE_OP_END(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED)
59970 HYBRID_BREAK();
59971 HYBRID_CASE(ZEND_DIV_SPEC_CONST_CV):
59972 VM_TRACE(ZEND_DIV_SPEC_CONST_CV)
59973 ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59974 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CV)
59975 HYBRID_BREAK();
59976 HYBRID_CASE(ZEND_POW_SPEC_CONST_CV):
59977 VM_TRACE(ZEND_POW_SPEC_CONST_CV)
59978 ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59979 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CV)
59980 HYBRID_BREAK();
59981 HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_CV):
59982 VM_TRACE(ZEND_CONCAT_SPEC_CONST_CV)
59983 ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59984 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_CV)
59985 HYBRID_BREAK();
59986 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CV):
59987 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CV)
59988 ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59989 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CV)
59990 HYBRID_BREAK();
59991 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CV):
59992 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
59993 ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59994 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
59995 HYBRID_BREAK();
59996 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV):
59997 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
59998 ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59999 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
60000 HYBRID_BREAK();
60001 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV):
60002 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
60003 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60004 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
60005 HYBRID_BREAK();
60006 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV):
60007 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
60008 ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60009 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
60010 HYBRID_BREAK();
60011 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV):
60012 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
60013 ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60014 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
60015 HYBRID_BREAK();
60016 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV):
60017 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
60018 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60019 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
60020 HYBRID_BREAK();
60021 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CV):
60022 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
60023 ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60024 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
60025 HYBRID_BREAK();
60026 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CV):
60027 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CV)
60028 ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60029 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CV)
60030 HYBRID_BREAK();
60031 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV):
60032 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
60033 ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60034 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
60035 HYBRID_BREAK();
60036 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV):
60037 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
60038 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60039 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
60040 HYBRID_BREAK();
60041 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CV):
60042 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
60043 ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60044 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
60045 HYBRID_BREAK();
60046 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV):
60047 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
60048 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60049 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
60050 HYBRID_BREAK();
60051 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CV):
60052 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CV)
60053 ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60054 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CV)
60055 HYBRID_BREAK();
60056 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV):
60057 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
60058 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60059 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
60060 HYBRID_BREAK();
60061 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV):
60062 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
60063 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60064 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
60065 HYBRID_BREAK();
60066 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV):
60067 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
60068 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60069 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
60070 HYBRID_BREAK();
60071 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CV):
60072 VM_TRACE(ZEND_YIELD_SPEC_CONST_CV)
60073 ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60074 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CV)
60075 HYBRID_BREAK();
60076 HYBRID_CASE(ZEND_BW_NOT_SPEC_TMPVARCV):
60077 VM_TRACE(ZEND_BW_NOT_SPEC_TMPVARCV)
60078 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60079 VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_TMPVARCV)
60080 HYBRID_BREAK();
60081 HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV):
60082 VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
60083 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60084 VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
60085 HYBRID_BREAK();
60086 HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV):
60087 VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
60088 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60089 VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
60090 HYBRID_BREAK();
60091 HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV):
60092 VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
60093 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60094 VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
60095 HYBRID_BREAK();
60096 HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_CONST):
60097 VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_CONST)
60098 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60099 VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_CONST)
60100 HYBRID_BREAK();
60101 HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_CONST):
60102 VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_CONST)
60103 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60104 VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_CONST)
60105 HYBRID_BREAK();
60106 HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_CONST):
60107 VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_CONST)
60108 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60109 VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_CONST)
60110 HYBRID_BREAK();
60111 HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_CONST):
60112 VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_CONST)
60113 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60114 VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_CONST)
60115 HYBRID_BREAK();
60116 HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_CONST):
60117 VM_TRACE(ZEND_SL_SPEC_TMPVARCV_CONST)
60118 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60119 VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_CONST)
60120 HYBRID_BREAK();
60121 HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_CONST):
60122 VM_TRACE(ZEND_SR_SPEC_TMPVARCV_CONST)
60123 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60124 VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_CONST)
60125 HYBRID_BREAK();
60126 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST):
60127 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
60128 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60129 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
60130 HYBRID_BREAK();
60131 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ):
60132 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
60133 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60134 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
60135 HYBRID_BREAK();
60136 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ):
60137 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
60138 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60139 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
60140 HYBRID_BREAK();
60141 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST):
60142 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
60143 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60144 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
60145 HYBRID_BREAK();
60146 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ):
60147 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
60148 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60149 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
60150 HYBRID_BREAK();
60151 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ):
60152 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
60153 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60154 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
60155 HYBRID_BREAK();
60156 HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_CONST):
60157 VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
60158 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60159 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
60160 HYBRID_BREAK();
60161 HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_CONST):
60162 VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
60163 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60164 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
60165 HYBRID_BREAK();
60166 HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST):
60167 VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
60168 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60169 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
60170 HYBRID_BREAK();
60171 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST):
60172 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
60173 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60174 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
60175 HYBRID_BREAK();
60176 HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST):
60177 VM_TRACE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
60178 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60179 VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
60180 HYBRID_BREAK();
60181 HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST):
60182 VM_TRACE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
60183 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60184 VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
60185 HYBRID_BREAK();
60186 HYBRID_CASE(ZEND_MATCH_SPEC_TMPVARCV_CONST):
60187 VM_TRACE(ZEND_MATCH_SPEC_TMPVARCV_CONST)
60188 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60189 VM_TRACE_OP_END(ZEND_MATCH_SPEC_TMPVARCV_CONST)
60190 HYBRID_BREAK();
60191 HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60192 VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60193 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60194 VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60195 HYBRID_BREAK();
60196 HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST):
60197 VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
60198 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60199 VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
60200 HYBRID_BREAK();
60201 HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST):
60202 VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
60203 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60204 VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
60205 HYBRID_BREAK();
60206 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60207 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60208 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60209 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60210 HYBRID_BREAK();
60211 HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST):
60212 VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
60213 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60214 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
60215 HYBRID_BREAK();
60216 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST):
60217 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
60218 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60219 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
60220 HYBRID_BREAK();
60221 HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
60222 VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60223 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60224 VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
60225 HYBRID_BREAK();
60226 HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST):
60227 VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
60228 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60229 VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
60230 HYBRID_BREAK();
60231 HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST):
60232 VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
60233 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60234 VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
60235 HYBRID_BREAK();
60236 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60237 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60238 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60239 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60240 HYBRID_BREAK();
60241 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60242 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60243 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60244 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60245 HYBRID_BREAK();
60246 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60247 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60248 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60249 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60250 HYBRID_BREAK();
60251 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60252 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60253 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60254 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60255 HYBRID_BREAK();
60256 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60257 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60258 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60259 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60260 HYBRID_BREAK();
60261 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60262 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60263 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60264 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60265 HYBRID_BREAK();
60266 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60267 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60268 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60269 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60270 HYBRID_BREAK();
60271 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60272 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60273 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60274 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60275 HYBRID_BREAK();
60276 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60277 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60278 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60279 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60280 HYBRID_BREAK();
60281 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60282 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60283 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60284 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60285 HYBRID_BREAK();
60286 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60287 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60288 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60289 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60290 HYBRID_BREAK();
60291 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60292 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60293 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60294 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60295 HYBRID_BREAK();
60296 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST):
60297 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
60298 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60299 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
60300 HYBRID_BREAK();
60301 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60302 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60303 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60304 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60305 HYBRID_BREAK();
60306 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60307 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60308 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60309 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60310 HYBRID_BREAK();
60311 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST):
60312 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
60313 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60314 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
60315 HYBRID_BREAK();
60316 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60317 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60318 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60319 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60320 HYBRID_BREAK();
60321 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60322 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60323 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60324 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60325 HYBRID_BREAK();
60326 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST):
60327 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60328 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60329 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
60330 HYBRID_BREAK();
60331 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
60332 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60333 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60334 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
60335 HYBRID_BREAK();
60336 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
60337 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60338 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60339 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
60340 HYBRID_BREAK();
60341 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
60342 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60343 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60344 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
60345 HYBRID_BREAK();
60346 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
60347 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60348 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60349 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
60350 HYBRID_BREAK();
60351 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
60352 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60353 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60354 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
60355 HYBRID_BREAK();
60356 HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV):
60357 VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
60358 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60359 VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
60360 HYBRID_BREAK();
60361 HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV):
60362 VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
60363 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60364 VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
60365 HYBRID_BREAK();
60366 HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV):
60367 VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
60368 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60369 VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
60370 HYBRID_BREAK();
60371 HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV):
60372 VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
60373 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60374 VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
60375 HYBRID_BREAK();
60376 HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV):
60377 VM_TRACE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
60378 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60379 VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
60380 HYBRID_BREAK();
60381 HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV):
60382 VM_TRACE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
60383 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60384 VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
60385 HYBRID_BREAK();
60386 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV):
60387 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
60388 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60389 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
60390 HYBRID_BREAK();
60391 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60392 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60393 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60394 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60395 HYBRID_BREAK();
60396 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60397 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60398 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60399 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60400 HYBRID_BREAK();
60401 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV):
60402 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
60403 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60404 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
60405 HYBRID_BREAK();
60406 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60407 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60408 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60409 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60410 HYBRID_BREAK();
60411 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60412 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60413 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60414 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60415 HYBRID_BREAK();
60416 HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV):
60417 VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
60418 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60419 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
60420 HYBRID_BREAK();
60421 HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV):
60422 VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
60423 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60424 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
60425 HYBRID_BREAK();
60426 HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV):
60427 VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
60428 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60429 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
60430 HYBRID_BREAK();
60431 HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60432 VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60433 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60434 VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60435 HYBRID_BREAK();
60436 HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV):
60437 VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
60438 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60439 VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
60440 HYBRID_BREAK();
60441 HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60442 VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60443 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60444 VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60445 HYBRID_BREAK();
60446 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60447 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60448 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60449 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60450 HYBRID_BREAK();
60451 HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV):
60452 VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
60453 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60454 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
60455 HYBRID_BREAK();
60456 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60457 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60458 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60459 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60460 HYBRID_BREAK();
60461 HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
60462 VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60463 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60464 VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
60465 HYBRID_BREAK();
60466 HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV):
60467 VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
60468 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60469 VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
60470 HYBRID_BREAK();
60471 HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60472 VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60473 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60474 VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60475 HYBRID_BREAK();
60476 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60477 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60478 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60479 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60480 HYBRID_BREAK();
60481 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60482 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60483 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60484 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60485 HYBRID_BREAK();
60486 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60487 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60488 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60489 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60490 HYBRID_BREAK();
60491 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60492 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60493 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60494 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60495 HYBRID_BREAK();
60496 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60497 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60498 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60499 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60500 HYBRID_BREAK();
60501 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60502 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60503 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60504 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60505 HYBRID_BREAK();
60506 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60507 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60508 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60509 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60510 HYBRID_BREAK();
60511 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60512 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60513 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60514 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60515 HYBRID_BREAK();
60516 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60517 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60518 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60519 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60520 HYBRID_BREAK();
60521 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60522 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60523 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60524 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60525 HYBRID_BREAK();
60526 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60527 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60528 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60529 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60530 HYBRID_BREAK();
60531 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60532 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60533 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60534 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60535 HYBRID_BREAK();
60536 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV):
60537 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
60538 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60539 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
60540 HYBRID_BREAK();
60541 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60542 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60543 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60544 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60545 HYBRID_BREAK();
60546 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60547 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60548 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60549 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60550 HYBRID_BREAK();
60551 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60552 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60553 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60554 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60555 HYBRID_BREAK();
60556 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60557 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60558 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60559 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60560 HYBRID_BREAK();
60561 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60562 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60563 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60564 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60565 HYBRID_BREAK();
60566 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
60567 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60568 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60569 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
60570 HYBRID_BREAK();
60571 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60572 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60573 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60574 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60575 HYBRID_BREAK();
60576 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60577 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60578 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60579 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60580 HYBRID_BREAK();
60581 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
60582 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60583 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60584 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
60585 HYBRID_BREAK();
60586 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
60587 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60588 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60589 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
60590 HYBRID_BREAK();
60591 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
60592 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60593 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60594 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
60595 HYBRID_BREAK();
60596 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR):
60597 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
60598 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60599 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
60600 HYBRID_BREAK();
60601 HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED):
60602 VM_TRACE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
60603 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60604 VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
60605 HYBRID_BREAK();
60606 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV):
60607 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
60608 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60609 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
60610 HYBRID_BREAK();
60611 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_TMPVAR):
60612 VM_TRACE(ZEND_BOOL_NOT_SPEC_TMPVAR)
60613 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60614 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_TMPVAR)
60615 HYBRID_BREAK();
60616 HYBRID_CASE(ZEND_ECHO_SPEC_TMPVAR):
60617 VM_TRACE(ZEND_ECHO_SPEC_TMPVAR)
60618 ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60619 VM_TRACE_OP_END(ZEND_ECHO_SPEC_TMPVAR)
60620 HYBRID_BREAK();
60621 HYBRID_CASE(ZEND_JMPZ_SPEC_TMPVAR):
60622 VM_TRACE(ZEND_JMPZ_SPEC_TMPVAR)
60623 ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60624 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_TMPVAR)
60625 HYBRID_BREAK();
60626 HYBRID_CASE(ZEND_JMPNZ_SPEC_TMPVAR):
60627 VM_TRACE(ZEND_JMPNZ_SPEC_TMPVAR)
60628 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60629 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_TMPVAR)
60630 HYBRID_BREAK();
60631 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_TMPVAR):
60632 VM_TRACE(ZEND_JMPZ_EX_SPEC_TMPVAR)
60633 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60634 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_TMPVAR)
60635 HYBRID_BREAK();
60636 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_TMPVAR):
60637 VM_TRACE(ZEND_JMPNZ_EX_SPEC_TMPVAR)
60638 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60639 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_TMPVAR)
60640 HYBRID_BREAK();
60641 HYBRID_CASE(ZEND_FREE_SPEC_TMPVAR):
60642 VM_TRACE(ZEND_FREE_SPEC_TMPVAR)
60643 ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60644 VM_TRACE_OP_END(ZEND_FREE_SPEC_TMPVAR)
60645 HYBRID_BREAK();
60646 HYBRID_CASE(ZEND_FE_FREE_SPEC_TMPVAR):
60647 VM_TRACE(ZEND_FE_FREE_SPEC_TMPVAR)
60648 ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60649 VM_TRACE_OP_END(ZEND_FE_FREE_SPEC_TMPVAR)
60650 HYBRID_BREAK();
60651 HYBRID_CASE(ZEND_THROW_SPEC_TMPVAR):
60652 VM_TRACE(ZEND_THROW_SPEC_TMPVAR)
60653 ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60654 VM_TRACE_OP_END(ZEND_THROW_SPEC_TMPVAR)
60655 HYBRID_BREAK();
60656 HYBRID_CASE(ZEND_BOOL_SPEC_TMPVAR):
60657 VM_TRACE(ZEND_BOOL_SPEC_TMPVAR)
60658 ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60659 VM_TRACE_OP_END(ZEND_BOOL_SPEC_TMPVAR)
60660 HYBRID_BREAK();
60661 HYBRID_CASE(ZEND_CLONE_SPEC_TMPVAR):
60662 VM_TRACE(ZEND_CLONE_SPEC_TMPVAR)
60663 ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60664 VM_TRACE_OP_END(ZEND_CLONE_SPEC_TMPVAR)
60665 HYBRID_BREAK();
60666 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR):
60667 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
60668 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60669 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
60670 HYBRID_BREAK();
60671 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_TMPVAR):
60672 VM_TRACE(ZEND_YIELD_FROM_SPEC_TMPVAR)
60673 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60674 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_TMPVAR)
60675 HYBRID_BREAK();
60676 HYBRID_CASE(ZEND_STRLEN_SPEC_TMPVAR):
60677 VM_TRACE(ZEND_STRLEN_SPEC_TMPVAR)
60678 ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60679 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_TMPVAR)
60680 HYBRID_BREAK();
60681 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_TMPVAR):
60682 VM_TRACE(ZEND_TYPE_CHECK_SPEC_TMPVAR)
60683 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60684 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_TMPVAR)
60685 HYBRID_BREAK();
60686 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR):
60687 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
60688 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60689 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
60690 HYBRID_BREAK();
60691 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CONST):
60692 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CONST)
60693 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60694 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CONST)
60695 HYBRID_BREAK();
60696 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CONST):
60697 VM_TRACE(ZEND_POW_SPEC_TMPVAR_CONST)
60698 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60699 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CONST)
60700 HYBRID_BREAK();
60701 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CONST):
60702 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CONST)
60703 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60704 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CONST)
60705 HYBRID_BREAK();
60706 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST):
60707 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
60708 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60709 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
60710 HYBRID_BREAK();
60711 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
60712 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60713 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60714 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60715 HYBRID_BREAK();
60716 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
60717 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60718 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60719 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60720 HYBRID_BREAK();
60721 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST):
60722 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
60723 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60724 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
60725 HYBRID_BREAK();
60726 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
60727 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60728 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60729 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
60730 HYBRID_BREAK();
60731 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
60732 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60733 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60734 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
60735 HYBRID_BREAK();
60736 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST):
60737 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
60738 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60739 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
60740 HYBRID_BREAK();
60741 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST):
60742 VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
60743 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60744 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
60745 HYBRID_BREAK();
60746 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST):
60747 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
60748 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60749 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
60750 HYBRID_BREAK();
60751 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST):
60752 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
60753 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60754 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
60755 HYBRID_BREAK();
60756 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST):
60757 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
60758 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60759 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
60760 HYBRID_BREAK();
60761 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST):
60762 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
60763 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60764 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
60765 HYBRID_BREAK();
60766 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST):
60767 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
60768 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60769 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
60770 HYBRID_BREAK();
60771 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST):
60772 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
60773 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60774 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
60775 HYBRID_BREAK();
60776 HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST):
60777 VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
60778 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60779 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
60780 HYBRID_BREAK();
60781 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CONST):
60782 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CONST)
60783 ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60784 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CONST)
60785 HYBRID_BREAK();
60786 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST):
60787 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
60788 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60789 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
60790 HYBRID_BREAK();
60791 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST):
60792 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
60793 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60794 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
60795 HYBRID_BREAK();
60796 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST):
60797 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
60798 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60799 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
60800 HYBRID_BREAK();
60801 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST):
60802 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
60803 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60804 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
60805 HYBRID_BREAK();
60806 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST):
60807 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
60808 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60809 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
60810 HYBRID_BREAK();
60811 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV):
60812 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
60813 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60814 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
60815 HYBRID_BREAK();
60816 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_TMPVAR):
60817 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
60818 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60819 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
60820 HYBRID_BREAK();
60821 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_TMPVAR):
60822 VM_TRACE(ZEND_POW_SPEC_TMPVAR_TMPVAR)
60823 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60824 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_TMPVAR)
60825 HYBRID_BREAK();
60826 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR):
60827 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
60828 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60829 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
60830 HYBRID_BREAK();
60831 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR):
60832 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
60833 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60834 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
60835 HYBRID_BREAK();
60836 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
60837 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
60838 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60839 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
60840 HYBRID_BREAK();
60841 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
60842 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
60843 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60844 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
60845 HYBRID_BREAK();
60846 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR):
60847 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
60848 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60849 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
60850 HYBRID_BREAK();
60851 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
60852 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
60853 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60854 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
60855 HYBRID_BREAK();
60856 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
60857 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
60858 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60859 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
60860 HYBRID_BREAK();
60861 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR):
60862 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
60863 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60864 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
60865 HYBRID_BREAK();
60866 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR):
60867 VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
60868 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60869 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
60870 HYBRID_BREAK();
60871 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR):
60872 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
60873 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60874 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
60875 HYBRID_BREAK();
60876 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR):
60877 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
60878 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60879 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
60880 HYBRID_BREAK();
60881 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR):
60882 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
60883 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60884 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
60885 HYBRID_BREAK();
60886 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR):
60887 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
60888 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60889 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
60890 HYBRID_BREAK();
60891 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR):
60892 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
60893 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60894 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
60895 HYBRID_BREAK();
60896 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR):
60897 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
60898 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60899 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
60900 HYBRID_BREAK();
60901 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_TMPVAR):
60902 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
60903 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60904 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
60905 HYBRID_BREAK();
60906 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR):
60907 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
60908 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60909 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
60910 HYBRID_BREAK();
60911 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR):
60912 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
60913 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60914 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
60915 HYBRID_BREAK();
60916 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR):
60917 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
60918 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60919 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
60920 HYBRID_BREAK();
60921 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR):
60922 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
60923 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60924 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
60925 HYBRID_BREAK();
60926 HYBRID_CASE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED):
60927 VM_TRACE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
60928 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60929 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
60930 HYBRID_BREAK();
60931 HYBRID_CASE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED):
60932 VM_TRACE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
60933 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60934 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
60935 HYBRID_BREAK();
60936 HYBRID_CASE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED):
60937 VM_TRACE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
60938 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60939 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
60940 HYBRID_BREAK();
60941 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED):
60942 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
60943 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60944 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
60945 HYBRID_BREAK();
60946 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED):
60947 VM_TRACE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
60948 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60949 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
60950 HYBRID_BREAK();
60951 HYBRID_CASE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED):
60952 VM_TRACE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
60953 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60954 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
60955 HYBRID_BREAK();
60956 HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED):
60957 VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
60958 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60959 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
60960 HYBRID_BREAK();
60961 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED):
60962 VM_TRACE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
60963 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60964 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
60965 HYBRID_BREAK();
60966 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED):
60967 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
60968 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60969 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
60970 HYBRID_BREAK();
60971 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED):
60972 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
60973 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60974 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
60975 HYBRID_BREAK();
60976 HYBRID_CASE(ZEND_COUNT_SPEC_TMPVAR_UNUSED):
60977 VM_TRACE(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
60978 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60979 VM_TRACE_OP_END(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
60980 HYBRID_BREAK();
60981 HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED):
60982 VM_TRACE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
60983 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60984 VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
60985 HYBRID_BREAK();
60986 HYBRID_CASE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED):
60987 VM_TRACE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
60988 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60989 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
60990 HYBRID_BREAK();
60991 HYBRID_CASE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED):
60992 VM_TRACE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
60993 ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60994 VM_TRACE_OP_END(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
60995 HYBRID_BREAK();
60996 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CV):
60997 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CV)
60998 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60999 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CV)
61000 HYBRID_BREAK();
61001 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CV):
61002 VM_TRACE(ZEND_POW_SPEC_TMPVAR_CV)
61003 ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61004 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CV)
61005 HYBRID_BREAK();
61006 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CV):
61007 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CV)
61008 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61009 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CV)
61010 HYBRID_BREAK();
61011 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CV):
61012 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
61013 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61014 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
61015 HYBRID_BREAK();
61016 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV):
61017 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
61018 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61019 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
61020 HYBRID_BREAK();
61021 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV):
61022 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
61023 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61024 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
61025 HYBRID_BREAK();
61026 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV):
61027 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
61028 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61029 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
61030 HYBRID_BREAK();
61031 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV):
61032 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
61033 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61034 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
61035 HYBRID_BREAK();
61036 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV):
61037 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
61038 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61039 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
61040 HYBRID_BREAK();
61041 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV):
61042 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
61043 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61044 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
61045 HYBRID_BREAK();
61046 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CV):
61047 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CV)
61048 ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61049 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CV)
61050 HYBRID_BREAK();
61051 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV):
61052 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
61053 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61054 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
61055 HYBRID_BREAK();
61056 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV):
61057 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
61058 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61059 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
61060 HYBRID_BREAK();
61061 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV):
61062 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
61063 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61064 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
61065 HYBRID_BREAK();
61066 HYBRID_CASE(ZEND_RETURN_SPEC_TMP):
61067 VM_TRACE(ZEND_RETURN_SPEC_TMP)
61068 {
61069 USE_OPLINE
61070 zval *retval_ptr;
61071 zval *return_value;
61072
61073 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
61074 return_value = EX(return_value);
61075
61076 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
61077 SAVE_OPLINE();
61078 retval_ptr = ZVAL_UNDEFINED_OP1();
61079 if (return_value) {
61080 ZVAL_NULL(return_value);
61081 }
61082 } else if (!return_value) {
61083 if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
61084 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
61085 SAVE_OPLINE();
61086 rc_dtor_func(Z_COUNTED_P(retval_ptr));
61087 }
61088 }
61089 } else {
61090 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
61091 ZVAL_COPY_VALUE(return_value, retval_ptr);
61092 if (IS_TMP_VAR == IS_CONST) {
61093 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
61094 Z_ADDREF_P(return_value);
61095 }
61096 }
61097 } else if (IS_TMP_VAR == IS_CV) {
61098 do {
61099 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61100 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
61101 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
61102 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61103 ZVAL_COPY_VALUE(return_value, retval_ptr);
61104 if (GC_MAY_LEAK(ref)) {
61105 SAVE_OPLINE();
61106 gc_possible_root(ref);
61107 }
61108 ZVAL_NULL(retval_ptr);
61109 break;
61110 } else {
61111 Z_ADDREF_P(retval_ptr);
61112 }
61113 } else {
61114 retval_ptr = Z_REFVAL_P(retval_ptr);
61115 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61116 Z_ADDREF_P(retval_ptr);
61117 }
61118 }
61119 }
61120 ZVAL_COPY_VALUE(return_value, retval_ptr);
61121 } while (0);
61122 } else /* if (IS_TMP_VAR == IS_VAR) */ {
61123 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
61124 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61125
61126 retval_ptr = Z_REFVAL_P(retval_ptr);
61127 ZVAL_COPY_VALUE(return_value, retval_ptr);
61128 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
61129 efree_size(ref, sizeof(zend_reference));
61130 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61131 Z_ADDREF_P(retval_ptr);
61132 }
61133 } else {
61134 ZVAL_COPY_VALUE(return_value, retval_ptr);
61135 }
61136 }
61137 }
61138
61139
61140
61141 goto zend_leave_helper_SPEC_LABEL;
61142 }
61143
61144 VM_TRACE_OP_END(ZEND_RETURN_SPEC_TMP)
61145 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_TMP):
61146 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_TMP)
61147 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61148 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_TMP)
61149 HYBRID_BREAK();
61150 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_TMP):
61151 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_TMP)
61152 ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61153 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_TMP)
61154 HYBRID_BREAK();
61155 HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP):
61156 VM_TRACE(ZEND_SEND_USER_SPEC_TMP)
61157 ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61158 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP)
61159 HYBRID_BREAK();
61160 HYBRID_CASE(ZEND_CAST_SPEC_TMP):
61161 VM_TRACE(ZEND_CAST_SPEC_TMP)
61162 ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61163 VM_TRACE_OP_END(ZEND_CAST_SPEC_TMP)
61164 HYBRID_BREAK();
61165 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_TMP):
61166 VM_TRACE(ZEND_FE_RESET_R_SPEC_TMP)
61167 ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61168 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_TMP)
61169 HYBRID_BREAK();
61170 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_TMP):
61171 VM_TRACE(ZEND_FE_RESET_RW_SPEC_TMP)
61172 ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61173 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_TMP)
61174 HYBRID_BREAK();
61175 HYBRID_CASE(ZEND_END_SILENCE_SPEC_TMP):
61176 VM_TRACE(ZEND_END_SILENCE_SPEC_TMP)
61177 ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61178 VM_TRACE_OP_END(ZEND_END_SILENCE_SPEC_TMP)
61179 HYBRID_BREAK();
61180 HYBRID_CASE(ZEND_JMP_SET_SPEC_TMP):
61181 VM_TRACE(ZEND_JMP_SET_SPEC_TMP)
61182 ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61183 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_TMP)
61184 HYBRID_BREAK();
61185 HYBRID_CASE(ZEND_COALESCE_SPEC_TMP):
61186 VM_TRACE(ZEND_COALESCE_SPEC_TMP)
61187 ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61188 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_TMP)
61189 HYBRID_BREAK();
61190 HYBRID_CASE(ZEND_JMP_NULL_SPEC_TMP):
61191 VM_TRACE(ZEND_JMP_NULL_SPEC_TMP)
61192 ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61193 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_TMP)
61194 HYBRID_BREAK();
61195 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_TMP):
61196 VM_TRACE(ZEND_QM_ASSIGN_SPEC_TMP)
61197 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61198 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_TMP)
61199 HYBRID_BREAK();
61200 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST):
61201 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
61202 ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61203 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
61204 HYBRID_BREAK();
61205 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CONST):
61206 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CONST)
61207 ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61208 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CONST)
61209 HYBRID_BREAK();
61210 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST):
61211 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
61212 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61213 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
61214 HYBRID_BREAK();
61215 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST):
61216 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
61217 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61218 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
61219 HYBRID_BREAK();
61220 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST):
61221 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
61222 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61223 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
61224 HYBRID_BREAK();
61225 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CONST):
61226 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CONST)
61227 ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61228 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CONST)
61229 HYBRID_BREAK();
61230 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CONST):
61231 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CONST)
61232 ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61233 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CONST)
61234 HYBRID_BREAK();
61235 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST):
61236 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
61237 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61238 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
61239 HYBRID_BREAK();
61240 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST):
61241 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
61242 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61243 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
61244 HYBRID_BREAK();
61245 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CONST):
61246 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
61247 ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61248 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
61249 HYBRID_BREAK();
61250 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CONST):
61251 VM_TRACE(ZEND_YIELD_SPEC_TMP_CONST)
61252 ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61253 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CONST)
61254 HYBRID_BREAK();
61255 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_TMP_CONST):
61256 VM_TRACE(ZEND_IN_ARRAY_SPEC_TMP_CONST)
61257 ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61258 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_TMP_CONST)
61259 HYBRID_BREAK();
61260 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR):
61261 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
61262 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61263 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
61264 HYBRID_BREAK();
61265 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR):
61266 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
61267 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61268 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
61269 HYBRID_BREAK();
61270 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR):
61271 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
61272 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61273 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
61274 HYBRID_BREAK();
61275 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_TMPVAR):
61276 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
61277 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61278 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
61279 HYBRID_BREAK();
61280 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR):
61281 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
61282 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61283 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
61284 HYBRID_BREAK();
61285 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR):
61286 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
61287 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61288 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
61289 HYBRID_BREAK();
61290 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_TMPVAR):
61291 VM_TRACE(ZEND_YIELD_SPEC_TMP_TMPVAR)
61292 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61293 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_TMPVAR)
61294 HYBRID_BREAK();
61295 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP):
61296 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
61297 ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61298 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
61299 HYBRID_BREAK();
61300 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_TMP):
61301 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_TMP)
61302 ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61303 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_TMP)
61304 HYBRID_BREAK();
61305 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP):
61306 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
61307 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61308 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
61309 HYBRID_BREAK();
61310 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_VAR):
61311 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_VAR)
61312 ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61313 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_VAR)
61314 HYBRID_BREAK();
61315 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED):
61316 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
61317 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61318 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
61319 HYBRID_BREAK();
61320 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED):
61321 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
61322 ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61323 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
61324 HYBRID_BREAK();
61325 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED):
61326 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
61327 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61328 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
61329 HYBRID_BREAK();
61330 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK):
61331 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
61332 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61333 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
61334 HYBRID_BREAK();
61335 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED):
61336 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
61337 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61338 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
61339 HYBRID_BREAK();
61340 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED):
61341 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
61342 ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61343 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
61344 HYBRID_BREAK();
61345 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_UNUSED):
61346 VM_TRACE(ZEND_YIELD_SPEC_TMP_UNUSED)
61347 ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61348 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_UNUSED)
61349 HYBRID_BREAK();
61350 HYBRID_CASE(ZEND_GET_TYPE_SPEC_TMP_UNUSED):
61351 VM_TRACE(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
61352 ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61353 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
61354 HYBRID_BREAK();
61355 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CV):
61356 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CV)
61357 ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61358 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CV)
61359 HYBRID_BREAK();
61360 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV):
61361 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
61362 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61363 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
61364 HYBRID_BREAK();
61365 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV):
61366 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
61367 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61368 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
61369 HYBRID_BREAK();
61370 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CV):
61371 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CV)
61372 ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61373 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CV)
61374 HYBRID_BREAK();
61375 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CV):
61376 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CV)
61377 ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61378 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CV)
61379 HYBRID_BREAK();
61380 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV):
61381 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
61382 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61383 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
61384 HYBRID_BREAK();
61385 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CV):
61386 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CV)
61387 ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61388 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CV)
61389 HYBRID_BREAK();
61390 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CV):
61391 VM_TRACE(ZEND_YIELD_SPEC_TMP_CV)
61392 ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61393 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CV)
61394 HYBRID_BREAK();
61395 HYBRID_CASE(ZEND_BIND_LEXICAL_SPEC_TMP_CV):
61396 VM_TRACE(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
61397 ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61398 VM_TRACE_OP_END(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
61399 HYBRID_BREAK();
61400 HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED):
61401 VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
61402 ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61403 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
61404 HYBRID_BREAK();
61405 HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED):
61406 VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
61407 ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61408 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
61409 HYBRID_BREAK();
61410 HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED):
61411 VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
61412 ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61413 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
61414 HYBRID_BREAK();
61415 HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED):
61416 VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
61417 ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61418 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
61419 HYBRID_BREAK();
61420 HYBRID_CASE(ZEND_POST_INC_SPEC_VAR):
61421 VM_TRACE(ZEND_POST_INC_SPEC_VAR)
61422 ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61423 VM_TRACE_OP_END(ZEND_POST_INC_SPEC_VAR)
61424 HYBRID_BREAK();
61425 HYBRID_CASE(ZEND_POST_DEC_SPEC_VAR):
61426 VM_TRACE(ZEND_POST_DEC_SPEC_VAR)
61427 ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61428 VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_VAR)
61429 HYBRID_BREAK();
61430 HYBRID_CASE(ZEND_RETURN_SPEC_VAR):
61431 VM_TRACE(ZEND_RETURN_SPEC_VAR)
61432 {
61433 USE_OPLINE
61434 zval *retval_ptr;
61435 zval *return_value;
61436
61437 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
61438 return_value = EX(return_value);
61439
61440 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
61441 SAVE_OPLINE();
61442 retval_ptr = ZVAL_UNDEFINED_OP1();
61443 if (return_value) {
61444 ZVAL_NULL(return_value);
61445 }
61446 } else if (!return_value) {
61447 if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
61448 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
61449 SAVE_OPLINE();
61450 rc_dtor_func(Z_COUNTED_P(retval_ptr));
61451 }
61452 }
61453 } else {
61454 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
61455 ZVAL_COPY_VALUE(return_value, retval_ptr);
61456 if (IS_VAR == IS_CONST) {
61457 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
61458 Z_ADDREF_P(return_value);
61459 }
61460 }
61461 } else if (IS_VAR == IS_CV) {
61462 do {
61463 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61464 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
61465 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
61466 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61467 ZVAL_COPY_VALUE(return_value, retval_ptr);
61468 if (GC_MAY_LEAK(ref)) {
61469 SAVE_OPLINE();
61470 gc_possible_root(ref);
61471 }
61472 ZVAL_NULL(retval_ptr);
61473 break;
61474 } else {
61475 Z_ADDREF_P(retval_ptr);
61476 }
61477 } else {
61478 retval_ptr = Z_REFVAL_P(retval_ptr);
61479 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61480 Z_ADDREF_P(retval_ptr);
61481 }
61482 }
61483 }
61484 ZVAL_COPY_VALUE(return_value, retval_ptr);
61485 } while (0);
61486 } else /* if (IS_VAR == IS_VAR) */ {
61487 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
61488 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61489
61490 retval_ptr = Z_REFVAL_P(retval_ptr);
61491 ZVAL_COPY_VALUE(return_value, retval_ptr);
61492 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
61493 efree_size(ref, sizeof(zend_reference));
61494 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61495 Z_ADDREF_P(retval_ptr);
61496 }
61497 } else {
61498 ZVAL_COPY_VALUE(return_value, retval_ptr);
61499 }
61500 }
61501 }
61502
61503
61504
61505 goto zend_leave_helper_SPEC_LABEL;
61506 }
61507
61508 VM_TRACE_OP_END(ZEND_RETURN_SPEC_VAR)
61509 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_VAR):
61510 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_VAR)
61511 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61512 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_VAR)
61513 HYBRID_BREAK();
61514 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_VAR):
61515 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_VAR)
61516 ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61517 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_VAR)
61518 HYBRID_BREAK();
61519 HYBRID_CASE(ZEND_SEND_USER_SPEC_VAR):
61520 VM_TRACE(ZEND_SEND_USER_SPEC_VAR)
61521 ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61522 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_VAR)
61523 HYBRID_BREAK();
61524 HYBRID_CASE(ZEND_CAST_SPEC_VAR):
61525 VM_TRACE(ZEND_CAST_SPEC_VAR)
61526 ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61527 VM_TRACE_OP_END(ZEND_CAST_SPEC_VAR)
61528 HYBRID_BREAK();
61529 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_VAR):
61530 VM_TRACE(ZEND_FE_RESET_R_SPEC_VAR)
61531 ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61532 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_VAR)
61533 HYBRID_BREAK();
61534 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_VAR):
61535 VM_TRACE(ZEND_FE_RESET_RW_SPEC_VAR)
61536 ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61537 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_VAR)
61538 HYBRID_BREAK();
61539 HYBRID_CASE(ZEND_FE_FETCH_R_SPEC_VAR):
61540 VM_TRACE(ZEND_FE_FETCH_R_SPEC_VAR)
61541 ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61542 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SPEC_VAR)
61543 HYBRID_BREAK();
61544 HYBRID_CASE(ZEND_FE_FETCH_RW_SPEC_VAR):
61545 VM_TRACE(ZEND_FE_FETCH_RW_SPEC_VAR)
61546 ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61547 VM_TRACE_OP_END(ZEND_FE_FETCH_RW_SPEC_VAR)
61548 HYBRID_BREAK();
61549 HYBRID_CASE(ZEND_JMP_SET_SPEC_VAR):
61550 VM_TRACE(ZEND_JMP_SET_SPEC_VAR)
61551 ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61552 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_VAR)
61553 HYBRID_BREAK();
61554 HYBRID_CASE(ZEND_COALESCE_SPEC_VAR):
61555 VM_TRACE(ZEND_COALESCE_SPEC_VAR)
61556 ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61557 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_VAR)
61558 HYBRID_BREAK();
61559 HYBRID_CASE(ZEND_JMP_NULL_SPEC_VAR):
61560 VM_TRACE(ZEND_JMP_NULL_SPEC_VAR)
61561 ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61562 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_VAR)
61563 HYBRID_BREAK();
61564 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_VAR):
61565 VM_TRACE(ZEND_QM_ASSIGN_SPEC_VAR)
61566 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61567 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_VAR)
61568 HYBRID_BREAK();
61569 HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR):
61570 VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
61571 ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61572 VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
61573 HYBRID_BREAK();
61574 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST):
61575 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
61576 ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61577 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
61578 HYBRID_BREAK();
61579 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CONST):
61580 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CONST)
61581 ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61582 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CONST)
61583 HYBRID_BREAK();
61584 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST):
61585 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
61586 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61587 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
61588 HYBRID_BREAK();
61589 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST):
61590 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
61591 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61592 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
61593 HYBRID_BREAK();
61594 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST):
61595 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
61596 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61597 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
61598 HYBRID_BREAK();
61599 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CONST):
61600 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
61601 ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61602 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
61603 HYBRID_BREAK();
61604 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST):
61605 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
61606 ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61607 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
61608 HYBRID_BREAK();
61609 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST):
61610 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
61611 ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61612 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
61613 HYBRID_BREAK();
61614 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST):
61615 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
61616 ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61617 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
61618 HYBRID_BREAK();
61619 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST):
61620 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
61621 ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61622 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
61623 HYBRID_BREAK();
61624 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST):
61625 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
61626 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61627 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
61628 HYBRID_BREAK();
61629 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST):
61630 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
61631 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61632 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
61633 HYBRID_BREAK();
61634 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST):
61635 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
61636 ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61637 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
61638 HYBRID_BREAK();
61639 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST):
61640 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
61641 ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61642 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
61643 HYBRID_BREAK();
61644 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST):
61645 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
61646 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61647 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
61648 HYBRID_BREAK();
61649 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST):
61650 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
61651 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61652 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
61653 HYBRID_BREAK();
61654 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST):
61655 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
61656 ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61657 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
61658 HYBRID_BREAK();
61659 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST):
61660 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
61661 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61662 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
61663 HYBRID_BREAK();
61664 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP):
61665 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
61666 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61667 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
61668 HYBRID_BREAK();
61669 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR):
61670 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
61671 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61672 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
61673 HYBRID_BREAK();
61674 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV):
61675 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
61676 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61677 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
61678 HYBRID_BREAK();
61679 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST):
61680 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
61681 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61682 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
61683 HYBRID_BREAK();
61684 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP):
61685 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
61686 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61687 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
61688 HYBRID_BREAK();
61689 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR):
61690 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
61691 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61692 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
61693 HYBRID_BREAK();
61694 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV):
61695 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
61696 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61697 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
61698 HYBRID_BREAK();
61699 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED):
61700 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
61701 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61702 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
61703 HYBRID_BREAK();
61704 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED):
61705 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
61706 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61707 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
61708 HYBRID_BREAK();
61709 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR):
61710 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
61711 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61712 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
61713 HYBRID_BREAK();
61714 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV):
61715 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
61716 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61717 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
61718 HYBRID_BREAK();
61719 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST):
61720 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
61721 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61722 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
61723 HYBRID_BREAK();
61724 HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_CONST):
61725 VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_CONST)
61726 ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61727 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_CONST)
61728 HYBRID_BREAK();
61729 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST):
61730 VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
61731 ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61732 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
61733 HYBRID_BREAK();
61734 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST):
61735 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
61736 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61737 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
61738 HYBRID_BREAK();
61739 HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_CONST):
61740 VM_TRACE(ZEND_SEND_REF_SPEC_VAR_CONST)
61741 ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61742 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_CONST)
61743 HYBRID_BREAK();
61744 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST):
61745 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
61746 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61747 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
61748 HYBRID_BREAK();
61749 HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST):
61750 VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
61751 ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61752 VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
61753 HYBRID_BREAK();
61754 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST):
61755 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
61756 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61757 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
61758 HYBRID_BREAK();
61759 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST):
61760 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
61761 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61762 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
61763 HYBRID_BREAK();
61764 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CONST):
61765 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
61766 ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61767 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
61768 HYBRID_BREAK();
61769 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CONST):
61770 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CONST)
61771 ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61772 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CONST)
61773 HYBRID_BREAK();
61774 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CONST):
61775 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
61776 ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61777 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
61778 HYBRID_BREAK();
61779 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CONST):
61780 VM_TRACE(ZEND_YIELD_SPEC_VAR_CONST)
61781 ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61782 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CONST)
61783 HYBRID_BREAK();
61784 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_VAR_CONST):
61785 VM_TRACE(ZEND_IN_ARRAY_SPEC_VAR_CONST)
61786 ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61787 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_VAR_CONST)
61788 HYBRID_BREAK();
61789 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV):
61790 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
61791 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61792 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
61793 HYBRID_BREAK();
61794 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR):
61795 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
61796 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61797 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
61798 HYBRID_BREAK();
61799 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR):
61800 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
61801 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61802 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
61803 HYBRID_BREAK();
61804 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR):
61805 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
61806 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61807 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
61808 HYBRID_BREAK();
61809 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR):
61810 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
61811 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61812 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
61813 HYBRID_BREAK();
61814 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR):
61815 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
61816 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61817 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
61818 HYBRID_BREAK();
61819 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR):
61820 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
61821 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61822 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
61823 HYBRID_BREAK();
61824 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR):
61825 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
61826 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61827 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
61828 HYBRID_BREAK();
61829 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR):
61830 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
61831 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61832 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
61833 HYBRID_BREAK();
61834 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR):
61835 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
61836 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61837 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
61838 HYBRID_BREAK();
61839 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR):
61840 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
61841 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61842 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
61843 HYBRID_BREAK();
61844 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR):
61845 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
61846 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61847 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
61848 HYBRID_BREAK();
61849 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR):
61850 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
61851 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61852 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
61853 HYBRID_BREAK();
61854 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR):
61855 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
61856 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61857 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
61858 HYBRID_BREAK();
61859 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR):
61860 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
61861 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61862 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
61863 HYBRID_BREAK();
61864 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST):
61865 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
61866 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61867 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
61868 HYBRID_BREAK();
61869 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP):
61870 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
61871 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61872 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
61873 HYBRID_BREAK();
61874 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR):
61875 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61876 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61877 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61878 HYBRID_BREAK();
61879 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV):
61880 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
61881 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61882 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
61883 HYBRID_BREAK();
61884 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST):
61885 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
61886 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61887 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
61888 HYBRID_BREAK();
61889 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP):
61890 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
61891 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61892 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
61893 HYBRID_BREAK();
61894 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR):
61895 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61896 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61897 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61898 HYBRID_BREAK();
61899 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV):
61900 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
61901 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61902 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
61903 HYBRID_BREAK();
61904 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR):
61905 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61906 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61907 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
61908 HYBRID_BREAK();
61909 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV):
61910 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
61911 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61912 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
61913 HYBRID_BREAK();
61914 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR):
61915 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
61916 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61917 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
61918 HYBRID_BREAK();
61919 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR):
61920 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
61921 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61922 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
61923 HYBRID_BREAK();
61924 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR):
61925 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
61926 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61927 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
61928 HYBRID_BREAK();
61929 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR):
61930 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
61931 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61932 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
61933 HYBRID_BREAK();
61934 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR):
61935 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
61936 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61937 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
61938 HYBRID_BREAK();
61939 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_TMPVAR):
61940 VM_TRACE(ZEND_YIELD_SPEC_VAR_TMPVAR)
61941 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61942 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_TMPVAR)
61943 HYBRID_BREAK();
61944 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP):
61945 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
61946 ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61947 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
61948 HYBRID_BREAK();
61949 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_TMP):
61950 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_TMP)
61951 ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61952 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_TMP)
61953 HYBRID_BREAK();
61954 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP):
61955 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
61956 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61957 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
61958 HYBRID_BREAK();
61959 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED):
61960 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
61961 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61962 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
61963 HYBRID_BREAK();
61964 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED):
61965 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
61966 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61967 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
61968 HYBRID_BREAK();
61969 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR):
61970 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
61971 ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61972 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
61973 HYBRID_BREAK();
61974 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_VAR):
61975 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_VAR)
61976 ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61977 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_VAR)
61978 HYBRID_BREAK();
61979 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR):
61980 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
61981 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61982 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
61983 HYBRID_BREAK();
61984 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED):
61985 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
61986 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61987 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
61988 HYBRID_BREAK();
61989 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED):
61990 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
61991 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61992 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
61993 HYBRID_BREAK();
61994 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_VAR):
61995 VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
61996 ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61997 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
61998 HYBRID_BREAK();
61999 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED):
62000 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
62001 ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62002 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
62003 HYBRID_BREAK();
62004 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED):
62005 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
62006 ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62007 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
62008 HYBRID_BREAK();
62009 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED):
62010 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
62011 ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62012 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
62013 HYBRID_BREAK();
62014 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED):
62015 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
62016 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62017 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
62018 HYBRID_BREAK();
62019 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST):
62020 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
62021 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62022 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
62023 HYBRID_BREAK();
62024 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP):
62025 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
62026 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62027 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
62028 HYBRID_BREAK();
62029 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR):
62030 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
62031 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62032 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
62033 HYBRID_BREAK();
62034 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV):
62035 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
62036 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62037 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
62038 HYBRID_BREAK();
62039 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED):
62040 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
62041 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62042 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
62043 HYBRID_BREAK();
62044 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED):
62045 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
62046 ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62047 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
62048 HYBRID_BREAK();
62049 HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_UNUSED):
62050 VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
62051 ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62052 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
62053 HYBRID_BREAK();
62054 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED):
62055 VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
62056 ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62057 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
62058 HYBRID_BREAK();
62059 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED):
62060 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
62061 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62062 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
62063 HYBRID_BREAK();
62064 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK):
62065 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
62066 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62067 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
62068 HYBRID_BREAK();
62069 HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_UNUSED):
62070 VM_TRACE(ZEND_SEND_REF_SPEC_VAR_UNUSED)
62071 ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62072 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_UNUSED)
62073 HYBRID_BREAK();
62074 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED):
62075 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
62076 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62077 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
62078 HYBRID_BREAK();
62079 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK):
62080 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
62081 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62082 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
62083 HYBRID_BREAK();
62084 HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED):
62085 VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
62086 ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62087 VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
62088 HYBRID_BREAK();
62089 HYBRID_CASE(ZEND_NEW_SPEC_VAR_UNUSED):
62090 VM_TRACE(ZEND_NEW_SPEC_VAR_UNUSED)
62091 ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62092 VM_TRACE_OP_END(ZEND_NEW_SPEC_VAR_UNUSED)
62093 HYBRID_BREAK();
62094 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED):
62095 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
62096 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62097 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
62098 HYBRID_BREAK();
62099 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED):
62100 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
62101 ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62102 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
62103 HYBRID_BREAK();
62104 HYBRID_CASE(ZEND_SEPARATE_SPEC_VAR_UNUSED):
62105 VM_TRACE(ZEND_SEPARATE_SPEC_VAR_UNUSED)
62106 ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62107 VM_TRACE_OP_END(ZEND_SEPARATE_SPEC_VAR_UNUSED)
62108 HYBRID_BREAK();
62109 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_UNUSED):
62110 VM_TRACE(ZEND_YIELD_SPEC_VAR_UNUSED)
62111 ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62112 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_UNUSED)
62113 HYBRID_BREAK();
62114 HYBRID_CASE(ZEND_MAKE_REF_SPEC_VAR_UNUSED):
62115 VM_TRACE(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
62116 ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62117 VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
62118 HYBRID_BREAK();
62119 HYBRID_CASE(ZEND_GET_TYPE_SPEC_VAR_UNUSED):
62120 VM_TRACE(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
62121 ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62122 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
62123 HYBRID_BREAK();
62124 HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED):
62125 VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
62126 ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62127 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
62128 HYBRID_BREAK();
62129 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CV):
62130 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CV)
62131 ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62132 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CV)
62133 HYBRID_BREAK();
62134 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV):
62135 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
62136 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62137 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
62138 HYBRID_BREAK();
62139 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV):
62140 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
62141 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62142 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
62143 HYBRID_BREAK();
62144 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CV):
62145 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CV)
62146 ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62147 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CV)
62148 HYBRID_BREAK();
62149 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV):
62150 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
62151 ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62152 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
62153 HYBRID_BREAK();
62154 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CV):
62155 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
62156 ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62157 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
62158 HYBRID_BREAK();
62159 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CV):
62160 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
62161 ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62162 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
62163 HYBRID_BREAK();
62164 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV):
62165 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
62166 ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62167 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
62168 HYBRID_BREAK();
62169 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV):
62170 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
62171 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62172 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
62173 HYBRID_BREAK();
62174 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV):
62175 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
62176 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62177 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
62178 HYBRID_BREAK();
62179 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV):
62180 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
62181 ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62182 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
62183 HYBRID_BREAK();
62184 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV):
62185 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
62186 ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62187 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
62188 HYBRID_BREAK();
62189 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV):
62190 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
62191 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62192 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
62193 HYBRID_BREAK();
62194 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV):
62195 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
62196 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62197 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
62198 HYBRID_BREAK();
62199 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CV):
62200 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
62201 ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62202 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
62203 HYBRID_BREAK();
62204 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST):
62205 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
62206 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62207 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
62208 HYBRID_BREAK();
62209 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP):
62210 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
62211 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62212 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
62213 HYBRID_BREAK();
62214 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR):
62215 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
62216 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62217 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
62218 HYBRID_BREAK();
62219 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV):
62220 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
62221 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62222 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
62223 HYBRID_BREAK();
62224 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST):
62225 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
62226 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62227 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
62228 HYBRID_BREAK();
62229 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP):
62230 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
62231 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62232 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
62233 HYBRID_BREAK();
62234 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR):
62235 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
62236 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62237 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
62238 HYBRID_BREAK();
62239 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV):
62240 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
62241 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62242 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
62243 HYBRID_BREAK();
62244 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED):
62245 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
62246 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62247 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
62248 HYBRID_BREAK();
62249 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED):
62250 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
62251 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62252 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
62253 HYBRID_BREAK();
62254 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_CV):
62255 VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_CV)
62256 ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62257 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_CV)
62258 HYBRID_BREAK();
62259 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR):
62260 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
62261 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62262 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
62263 HYBRID_BREAK();
62264 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV):
62265 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
62266 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62267 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
62268 HYBRID_BREAK();
62269 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV):
62270 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
62271 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62272 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
62273 HYBRID_BREAK();
62274 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV):
62275 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
62276 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62277 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
62278 HYBRID_BREAK();
62279 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CV):
62280 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CV)
62281 ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62282 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CV)
62283 HYBRID_BREAK();
62284 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CV):
62285 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CV)
62286 ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62287 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CV)
62288 HYBRID_BREAK();
62289 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CV):
62290 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CV)
62291 ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62292 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CV)
62293 HYBRID_BREAK();
62294 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CV):
62295 VM_TRACE(ZEND_YIELD_SPEC_VAR_CV)
62296 ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62297 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CV)
62298 HYBRID_BREAK();
62299 HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED):
62300 VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
62301 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62302 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
62303 HYBRID_BREAK();
62304 HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED):
62305 VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
62306 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62307 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
62308 HYBRID_BREAK();
62309 HYBRID_CASE(ZEND_CLONE_SPEC_UNUSED):
62310 VM_TRACE(ZEND_CLONE_SPEC_UNUSED)
62311 ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62312 VM_TRACE_OP_END(ZEND_CLONE_SPEC_UNUSED)
62313 HYBRID_BREAK();
62314 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED):
62315 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
62316 ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62317 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
62318 HYBRID_BREAK();
62319 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST):
62320 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
62321 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62322 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
62323 HYBRID_BREAK();
62324 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST):
62325 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
62326 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62327 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
62328 HYBRID_BREAK();
62329 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST):
62330 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
62331 ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62332 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
62333 HYBRID_BREAK();
62334 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST):
62335 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
62336 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62337 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
62338 HYBRID_BREAK();
62339 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST):
62340 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
62341 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62342 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
62343 HYBRID_BREAK();
62344 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST):
62345 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
62346 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62347 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
62348 HYBRID_BREAK();
62349 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST):
62350 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
62351 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62352 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
62353 HYBRID_BREAK();
62354 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST):
62355 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
62356 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62357 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
62358 HYBRID_BREAK();
62359 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST):
62360 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
62361 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62362 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
62363 HYBRID_BREAK();
62364 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST):
62365 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
62366 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62367 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
62368 HYBRID_BREAK();
62369 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP):
62370 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
62371 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62372 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
62373 HYBRID_BREAK();
62374 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR):
62375 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
62376 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62377 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
62378 HYBRID_BREAK();
62379 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV):
62380 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
62381 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62382 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
62383 HYBRID_BREAK();
62384 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR):
62385 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
62386 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62387 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
62388 HYBRID_BREAK();
62389 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV):
62390 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
62391 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62392 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
62393 HYBRID_BREAK();
62394 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST):
62395 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
62396 ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62397 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
62398 HYBRID_BREAK();
62399 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST):
62400 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
62401 ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62402 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
62403 HYBRID_BREAK();
62404 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST):
62405 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
62406 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62407 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
62408 HYBRID_BREAK();
62409 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST):
62410 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
62411 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62412 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
62413 HYBRID_BREAK();
62414 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST):
62415 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
62416 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62417 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
62418 HYBRID_BREAK();
62419 HYBRID_CASE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST):
62420 VM_TRACE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
62421 ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62422 VM_TRACE_OP_END(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
62423 HYBRID_BREAK();
62424 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST):
62425 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
62426 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62427 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
62428 HYBRID_BREAK();
62429 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST):
62430 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
62431 ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62432 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
62433 HYBRID_BREAK();
62434 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST):
62435 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
62436 ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62437 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
62438 HYBRID_BREAK();
62439 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST):
62440 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
62441 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62442 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
62443 HYBRID_BREAK();
62444 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CONST):
62445 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CONST)
62446 ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62447 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CONST)
62448 HYBRID_BREAK();
62449 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV):
62450 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
62451 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62452 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
62453 HYBRID_BREAK();
62454 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR):
62455 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
62456 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62457 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
62458 HYBRID_BREAK();
62459 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR):
62460 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
62461 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62462 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
62463 HYBRID_BREAK();
62464 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR):
62465 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
62466 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62467 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
62468 HYBRID_BREAK();
62469 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR):
62470 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
62471 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62472 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
62473 HYBRID_BREAK();
62474 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR):
62475 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
62476 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62477 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
62478 HYBRID_BREAK();
62479 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR):
62480 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
62481 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62482 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
62483 HYBRID_BREAK();
62484 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR):
62485 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
62486 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62487 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
62488 HYBRID_BREAK();
62489 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR):
62490 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
62491 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62492 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
62493 HYBRID_BREAK();
62494 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR):
62495 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
62496 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62497 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
62498 HYBRID_BREAK();
62499 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST):
62500 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
62501 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62502 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
62503 HYBRID_BREAK();
62504 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP):
62505 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
62506 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62507 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
62508 HYBRID_BREAK();
62509 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
62510 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62511 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62512 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62513 HYBRID_BREAK();
62514 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
62515 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62516 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62517 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62518 HYBRID_BREAK();
62519 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
62520 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62521 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62522 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
62523 HYBRID_BREAK();
62524 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
62525 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62526 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62527 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
62528 HYBRID_BREAK();
62529 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR):
62530 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
62531 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62532 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
62533 HYBRID_BREAK();
62534 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR):
62535 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
62536 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62537 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
62538 HYBRID_BREAK();
62539 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR):
62540 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62541 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62542 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62543 HYBRID_BREAK();
62544 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR):
62545 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62546 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62547 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
62548 HYBRID_BREAK();
62549 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR):
62550 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
62551 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62552 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
62553 HYBRID_BREAK();
62554 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR):
62555 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
62556 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62557 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
62558 HYBRID_BREAK();
62559 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR):
62560 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
62561 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62562 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
62563 HYBRID_BREAK();
62564 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_TMPVAR):
62565 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
62566 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62567 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
62568 HYBRID_BREAK();
62569 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED):
62570 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
62571 ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62572 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
62573 HYBRID_BREAK();
62574 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED):
62575 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
62576 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62577 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
62578 HYBRID_BREAK();
62579 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED):
62580 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
62581 ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62582 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
62583 HYBRID_BREAK();
62584 HYBRID_CASE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED):
62585 VM_TRACE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
62586 ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62587 VM_TRACE_OP_END(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
62588 HYBRID_BREAK();
62589 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED):
62590 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
62591 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62592 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
62593 HYBRID_BREAK();
62594 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK):
62595 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
62596 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62597 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
62598 HYBRID_BREAK();
62599 HYBRID_CASE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED):
62600 VM_TRACE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
62601 ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62602 VM_TRACE_OP_END(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
62603 HYBRID_BREAK();
62604 HYBRID_CASE(ZEND_NEW_SPEC_UNUSED_UNUSED):
62605 VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED)
62606 ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62607 VM_TRACE_OP_END(ZEND_NEW_SPEC_UNUSED_UNUSED)
62608 HYBRID_BREAK();
62609 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED):
62610 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
62611 ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62612 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
62613 HYBRID_BREAK();
62614 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_UNUSED):
62615 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_UNUSED)
62616 ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62617 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_UNUSED)
62618 HYBRID_BREAK();
62619 HYBRID_CASE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED):
62620 VM_TRACE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
62621 ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62622 VM_TRACE_OP_END(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
62623 HYBRID_BREAK();
62624 HYBRID_CASE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED):
62625 VM_TRACE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
62626 ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62627 VM_TRACE_OP_END(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
62628 HYBRID_BREAK();
62629 HYBRID_CASE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED):
62630 VM_TRACE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
62631 ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62632 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
62633 HYBRID_BREAK();
62634 HYBRID_CASE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED):
62635 VM_TRACE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
62636 ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62637 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
62638 HYBRID_BREAK();
62639 HYBRID_CASE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED):
62640 VM_TRACE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
62641 ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62642 VM_TRACE_OP_END(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
62643 HYBRID_BREAK();
62644 HYBRID_CASE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED):
62645 VM_TRACE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
62646 ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62647 VM_TRACE_OP_END(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
62648 HYBRID_BREAK();
62649 HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED):
62650 VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
62651 ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62652 VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
62653 HYBRID_BREAK();
62654 HYBRID_CASE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED):
62655 VM_TRACE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
62656 ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62657 VM_TRACE_OP_END(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
62658 HYBRID_BREAK();
62659 HYBRID_CASE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED):
62660 VM_TRACE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
62661 ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62662 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
62663 HYBRID_BREAK();
62664 HYBRID_CASE(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER):
62665 VM_TRACE(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER)
62666 ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62667 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER)
62668 HYBRID_BREAK();
62669 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV):
62670 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
62671 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62672 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
62673 HYBRID_BREAK();
62674 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV):
62675 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
62676 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62677 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
62678 HYBRID_BREAK();
62679 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV):
62680 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
62681 ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62682 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
62683 HYBRID_BREAK();
62684 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV):
62685 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
62686 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62687 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
62688 HYBRID_BREAK();
62689 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV):
62690 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
62691 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62692 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
62693 HYBRID_BREAK();
62694 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV):
62695 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
62696 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62697 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
62698 HYBRID_BREAK();
62699 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV):
62700 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
62701 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62702 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
62703 HYBRID_BREAK();
62704 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV):
62705 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
62706 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62707 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
62708 HYBRID_BREAK();
62709 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV):
62710 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
62711 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62712 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
62713 HYBRID_BREAK();
62714 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST):
62715 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
62716 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62717 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
62718 HYBRID_BREAK();
62719 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP):
62720 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
62721 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62722 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
62723 HYBRID_BREAK();
62724 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR):
62725 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
62726 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62727 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
62728 HYBRID_BREAK();
62729 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV):
62730 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
62731 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62732 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
62733 HYBRID_BREAK();
62734 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR):
62735 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
62736 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62737 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
62738 HYBRID_BREAK();
62739 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV):
62740 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
62741 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62742 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
62743 HYBRID_BREAK();
62744 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CV):
62745 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
62746 ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62747 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
62748 HYBRID_BREAK();
62749 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV):
62750 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
62751 ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62752 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
62753 HYBRID_BREAK();
62754 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV):
62755 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
62756 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62757 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
62758 HYBRID_BREAK();
62759 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV):
62760 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
62761 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62762 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
62763 HYBRID_BREAK();
62764 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV):
62765 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
62766 ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62767 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
62768 HYBRID_BREAK();
62769 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV):
62770 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
62771 ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62772 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
62773 HYBRID_BREAK();
62774 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV):
62775 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
62776 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62777 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
62778 HYBRID_BREAK();
62779 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CV):
62780 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CV)
62781 ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62782 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CV)
62783 HYBRID_BREAK();
62784 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CV):
62785 VM_TRACE(ZEND_BOOL_NOT_SPEC_CV)
62786 ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62787 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CV)
62788 HYBRID_BREAK();
62789 HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED):
62790 VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
62791 ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62792 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
62793 HYBRID_BREAK();
62794 HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED):
62795 VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
62796 ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62797 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
62798 HYBRID_BREAK();
62799 HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED):
62800 VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
62801 ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62802 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
62803 HYBRID_BREAK();
62804 HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED):
62805 VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
62806 ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62807 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
62808 HYBRID_BREAK();
62809 HYBRID_CASE(ZEND_POST_INC_SPEC_CV):
62810 VM_TRACE(ZEND_POST_INC_SPEC_CV)
62811 ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62812 VM_TRACE_OP_END(ZEND_POST_INC_SPEC_CV)
62813 HYBRID_BREAK();
62814 HYBRID_CASE(ZEND_POST_DEC_SPEC_CV):
62815 VM_TRACE(ZEND_POST_DEC_SPEC_CV)
62816 ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62817 VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_CV)
62818 HYBRID_BREAK();
62819 HYBRID_CASE(ZEND_ECHO_SPEC_CV):
62820 VM_TRACE(ZEND_ECHO_SPEC_CV)
62821 ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62822 VM_TRACE_OP_END(ZEND_ECHO_SPEC_CV)
62823 HYBRID_BREAK();
62824 HYBRID_CASE(ZEND_JMPZ_SPEC_CV):
62825 VM_TRACE(ZEND_JMPZ_SPEC_CV)
62826 ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62827 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CV)
62828 HYBRID_BREAK();
62829 HYBRID_CASE(ZEND_JMPNZ_SPEC_CV):
62830 VM_TRACE(ZEND_JMPNZ_SPEC_CV)
62831 ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62832 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CV)
62833 HYBRID_BREAK();
62834 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CV):
62835 VM_TRACE(ZEND_JMPZ_EX_SPEC_CV)
62836 ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62837 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CV)
62838 HYBRID_BREAK();
62839 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CV):
62840 VM_TRACE(ZEND_JMPNZ_EX_SPEC_CV)
62841 ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62842 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CV)
62843 HYBRID_BREAK();
62844 HYBRID_CASE(ZEND_RETURN_SPEC_CV):
62845 VM_TRACE(ZEND_RETURN_SPEC_CV)
62846 {
62847 USE_OPLINE
62848 zval *retval_ptr;
62849 zval *return_value;
62850
62851 retval_ptr = EX_VAR(opline->op1.var);
62852 return_value = EX(return_value);
62853
62854 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
62855 SAVE_OPLINE();
62856 retval_ptr = ZVAL_UNDEFINED_OP1();
62857 if (return_value) {
62858 ZVAL_NULL(return_value);
62859 }
62860 } else if (!return_value) {
62861 if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
62862 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
62863 SAVE_OPLINE();
62864 rc_dtor_func(Z_COUNTED_P(retval_ptr));
62865 }
62866 }
62867 } else {
62868 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
62869 ZVAL_COPY_VALUE(return_value, retval_ptr);
62870 if (IS_CV == IS_CONST) {
62871 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
62872 Z_ADDREF_P(return_value);
62873 }
62874 }
62875 } else if (IS_CV == IS_CV) {
62876 do {
62877 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
62878 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
62879 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
62880 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
62881 ZVAL_COPY_VALUE(return_value, retval_ptr);
62882 if (GC_MAY_LEAK(ref)) {
62883 SAVE_OPLINE();
62884 gc_possible_root(ref);
62885 }
62886 ZVAL_NULL(retval_ptr);
62887 break;
62888 } else {
62889 Z_ADDREF_P(retval_ptr);
62890 }
62891 } else {
62892 retval_ptr = Z_REFVAL_P(retval_ptr);
62893 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
62894 Z_ADDREF_P(retval_ptr);
62895 }
62896 }
62897 }
62898 ZVAL_COPY_VALUE(return_value, retval_ptr);
62899 } while (0);
62900 } else /* if (IS_CV == IS_VAR) */ {
62901 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
62902 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
62903
62904 retval_ptr = Z_REFVAL_P(retval_ptr);
62905 ZVAL_COPY_VALUE(return_value, retval_ptr);
62906 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
62907 efree_size(ref, sizeof(zend_reference));
62908 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
62909 Z_ADDREF_P(retval_ptr);
62910 }
62911 } else {
62912 ZVAL_COPY_VALUE(return_value, retval_ptr);
62913 }
62914 }
62915 }
62916
62917
62918
62919 goto zend_leave_helper_SPEC_LABEL;
62920 }
62921
62922 VM_TRACE_OP_END(ZEND_RETURN_SPEC_CV)
62923 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CV):
62924 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CV)
62925 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62926 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CV)
62927 HYBRID_BREAK();
62928 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CV):
62929 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CV)
62930 ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62931 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CV)
62932 HYBRID_BREAK();
62933 HYBRID_CASE(ZEND_THROW_SPEC_CV):
62934 VM_TRACE(ZEND_THROW_SPEC_CV)
62935 ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62936 VM_TRACE_OP_END(ZEND_THROW_SPEC_CV)
62937 HYBRID_BREAK();
62938 HYBRID_CASE(ZEND_SEND_USER_SPEC_CV):
62939 VM_TRACE(ZEND_SEND_USER_SPEC_CV)
62940 ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62941 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV)
62942 HYBRID_BREAK();
62943 HYBRID_CASE(ZEND_BOOL_SPEC_CV):
62944 VM_TRACE(ZEND_BOOL_SPEC_CV)
62945 ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62946 VM_TRACE_OP_END(ZEND_BOOL_SPEC_CV)
62947 HYBRID_BREAK();
62948 HYBRID_CASE(ZEND_CLONE_SPEC_CV):
62949 VM_TRACE(ZEND_CLONE_SPEC_CV)
62950 ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62951 VM_TRACE_OP_END(ZEND_CLONE_SPEC_CV)
62952 HYBRID_BREAK();
62953 HYBRID_CASE(ZEND_CAST_SPEC_CV):
62954 VM_TRACE(ZEND_CAST_SPEC_CV)
62955 ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62956 VM_TRACE_OP_END(ZEND_CAST_SPEC_CV)
62957 HYBRID_BREAK();
62958 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CV):
62959 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
62960 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62961 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
62962 HYBRID_BREAK();
62963 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CV):
62964 VM_TRACE(ZEND_FE_RESET_R_SPEC_CV)
62965 ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62966 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CV)
62967 HYBRID_BREAK();
62968 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CV):
62969 VM_TRACE(ZEND_FE_RESET_RW_SPEC_CV)
62970 ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62971 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CV)
62972 HYBRID_BREAK();
62973 HYBRID_CASE(ZEND_JMP_SET_SPEC_CV):
62974 VM_TRACE(ZEND_JMP_SET_SPEC_CV)
62975 ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62976 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CV)
62977 HYBRID_BREAK();
62978 HYBRID_CASE(ZEND_COALESCE_SPEC_CV):
62979 VM_TRACE(ZEND_COALESCE_SPEC_CV)
62980 ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62981 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CV)
62982 HYBRID_BREAK();
62983 HYBRID_CASE(ZEND_JMP_NULL_SPEC_CV):
62984 VM_TRACE(ZEND_JMP_NULL_SPEC_CV)
62985 ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62986 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CV)
62987 HYBRID_BREAK();
62988 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CV):
62989 VM_TRACE(ZEND_QM_ASSIGN_SPEC_CV)
62990 ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62991 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CV)
62992 HYBRID_BREAK();
62993 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CV):
62994 VM_TRACE(ZEND_YIELD_FROM_SPEC_CV)
62995 ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62996 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CV)
62997 HYBRID_BREAK();
62998 HYBRID_CASE(ZEND_STRLEN_SPEC_CV):
62999 VM_TRACE(ZEND_STRLEN_SPEC_CV)
63000 ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63001 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CV)
63002 HYBRID_BREAK();
63003 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CV):
63004 VM_TRACE(ZEND_TYPE_CHECK_SPEC_CV)
63005 ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63006 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CV)
63007 HYBRID_BREAK();
63008 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_CV):
63009 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_CV)
63010 ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63011 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_CV)
63012 HYBRID_BREAK();
63013 HYBRID_CASE(ZEND_BIND_STATIC_SPEC_CV):
63014 VM_TRACE(ZEND_BIND_STATIC_SPEC_CV)
63015 ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63016 VM_TRACE_OP_END(ZEND_BIND_STATIC_SPEC_CV)
63017 HYBRID_BREAK();
63018 HYBRID_CASE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV):
63019 VM_TRACE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
63020 ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63021 VM_TRACE_OP_END(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
63022 HYBRID_BREAK();
63023 HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
63024 VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63025 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63026 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63027 HYBRID_BREAK();
63028 HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
63029 VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63030 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63031 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63032 HYBRID_BREAK();
63033 HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED):
63034 VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
63035 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63036 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
63037 HYBRID_BREAK();
63038 HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED):
63039 VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
63040 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63041 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
63042 HYBRID_BREAK();
63043 HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
63044 VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63045 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63046 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
63047 HYBRID_BREAK();
63048 HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
63049 VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63050 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63051 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
63052 HYBRID_BREAK();
63053 HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED):
63054 VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
63055 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63056 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
63057 HYBRID_BREAK();
63058 HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED):
63059 VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
63060 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63061 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
63062 HYBRID_BREAK();
63063 HYBRID_CASE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV):
63064 VM_TRACE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
63065 ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63066 VM_TRACE_OP_END(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
63067 HYBRID_BREAK();
63068 HYBRID_CASE(ZEND_POST_INC_LONG_SPEC_CV):
63069 VM_TRACE(ZEND_POST_INC_LONG_SPEC_CV)
63070 ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63071 VM_TRACE_OP_END(ZEND_POST_INC_LONG_SPEC_CV)
63072 HYBRID_BREAK();
63073 HYBRID_CASE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV):
63074 VM_TRACE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
63075 ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63076 VM_TRACE_OP_END(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
63077 HYBRID_BREAK();
63078 HYBRID_CASE(ZEND_POST_DEC_LONG_SPEC_CV):
63079 VM_TRACE(ZEND_POST_DEC_LONG_SPEC_CV)
63080 ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63081 VM_TRACE_OP_END(ZEND_POST_DEC_LONG_SPEC_CV)
63082 HYBRID_BREAK();
63083 HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_CV):
63084 VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
63085 ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63086 VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
63087 HYBRID_BREAK();
63088 HYBRID_CASE(ZEND_DIV_SPEC_CV_CONST):
63089 VM_TRACE(ZEND_DIV_SPEC_CV_CONST)
63090 ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63091 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CONST)
63092 HYBRID_BREAK();
63093 HYBRID_CASE(ZEND_POW_SPEC_CV_CONST):
63094 VM_TRACE(ZEND_POW_SPEC_CV_CONST)
63095 ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63096 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CONST)
63097 HYBRID_BREAK();
63098 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CONST):
63099 VM_TRACE(ZEND_CONCAT_SPEC_CV_CONST)
63100 ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63101 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CONST)
63102 HYBRID_BREAK();
63103 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CONST):
63104 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
63105 ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63106 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
63107 HYBRID_BREAK();
63108 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST):
63109 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
63110 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63111 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
63112 HYBRID_BREAK();
63113 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST):
63114 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST)
63115 ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63116 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST)
63117 HYBRID_BREAK();
63118 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ):
63119 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
63120 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63121 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
63122 HYBRID_BREAK();
63123 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ):
63124 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
63125 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63126 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
63127 HYBRID_BREAK();
63128 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST):
63129 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
63130 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63131 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
63132 HYBRID_BREAK();
63133 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ):
63134 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
63135 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63136 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
63137 HYBRID_BREAK();
63138 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ):
63139 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
63140 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63141 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
63142 HYBRID_BREAK();
63143 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CONST):
63144 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CONST)
63145 ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63146 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CONST)
63147 HYBRID_BREAK();
63148 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CONST):
63149 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CONST)
63150 ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63151 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CONST)
63152 HYBRID_BREAK();
63153 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST):
63154 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
63155 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63156 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
63157 HYBRID_BREAK();
63158 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST):
63159 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
63160 ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63161 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
63162 HYBRID_BREAK();
63163 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CONST):
63164 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CONST)
63165 ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63166 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CONST)
63167 HYBRID_BREAK();
63168 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST):
63169 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
63170 ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63171 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
63172 HYBRID_BREAK();
63173 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CONST):
63174 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
63175 ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63176 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
63177 HYBRID_BREAK();
63178 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CONST):
63179 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
63180 ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63181 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
63182 HYBRID_BREAK();
63183 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CONST):
63184 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
63185 ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63186 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
63187 HYBRID_BREAK();
63188 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST):
63189 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
63190 ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63191 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
63192 HYBRID_BREAK();
63193 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST):
63194 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
63195 ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63196 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
63197 HYBRID_BREAK();
63198 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST):
63199 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
63200 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63201 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
63202 HYBRID_BREAK();
63203 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST):
63204 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
63205 ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63206 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
63207 HYBRID_BREAK();
63208 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST):
63209 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
63210 ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63211 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
63212 HYBRID_BREAK();
63213 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST):
63214 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
63215 ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63216 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
63217 HYBRID_BREAK();
63218 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST):
63219 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
63220 ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63221 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
63222 HYBRID_BREAK();
63223 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST):
63224 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
63225 ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63226 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
63227 HYBRID_BREAK();
63228 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST):
63229 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
63230 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63231 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
63232 HYBRID_BREAK();
63233 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST):
63234 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
63235 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63236 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
63237 HYBRID_BREAK();
63238 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST):
63239 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
63240 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63241 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
63242 HYBRID_BREAK();
63243 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP):
63244 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
63245 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63246 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
63247 HYBRID_BREAK();
63248 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR):
63249 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
63250 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63251 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
63252 HYBRID_BREAK();
63253 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV):
63254 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
63255 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63256 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
63257 HYBRID_BREAK();
63258 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST):
63259 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
63260 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63261 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
63262 HYBRID_BREAK();
63263 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP):
63264 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
63265 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63266 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
63267 HYBRID_BREAK();
63268 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR):
63269 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
63270 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63271 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
63272 HYBRID_BREAK();
63273 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV):
63274 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
63275 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63276 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
63277 HYBRID_BREAK();
63278 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED):
63279 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
63280 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63281 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
63282 HYBRID_BREAK();
63283 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED):
63284 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
63285 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63286 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
63287 HYBRID_BREAK();
63288 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR):
63289 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
63290 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63291 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
63292 HYBRID_BREAK();
63293 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV):
63294 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
63295 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63296 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
63297 HYBRID_BREAK();
63298 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CONST):
63299 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CONST)
63300 ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63301 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CONST)
63302 HYBRID_BREAK();
63303 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST):
63304 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
63305 ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63306 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
63307 HYBRID_BREAK();
63308 HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_CONST):
63309 VM_TRACE(ZEND_SEND_VAR_SPEC_CV_CONST)
63310 ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63311 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_CONST)
63312 HYBRID_BREAK();
63313 HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_CONST):
63314 VM_TRACE(ZEND_SEND_REF_SPEC_CV_CONST)
63315 ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63316 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_CONST)
63317 HYBRID_BREAK();
63318 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_CONST):
63319 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
63320 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63321 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
63322 HYBRID_BREAK();
63323 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST):
63324 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
63325 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63326 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
63327 HYBRID_BREAK();
63328 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CONST):
63329 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CONST)
63330 ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63331 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CONST)
63332 HYBRID_BREAK();
63333 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CONST):
63334 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CONST)
63335 ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63336 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CONST)
63337 HYBRID_BREAK();
63338 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CONST):
63339 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CONST)
63340 ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63341 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CONST)
63342 HYBRID_BREAK();
63343 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST):
63344 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
63345 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63346 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
63347 HYBRID_BREAK();
63348 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST):
63349 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
63350 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63351 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
63352 HYBRID_BREAK();
63353 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST):
63354 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
63355 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63356 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
63357 HYBRID_BREAK();
63358 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_CONST):
63359 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_CONST)
63360 ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63361 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_CONST)
63362 HYBRID_BREAK();
63363 HYBRID_CASE(ZEND_YIELD_SPEC_CV_CONST):
63364 VM_TRACE(ZEND_YIELD_SPEC_CV_CONST)
63365 ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63366 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CONST)
63367 HYBRID_BREAK();
63368 HYBRID_CASE(ZEND_BIND_GLOBAL_SPEC_CV_CONST):
63369 VM_TRACE(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
63370 ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63371 VM_TRACE_OP_END(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
63372 HYBRID_BREAK();
63373 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CV_CONST):
63374 VM_TRACE(ZEND_IN_ARRAY_SPEC_CV_CONST)
63375 ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63376 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CV_CONST)
63377 HYBRID_BREAK();
63378 HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST):
63379 VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63380 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63381 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63382 HYBRID_BREAK();
63383 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST):
63384 VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63385 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63386 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
63387 HYBRID_BREAK();
63388 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST):
63389 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
63390 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63391 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
63392 HYBRID_BREAK();
63393 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV):
63394 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
63395 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63396 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
63397 HYBRID_BREAK();
63398 HYBRID_CASE(ZEND_DIV_SPEC_CV_TMPVAR):
63399 VM_TRACE(ZEND_DIV_SPEC_CV_TMPVAR)
63400 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63401 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_TMPVAR)
63402 HYBRID_BREAK();
63403 HYBRID_CASE(ZEND_POW_SPEC_CV_TMPVAR):
63404 VM_TRACE(ZEND_POW_SPEC_CV_TMPVAR)
63405 ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63406 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_TMPVAR)
63407 HYBRID_BREAK();
63408 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_TMPVAR):
63409 VM_TRACE(ZEND_CONCAT_SPEC_CV_TMPVAR)
63410 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63411 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_TMPVAR)
63412 HYBRID_BREAK();
63413 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR):
63414 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
63415 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63416 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
63417 HYBRID_BREAK();
63418 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ):
63419 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63420 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63421 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63422 HYBRID_BREAK();
63423 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
63424 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63425 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63426 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63427 HYBRID_BREAK();
63428 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR):
63429 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
63430 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63431 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
63432 HYBRID_BREAK();
63433 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ):
63434 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63435 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63436 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
63437 HYBRID_BREAK();
63438 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
63439 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63440 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63441 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
63442 HYBRID_BREAK();
63443 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_TMPVAR):
63444 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
63445 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63446 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
63447 HYBRID_BREAK();
63448 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR):
63449 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
63450 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63451 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
63452 HYBRID_BREAK();
63453 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR):
63454 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
63455 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63456 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
63457 HYBRID_BREAK();
63458 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR):
63459 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
63460 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63461 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
63462 HYBRID_BREAK();
63463 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR):
63464 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
63465 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63466 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
63467 HYBRID_BREAK();
63468 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR):
63469 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
63470 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63471 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
63472 HYBRID_BREAK();
63473 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR):
63474 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
63475 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63476 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
63477 HYBRID_BREAK();
63478 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR):
63479 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
63480 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63481 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
63482 HYBRID_BREAK();
63483 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR):
63484 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
63485 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63486 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
63487 HYBRID_BREAK();
63488 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR):
63489 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
63490 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63491 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
63492 HYBRID_BREAK();
63493 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR):
63494 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
63495 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63496 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
63497 HYBRID_BREAK();
63498 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR):
63499 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
63500 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63501 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
63502 HYBRID_BREAK();
63503 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR):
63504 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
63505 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63506 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
63507 HYBRID_BREAK();
63508 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR):
63509 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
63510 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63511 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
63512 HYBRID_BREAK();
63513 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR):
63514 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
63515 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63516 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
63517 HYBRID_BREAK();
63518 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR):
63519 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
63520 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63521 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
63522 HYBRID_BREAK();
63523 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR):
63524 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
63525 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63526 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
63527 HYBRID_BREAK();
63528 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR):
63529 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
63530 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63531 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
63532 HYBRID_BREAK();
63533 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR):
63534 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
63535 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63536 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
63537 HYBRID_BREAK();
63538 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST):
63539 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
63540 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63541 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
63542 HYBRID_BREAK();
63543 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP):
63544 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
63545 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63546 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
63547 HYBRID_BREAK();
63548 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR):
63549 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
63550 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63551 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
63552 HYBRID_BREAK();
63553 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV):
63554 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
63555 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63556 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
63557 HYBRID_BREAK();
63558 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST):
63559 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
63560 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63561 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
63562 HYBRID_BREAK();
63563 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP):
63564 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
63565 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63566 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
63567 HYBRID_BREAK();
63568 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR):
63569 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
63570 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63571 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
63572 HYBRID_BREAK();
63573 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV):
63574 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
63575 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63576 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
63577 HYBRID_BREAK();
63578 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR):
63579 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
63580 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63581 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
63582 HYBRID_BREAK();
63583 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV):
63584 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
63585 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63586 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
63587 HYBRID_BREAK();
63588 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR):
63589 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
63590 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63591 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
63592 HYBRID_BREAK();
63593 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR):
63594 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
63595 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63596 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
63597 HYBRID_BREAK();
63598 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR):
63599 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
63600 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63601 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
63602 HYBRID_BREAK();
63603 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR):
63604 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
63605 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63606 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
63607 HYBRID_BREAK();
63608 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR):
63609 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
63610 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63611 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
63612 HYBRID_BREAK();
63613 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR):
63614 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
63615 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63616 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
63617 HYBRID_BREAK();
63618 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR):
63619 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
63620 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63621 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
63622 HYBRID_BREAK();
63623 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR):
63624 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
63625 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63626 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
63627 HYBRID_BREAK();
63628 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR):
63629 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
63630 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63631 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
63632 HYBRID_BREAK();
63633 HYBRID_CASE(ZEND_YIELD_SPEC_CV_TMPVAR):
63634 VM_TRACE(ZEND_YIELD_SPEC_CV_TMPVAR)
63635 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63636 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_TMPVAR)
63637 HYBRID_BREAK();
63638 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_TMP):
63639 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
63640 ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63641 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
63642 HYBRID_BREAK();
63643 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP):
63644 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
63645 ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63646 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
63647 HYBRID_BREAK();
63648 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED):
63649 VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
63650 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63651 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
63652 HYBRID_BREAK();
63653 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED):
63654 VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
63655 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63656 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
63657 HYBRID_BREAK();
63658 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_VAR):
63659 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
63660 ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63661 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
63662 HYBRID_BREAK();
63663 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR):
63664 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
63665 ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63666 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
63667 HYBRID_BREAK();
63668 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED):
63669 VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
63670 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63671 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
63672 HYBRID_BREAK();
63673 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED):
63674 VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
63675 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63676 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
63677 HYBRID_BREAK();
63678 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_VAR):
63679 VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_VAR)
63680 ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63681 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_VAR)
63682 HYBRID_BREAK();
63683 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_VAR):
63684 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_VAR)
63685 ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63686 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_VAR)
63687 HYBRID_BREAK();
63688 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED):
63689 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
63690 ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63691 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
63692 HYBRID_BREAK();
63693 HYBRID_CASE(ZEND_FETCH_R_SPEC_CV_UNUSED):
63694 VM_TRACE(ZEND_FETCH_R_SPEC_CV_UNUSED)
63695 ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63696 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CV_UNUSED)
63697 HYBRID_BREAK();
63698 HYBRID_CASE(ZEND_FETCH_W_SPEC_CV_UNUSED):
63699 VM_TRACE(ZEND_FETCH_W_SPEC_CV_UNUSED)
63700 ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63701 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CV_UNUSED)
63702 HYBRID_BREAK();
63703 HYBRID_CASE(ZEND_FETCH_RW_SPEC_CV_UNUSED):
63704 VM_TRACE(ZEND_FETCH_RW_SPEC_CV_UNUSED)
63705 ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63706 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CV_UNUSED)
63707 HYBRID_BREAK();
63708 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED):
63709 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
63710 ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63711 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
63712 HYBRID_BREAK();
63713 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED):
63714 VM_TRACE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
63715 ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63716 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
63717 HYBRID_BREAK();
63718 HYBRID_CASE(ZEND_FETCH_IS_SPEC_CV_UNUSED):
63719 VM_TRACE(ZEND_FETCH_IS_SPEC_CV_UNUSED)
63720 ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63721 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CV_UNUSED)
63722 HYBRID_BREAK();
63723 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED):
63724 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
63725 ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63726 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
63727 HYBRID_BREAK();
63728 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED):
63729 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
63730 ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63731 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
63732 HYBRID_BREAK();
63733 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED):
63734 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
63735 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63736 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
63737 HYBRID_BREAK();
63738 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST):
63739 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
63740 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63741 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
63742 HYBRID_BREAK();
63743 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP):
63744 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
63745 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63746 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
63747 HYBRID_BREAK();
63748 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR):
63749 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
63750 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63751 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
63752 HYBRID_BREAK();
63753 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV):
63754 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
63755 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63756 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
63757 HYBRID_BREAK();
63758 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED):
63759 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
63760 ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63761 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
63762 HYBRID_BREAK();
63763 HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_UNUSED):
63764 VM_TRACE(ZEND_SEND_VAR_SPEC_CV_UNUSED)
63765 ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63766 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_UNUSED)
63767 HYBRID_BREAK();
63768 HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_UNUSED):
63769 VM_TRACE(ZEND_SEND_REF_SPEC_CV_UNUSED)
63770 ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63771 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_UNUSED)
63772 HYBRID_BREAK();
63773 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED):
63774 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
63775 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63776 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
63777 HYBRID_BREAK();
63778 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK):
63779 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
63780 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63781 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
63782 HYBRID_BREAK();
63783 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED):
63784 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
63785 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63786 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
63787 HYBRID_BREAK();
63788 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED):
63789 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
63790 ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63791 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
63792 HYBRID_BREAK();
63793 HYBRID_CASE(ZEND_UNSET_CV_SPEC_CV_UNUSED):
63794 VM_TRACE(ZEND_UNSET_CV_SPEC_CV_UNUSED)
63795 ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63796 VM_TRACE_OP_END(ZEND_UNSET_CV_SPEC_CV_UNUSED)
63797 HYBRID_BREAK();
63798 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CV_UNUSED):
63799 VM_TRACE(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
63800 ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63801 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
63802 HYBRID_BREAK();
63803 HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET):
63804 VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
63805 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63806 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
63807 HYBRID_BREAK();
63808 HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY):
63809 VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
63810 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63811 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
63812 HYBRID_BREAK();
63813 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED):
63814 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
63815 ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63816 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
63817 HYBRID_BREAK();
63818 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_UNUSED):
63819 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
63820 ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63821 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
63822 HYBRID_BREAK();
63823 HYBRID_CASE(ZEND_YIELD_SPEC_CV_UNUSED):
63824 VM_TRACE(ZEND_YIELD_SPEC_CV_UNUSED)
63825 ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63826 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_UNUSED)
63827 HYBRID_BREAK();
63828 HYBRID_CASE(ZEND_CHECK_VAR_SPEC_CV_UNUSED):
63829 VM_TRACE(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
63830 ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63831 VM_TRACE_OP_END(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
63832 HYBRID_BREAK();
63833 HYBRID_CASE(ZEND_MAKE_REF_SPEC_CV_UNUSED):
63834 VM_TRACE(ZEND_MAKE_REF_SPEC_CV_UNUSED)
63835 ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63836 VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_CV_UNUSED)
63837 HYBRID_BREAK();
63838 HYBRID_CASE(ZEND_COUNT_SPEC_CV_UNUSED):
63839 VM_TRACE(ZEND_COUNT_SPEC_CV_UNUSED)
63840 ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63841 VM_TRACE_OP_END(ZEND_COUNT_SPEC_CV_UNUSED)
63842 HYBRID_BREAK();
63843 HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED):
63844 VM_TRACE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
63845 ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63846 VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
63847 HYBRID_BREAK();
63848 HYBRID_CASE(ZEND_GET_CLASS_SPEC_CV_UNUSED):
63849 VM_TRACE(ZEND_GET_CLASS_SPEC_CV_UNUSED)
63850 ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63851 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CV_UNUSED)
63852 HYBRID_BREAK();
63853 HYBRID_CASE(ZEND_GET_TYPE_SPEC_CV_UNUSED):
63854 VM_TRACE(ZEND_GET_TYPE_SPEC_CV_UNUSED)
63855 ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63856 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CV_UNUSED)
63857 HYBRID_BREAK();
63858 HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED):
63859 VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
63860 ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63861 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
63862 HYBRID_BREAK();
63863 HYBRID_CASE(ZEND_DIV_SPEC_CV_CV):
63864 VM_TRACE(ZEND_DIV_SPEC_CV_CV)
63865 ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63866 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CV)
63867 HYBRID_BREAK();
63868 HYBRID_CASE(ZEND_POW_SPEC_CV_CV):
63869 VM_TRACE(ZEND_POW_SPEC_CV_CV)
63870 ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63871 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CV)
63872 HYBRID_BREAK();
63873 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CV):
63874 VM_TRACE(ZEND_CONCAT_SPEC_CV_CV)
63875 ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63876 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CV)
63877 HYBRID_BREAK();
63878 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CV):
63879 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CV)
63880 ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63881 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CV)
63882 HYBRID_BREAK();
63883 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV):
63884 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
63885 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63886 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
63887 HYBRID_BREAK();
63888 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV):
63889 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV)
63890 ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63891 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV)
63892 HYBRID_BREAK();
63893 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ):
63894 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
63895 ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63896 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
63897 HYBRID_BREAK();
63898 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ):
63899 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
63900 ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63901 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
63902 HYBRID_BREAK();
63903 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV):
63904 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
63905 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63906 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
63907 HYBRID_BREAK();
63908 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ):
63909 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
63910 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63911 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
63912 HYBRID_BREAK();
63913 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ):
63914 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
63915 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63916 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
63917 HYBRID_BREAK();
63918 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CV):
63919 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CV)
63920 ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63921 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CV)
63922 HYBRID_BREAK();
63923 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CV):
63924 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CV)
63925 ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63926 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CV)
63927 HYBRID_BREAK();
63928 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV):
63929 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
63930 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63931 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
63932 HYBRID_BREAK();
63933 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV):
63934 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
63935 ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63936 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
63937 HYBRID_BREAK();
63938 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CV):
63939 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CV)
63940 ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63941 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CV)
63942 HYBRID_BREAK();
63943 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CV):
63944 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
63945 ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63946 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
63947 HYBRID_BREAK();
63948 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CV):
63949 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CV)
63950 ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63951 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CV)
63952 HYBRID_BREAK();
63953 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CV):
63954 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CV)
63955 ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63956 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CV)
63957 HYBRID_BREAK();
63958 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CV):
63959 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CV)
63960 ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63961 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CV)
63962 HYBRID_BREAK();
63963 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CV):
63964 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
63965 ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63966 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
63967 HYBRID_BREAK();
63968 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CV):
63969 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
63970 ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63971 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
63972 HYBRID_BREAK();
63973 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV):
63974 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
63975 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63976 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
63977 HYBRID_BREAK();
63978 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV):
63979 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
63980 ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63981 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
63982 HYBRID_BREAK();
63983 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CV):
63984 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
63985 ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63986 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
63987 HYBRID_BREAK();
63988 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CV):
63989 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
63990 ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63991 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
63992 HYBRID_BREAK();
63993 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV):
63994 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
63995 ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
63996 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
63997 HYBRID_BREAK();
63998 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV):
63999 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
64000 ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64001 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
64002 HYBRID_BREAK();
64003 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV):
64004 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
64005 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64006 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
64007 HYBRID_BREAK();
64008 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV):
64009 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
64010 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64011 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
64012 HYBRID_BREAK();
64013 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST):
64014 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
64015 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64016 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
64017 HYBRID_BREAK();
64018 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP):
64019 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
64020 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64021 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
64022 HYBRID_BREAK();
64023 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR):
64024 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
64025 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64026 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
64027 HYBRID_BREAK();
64028 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV):
64029 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
64030 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64031 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
64032 HYBRID_BREAK();
64033 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST):
64034 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
64035 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64036 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
64037 HYBRID_BREAK();
64038 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP):
64039 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
64040 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64041 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
64042 HYBRID_BREAK();
64043 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR):
64044 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
64045 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64046 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
64047 HYBRID_BREAK();
64048 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV):
64049 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
64050 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64051 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
64052 HYBRID_BREAK();
64053 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED):
64054 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
64055 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64056 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
64057 HYBRID_BREAK();
64058 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED):
64059 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
64060 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64061 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
64062 HYBRID_BREAK();
64063 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_CV):
64064 VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_CV)
64065 ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64066 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_CV)
64067 HYBRID_BREAK();
64068 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR):
64069 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
64070 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64071 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
64072 HYBRID_BREAK();
64073 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV):
64074 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
64075 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64076 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
64077 HYBRID_BREAK();
64078 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CV):
64079 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CV)
64080 ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64081 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CV)
64082 HYBRID_BREAK();
64083 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV):
64084 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
64085 ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64086 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
64087 HYBRID_BREAK();
64088 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV):
64089 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
64090 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64091 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
64092 HYBRID_BREAK();
64093 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CV):
64094 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CV)
64095 ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64096 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CV)
64097 HYBRID_BREAK();
64098 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CV):
64099 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CV)
64100 ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64101 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CV)
64102 HYBRID_BREAK();
64103 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CV):
64104 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CV)
64105 ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64106 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CV)
64107 HYBRID_BREAK();
64108 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV):
64109 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
64110 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64111 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
64112 HYBRID_BREAK();
64113 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV):
64114 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
64115 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64116 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
64117 HYBRID_BREAK();
64118 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV):
64119 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
64120 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64121 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
64122 HYBRID_BREAK();
64123 HYBRID_CASE(ZEND_YIELD_SPEC_CV_CV):
64124 VM_TRACE(ZEND_YIELD_SPEC_CV_CV)
64125 ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64126 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CV)
64127 HYBRID_BREAK();
64128 HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV):
64129 VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
64130 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64131 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
64132 HYBRID_BREAK();
64133 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV):
64134 VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
64135 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64136 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
64137 HYBRID_BREAK();
64138 HYBRID_CASE(HYBRID_HALT):
64139 #ifdef ZEND_VM_FP_GLOBAL_REG
64140 execute_data = vm_stack_data.orig_execute_data;
64141 #endif
64142 #ifdef ZEND_VM_IP_GLOBAL_REG
64143 opline = vm_stack_data.orig_opline;
64144 #endif
64145 return;
64146 HYBRID_DEFAULT:
64147 VM_TRACE(ZEND_NULL)
64148 ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
64149 VM_TRACE_OP_END(ZEND_NULL)
64150 HYBRID_BREAK(); /* Never reached */
64151 #else
64152 #ifdef ZEND_VM_FP_GLOBAL_REG
64153 execute_data = vm_stack_data.orig_execute_data;
64154 # ifdef ZEND_VM_IP_GLOBAL_REG
64155 opline = vm_stack_data.orig_opline;
64156 # endif
64157 return;
64158 #else
64159 if (EXPECTED(ret > 0)) {
64160 execute_data = EG(current_execute_data);
64161 ZEND_VM_LOOP_INTERRUPT_CHECK();
64162 } else {
64163 # ifdef ZEND_VM_IP_GLOBAL_REG
64164 opline = vm_stack_data.orig_opline;
64165 # endif
64166 return;
64167 }
64168 #endif
64169 #endif
64170 }
64171
64172 }
64173 zend_error_noreturn(E_CORE_ERROR, "Arrived at end of main loop which shouldn't happen");
64174 }
64175 #if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
64176 # pragma GCC pop_options
64177 #endif
64178
64179 ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value)
64180 {
64181 zend_execute_data *execute_data;
64182 void *object_or_called_scope;
64183 uint32_t call_info;
64184
64185 if (EG(exception) != NULL) {
64186 return;
64187 }
64188
64189 object_or_called_scope = zend_get_this_object(EG(current_execute_data));
64190 if (EXPECTED(!object_or_called_scope)) {
64191 object_or_called_scope = zend_get_called_scope(EG(current_execute_data));
64192 call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE;
64193 } else {
64194 call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE | ZEND_CALL_HAS_THIS;
64195 }
64196 execute_data = zend_vm_stack_push_call_frame(call_info,
64197 (zend_function*)op_array, 0, object_or_called_scope);
64198 if (EG(current_execute_data)) {
64199 execute_data->symbol_table = zend_rebuild_symbol_table();
64200 } else {
64201 execute_data->symbol_table = &EG(symbol_table);
64202 }
64203 EX(prev_execute_data) = EG(current_execute_data);
64204 i_init_code_execute_data(execute_data, op_array, return_value);
64205 ZEND_OBSERVER_FCALL_BEGIN(execute_data);
64206 zend_execute_ex(execute_data);
64207 /* Observer end handlers are called from ZEND_RETURN */
64208 zend_vm_stack_free_call_frame(execute_data);
64209 }
64210
64211
64212 void zend_vm_init(void)
64213 {
64214 static const void * const labels[] = {
64215 ZEND_NOP_SPEC_HANDLER,
64216 ZEND_ADD_SPEC_CONST_CONST_HANDLER,
64217 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64218 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64219 ZEND_NULL_HANDLER,
64220 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
64221 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64222 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64223 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64224 ZEND_NULL_HANDLER,
64225 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64226 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64227 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64228 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64229 ZEND_NULL_HANDLER,
64230 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64231 ZEND_NULL_HANDLER,
64232 ZEND_NULL_HANDLER,
64233 ZEND_NULL_HANDLER,
64234 ZEND_NULL_HANDLER,
64235 ZEND_NULL_HANDLER,
64236 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
64237 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64238 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64239 ZEND_NULL_HANDLER,
64240 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64241 ZEND_SUB_SPEC_CONST_CONST_HANDLER,
64242 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64243 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64244 ZEND_NULL_HANDLER,
64245 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
64246 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64247 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64248 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64249 ZEND_NULL_HANDLER,
64250 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64251 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64252 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64253 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64254 ZEND_NULL_HANDLER,
64255 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64256 ZEND_NULL_HANDLER,
64257 ZEND_NULL_HANDLER,
64258 ZEND_NULL_HANDLER,
64259 ZEND_NULL_HANDLER,
64260 ZEND_NULL_HANDLER,
64261 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
64262 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64263 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64264 ZEND_NULL_HANDLER,
64265 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64266 ZEND_MUL_SPEC_CONST_CONST_HANDLER,
64267 ZEND_NULL_HANDLER,
64268 ZEND_NULL_HANDLER,
64269 ZEND_NULL_HANDLER,
64270 ZEND_NULL_HANDLER,
64271 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64272 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64273 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64274 ZEND_NULL_HANDLER,
64275 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64276 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64277 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64278 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64279 ZEND_NULL_HANDLER,
64280 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64281 ZEND_NULL_HANDLER,
64282 ZEND_NULL_HANDLER,
64283 ZEND_NULL_HANDLER,
64284 ZEND_NULL_HANDLER,
64285 ZEND_NULL_HANDLER,
64286 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
64287 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64288 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64289 ZEND_NULL_HANDLER,
64290 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64291 ZEND_DIV_SPEC_CONST_CONST_HANDLER,
64292 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
64293 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
64294 ZEND_NULL_HANDLER,
64295 ZEND_DIV_SPEC_CONST_CV_HANDLER,
64296 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
64297 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64298 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64299 ZEND_NULL_HANDLER,
64300 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
64301 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
64302 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64303 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
64304 ZEND_NULL_HANDLER,
64305 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
64306 ZEND_NULL_HANDLER,
64307 ZEND_NULL_HANDLER,
64308 ZEND_NULL_HANDLER,
64309 ZEND_NULL_HANDLER,
64310 ZEND_NULL_HANDLER,
64311 ZEND_DIV_SPEC_CV_CONST_HANDLER,
64312 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
64313 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
64314 ZEND_NULL_HANDLER,
64315 ZEND_DIV_SPEC_CV_CV_HANDLER,
64316 ZEND_MOD_SPEC_CONST_CONST_HANDLER,
64317 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64318 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64319 ZEND_NULL_HANDLER,
64320 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
64321 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64322 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64323 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64324 ZEND_NULL_HANDLER,
64325 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64326 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64327 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64328 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64329 ZEND_NULL_HANDLER,
64330 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64331 ZEND_NULL_HANDLER,
64332 ZEND_NULL_HANDLER,
64333 ZEND_NULL_HANDLER,
64334 ZEND_NULL_HANDLER,
64335 ZEND_NULL_HANDLER,
64336 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
64337 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64338 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64339 ZEND_NULL_HANDLER,
64340 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64341 ZEND_SL_SPEC_CONST_CONST_HANDLER,
64342 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64343 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64344 ZEND_NULL_HANDLER,
64345 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
64346 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64347 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64348 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64349 ZEND_NULL_HANDLER,
64350 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64351 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64352 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64353 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64354 ZEND_NULL_HANDLER,
64355 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64356 ZEND_NULL_HANDLER,
64357 ZEND_NULL_HANDLER,
64358 ZEND_NULL_HANDLER,
64359 ZEND_NULL_HANDLER,
64360 ZEND_NULL_HANDLER,
64361 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
64362 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64363 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64364 ZEND_NULL_HANDLER,
64365 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64366 ZEND_SR_SPEC_CONST_CONST_HANDLER,
64367 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64368 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64369 ZEND_NULL_HANDLER,
64370 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
64371 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64372 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64373 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64374 ZEND_NULL_HANDLER,
64375 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64376 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64377 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64378 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64379 ZEND_NULL_HANDLER,
64380 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64381 ZEND_NULL_HANDLER,
64382 ZEND_NULL_HANDLER,
64383 ZEND_NULL_HANDLER,
64384 ZEND_NULL_HANDLER,
64385 ZEND_NULL_HANDLER,
64386 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
64387 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64388 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64389 ZEND_NULL_HANDLER,
64390 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64391 ZEND_NULL_HANDLER,
64392 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64393 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64394 ZEND_NULL_HANDLER,
64395 ZEND_CONCAT_SPEC_CONST_CV_HANDLER,
64396 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64397 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64398 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64399 ZEND_NULL_HANDLER,
64400 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64401 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64402 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64403 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64404 ZEND_NULL_HANDLER,
64405 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64406 ZEND_NULL_HANDLER,
64407 ZEND_NULL_HANDLER,
64408 ZEND_NULL_HANDLER,
64409 ZEND_NULL_HANDLER,
64410 ZEND_NULL_HANDLER,
64411 ZEND_CONCAT_SPEC_CV_CONST_HANDLER,
64412 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64413 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64414 ZEND_NULL_HANDLER,
64415 ZEND_CONCAT_SPEC_CV_CV_HANDLER,
64416 ZEND_BW_OR_SPEC_CONST_CONST_HANDLER,
64417 ZEND_NULL_HANDLER,
64418 ZEND_NULL_HANDLER,
64419 ZEND_NULL_HANDLER,
64420 ZEND_NULL_HANDLER,
64421 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64422 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64423 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64424 ZEND_NULL_HANDLER,
64425 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64426 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64427 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64428 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64429 ZEND_NULL_HANDLER,
64430 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64431 ZEND_NULL_HANDLER,
64432 ZEND_NULL_HANDLER,
64433 ZEND_NULL_HANDLER,
64434 ZEND_NULL_HANDLER,
64435 ZEND_NULL_HANDLER,
64436 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
64437 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64438 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64439 ZEND_NULL_HANDLER,
64440 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64441 ZEND_BW_AND_SPEC_CONST_CONST_HANDLER,
64442 ZEND_NULL_HANDLER,
64443 ZEND_NULL_HANDLER,
64444 ZEND_NULL_HANDLER,
64445 ZEND_NULL_HANDLER,
64446 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64447 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64448 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64449 ZEND_NULL_HANDLER,
64450 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64451 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64452 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64453 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64454 ZEND_NULL_HANDLER,
64455 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64456 ZEND_NULL_HANDLER,
64457 ZEND_NULL_HANDLER,
64458 ZEND_NULL_HANDLER,
64459 ZEND_NULL_HANDLER,
64460 ZEND_NULL_HANDLER,
64461 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
64462 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64463 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64464 ZEND_NULL_HANDLER,
64465 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64466 ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER,
64467 ZEND_NULL_HANDLER,
64468 ZEND_NULL_HANDLER,
64469 ZEND_NULL_HANDLER,
64470 ZEND_NULL_HANDLER,
64471 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64472 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64473 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64474 ZEND_NULL_HANDLER,
64475 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64476 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64477 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64478 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64479 ZEND_NULL_HANDLER,
64480 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64481 ZEND_NULL_HANDLER,
64482 ZEND_NULL_HANDLER,
64483 ZEND_NULL_HANDLER,
64484 ZEND_NULL_HANDLER,
64485 ZEND_NULL_HANDLER,
64486 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
64487 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64488 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64489 ZEND_NULL_HANDLER,
64490 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64491 ZEND_POW_SPEC_CONST_CONST_HANDLER,
64492 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
64493 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
64494 ZEND_NULL_HANDLER,
64495 ZEND_POW_SPEC_CONST_CV_HANDLER,
64496 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
64497 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64498 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64499 ZEND_NULL_HANDLER,
64500 ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
64501 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
64502 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64503 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
64504 ZEND_NULL_HANDLER,
64505 ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
64506 ZEND_NULL_HANDLER,
64507 ZEND_NULL_HANDLER,
64508 ZEND_NULL_HANDLER,
64509 ZEND_NULL_HANDLER,
64510 ZEND_NULL_HANDLER,
64511 ZEND_POW_SPEC_CV_CONST_HANDLER,
64512 ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
64513 ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
64514 ZEND_NULL_HANDLER,
64515 ZEND_POW_SPEC_CV_CV_HANDLER,
64516 ZEND_BW_NOT_SPEC_CONST_HANDLER,
64517 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64518 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64519 ZEND_NULL_HANDLER,
64520 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
64521 ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
64522 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
64523 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
64524 ZEND_NULL_HANDLER,
64525 ZEND_BOOL_NOT_SPEC_CV_HANDLER,
64526 ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER,
64527 ZEND_NULL_HANDLER,
64528 ZEND_NULL_HANDLER,
64529 ZEND_NULL_HANDLER,
64530 ZEND_NULL_HANDLER,
64531 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
64532 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64533 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64534 ZEND_NULL_HANDLER,
64535 ZEND_NULL_HANDLER,
64536 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
64537 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64538 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
64539 ZEND_NULL_HANDLER,
64540 ZEND_NULL_HANDLER,
64541 ZEND_NULL_HANDLER,
64542 ZEND_NULL_HANDLER,
64543 ZEND_NULL_HANDLER,
64544 ZEND_NULL_HANDLER,
64545 ZEND_NULL_HANDLER,
64546 ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER,
64547 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
64548 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
64549 ZEND_NULL_HANDLER,
64550 ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER,
64551 ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER,
64552 ZEND_NULL_HANDLER,
64553 ZEND_NULL_HANDLER,
64554 ZEND_NULL_HANDLER,
64555 ZEND_NULL_HANDLER,
64556 ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER,
64557 ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER,
64558 ZEND_NULL_HANDLER,
64559 ZEND_NULL_HANDLER,
64560 ZEND_NULL_HANDLER,
64561 ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER,
64562 ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER,
64563 ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER,
64564 ZEND_NULL_HANDLER,
64565 ZEND_NULL_HANDLER,
64566 ZEND_NULL_HANDLER,
64567 ZEND_NULL_HANDLER,
64568 ZEND_NULL_HANDLER,
64569 ZEND_NULL_HANDLER,
64570 ZEND_NULL_HANDLER,
64571 ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER,
64572 ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER,
64573 ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER,
64574 ZEND_NULL_HANDLER,
64575 ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER,
64576 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER,
64577 ZEND_NULL_HANDLER,
64578 ZEND_NULL_HANDLER,
64579 ZEND_NULL_HANDLER,
64580 ZEND_NULL_HANDLER,
64581 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER,
64582 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER,
64583 ZEND_NULL_HANDLER,
64584 ZEND_NULL_HANDLER,
64585 ZEND_NULL_HANDLER,
64586 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER,
64587 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER,
64588 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER,
64589 ZEND_NULL_HANDLER,
64590 ZEND_NULL_HANDLER,
64591 ZEND_NULL_HANDLER,
64592 ZEND_NULL_HANDLER,
64593 ZEND_NULL_HANDLER,
64594 ZEND_NULL_HANDLER,
64595 ZEND_NULL_HANDLER,
64596 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER,
64597 ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER,
64598 ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER,
64599 ZEND_NULL_HANDLER,
64600 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER,
64601 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64602 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64603 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
64604 ZEND_NULL_HANDLER,
64605 ZEND_NULL_HANDLER,
64606 ZEND_NULL_HANDLER,
64607 ZEND_NULL_HANDLER,
64608 ZEND_NULL_HANDLER,
64609 ZEND_NULL_HANDLER,
64610 ZEND_NULL_HANDLER,
64611 ZEND_NULL_HANDLER,
64612 ZEND_NULL_HANDLER,
64613 ZEND_NULL_HANDLER,
64614 ZEND_NULL_HANDLER,
64615 ZEND_NULL_HANDLER,
64616 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64617 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64618 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64619 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64620 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64621 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64622 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64623 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64624 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64632 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64633 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64634 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64635 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64636 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64637 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64638 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64639 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64640 ZEND_NULL_HANDLER,
64641 ZEND_NULL_HANDLER,
64642 ZEND_NULL_HANDLER,
64643 ZEND_NULL_HANDLER,
64644 ZEND_NULL_HANDLER,
64645 ZEND_NULL_HANDLER,
64646 ZEND_NULL_HANDLER,
64647 ZEND_NULL_HANDLER,
64648 ZEND_NULL_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_NULL_HANDLER,
64657 ZEND_NULL_HANDLER,
64658 ZEND_NULL_HANDLER,
64659 ZEND_NULL_HANDLER,
64660 ZEND_NULL_HANDLER,
64661 ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER,
64662 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
64663 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
64664 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64665 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64666 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64667 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64668 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64669 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64670 ZEND_NULL_HANDLER,
64671 ZEND_NULL_HANDLER,
64672 ZEND_NULL_HANDLER,
64673 ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER,
64674 ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
64675 ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
64676 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64677 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64678 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
64679 ZEND_NULL_HANDLER,
64680 ZEND_NULL_HANDLER,
64681 ZEND_NULL_HANDLER,
64682 ZEND_NULL_HANDLER,
64683 ZEND_NULL_HANDLER,
64684 ZEND_NULL_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_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64692 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64693 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64694 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64695 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64696 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64697 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64698 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64699 ZEND_IS_NOT_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_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
64707 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
64708 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
64709 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64710 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64711 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
64712 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
64713 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
64714 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_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_NULL_HANDLER,
64722 ZEND_NULL_HANDLER,
64723 ZEND_NULL_HANDLER,
64724 ZEND_NULL_HANDLER,
64725 ZEND_NULL_HANDLER,
64726 ZEND_NULL_HANDLER,
64727 ZEND_NULL_HANDLER,
64728 ZEND_NULL_HANDLER,
64729 ZEND_NULL_HANDLER,
64730 ZEND_NULL_HANDLER,
64731 ZEND_NULL_HANDLER,
64732 ZEND_NULL_HANDLER,
64733 ZEND_NULL_HANDLER,
64734 ZEND_NULL_HANDLER,
64735 ZEND_NULL_HANDLER,
64736 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER,
64737 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
64738 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
64739 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64740 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64741 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64742 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
64743 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
64744 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
64745 ZEND_NULL_HANDLER,
64746 ZEND_NULL_HANDLER,
64747 ZEND_NULL_HANDLER,
64748 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER,
64749 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
64750 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
64751 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64752 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64753 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
64754 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64755 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64756 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64757 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64758 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64759 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64760 ZEND_NULL_HANDLER,
64761 ZEND_NULL_HANDLER,
64762 ZEND_NULL_HANDLER,
64763 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
64764 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64765 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64766 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64767 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64768 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64769 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64770 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64771 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64772 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64773 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64774 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64775 ZEND_NULL_HANDLER,
64776 ZEND_NULL_HANDLER,
64777 ZEND_NULL_HANDLER,
64778 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64779 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64780 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64781 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64782 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64783 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64784 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64785 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64786 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64787 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64788 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64789 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64790 ZEND_NULL_HANDLER,
64791 ZEND_NULL_HANDLER,
64792 ZEND_NULL_HANDLER,
64793 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64794 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64795 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64796 ZEND_NULL_HANDLER,
64797 ZEND_NULL_HANDLER,
64798 ZEND_NULL_HANDLER,
64799 ZEND_NULL_HANDLER,
64800 ZEND_NULL_HANDLER,
64801 ZEND_NULL_HANDLER,
64802 ZEND_NULL_HANDLER,
64803 ZEND_NULL_HANDLER,
64804 ZEND_NULL_HANDLER,
64805 ZEND_NULL_HANDLER,
64806 ZEND_NULL_HANDLER,
64807 ZEND_NULL_HANDLER,
64808 ZEND_NULL_HANDLER,
64809 ZEND_NULL_HANDLER,
64810 ZEND_NULL_HANDLER,
64811 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
64812 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64813 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64814 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64815 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64816 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64817 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64818 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64819 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64820 ZEND_NULL_HANDLER,
64821 ZEND_NULL_HANDLER,
64822 ZEND_NULL_HANDLER,
64823 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64824 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64825 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64826 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
64827 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
64828 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
64829 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
64830 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64831 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64832 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
64833 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64834 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64835 ZEND_NULL_HANDLER,
64836 ZEND_NULL_HANDLER,
64837 ZEND_NULL_HANDLER,
64838 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
64839 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
64840 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
64841 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
64842 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64843 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64844 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64845 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64846 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64847 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64848 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64849 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64850 ZEND_NULL_HANDLER,
64851 ZEND_NULL_HANDLER,
64852 ZEND_NULL_HANDLER,
64853 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64854 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64855 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64856 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
64857 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64858 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64859 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64860 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64861 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64862 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64863 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64864 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64865 ZEND_NULL_HANDLER,
64866 ZEND_NULL_HANDLER,
64867 ZEND_NULL_HANDLER,
64868 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64869 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64870 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64871 ZEND_NULL_HANDLER,
64872 ZEND_NULL_HANDLER,
64873 ZEND_NULL_HANDLER,
64874 ZEND_NULL_HANDLER,
64875 ZEND_NULL_HANDLER,
64876 ZEND_NULL_HANDLER,
64877 ZEND_NULL_HANDLER,
64878 ZEND_NULL_HANDLER,
64879 ZEND_NULL_HANDLER,
64880 ZEND_NULL_HANDLER,
64881 ZEND_NULL_HANDLER,
64882 ZEND_NULL_HANDLER,
64883 ZEND_NULL_HANDLER,
64884 ZEND_NULL_HANDLER,
64885 ZEND_NULL_HANDLER,
64886 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
64887 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
64888 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
64889 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64890 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64891 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64892 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64893 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64894 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64895 ZEND_NULL_HANDLER,
64896 ZEND_NULL_HANDLER,
64897 ZEND_NULL_HANDLER,
64898 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
64899 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
64900 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
64901 ZEND_NULL_HANDLER,
64902 ZEND_NULL_HANDLER,
64903 ZEND_NULL_HANDLER,
64904 ZEND_NULL_HANDLER,
64905 ZEND_NULL_HANDLER,
64906 ZEND_NULL_HANDLER,
64907 ZEND_NULL_HANDLER,
64908 ZEND_NULL_HANDLER,
64909 ZEND_NULL_HANDLER,
64910 ZEND_NULL_HANDLER,
64911 ZEND_NULL_HANDLER,
64912 ZEND_NULL_HANDLER,
64913 ZEND_NULL_HANDLER,
64914 ZEND_NULL_HANDLER,
64915 ZEND_NULL_HANDLER,
64916 ZEND_NULL_HANDLER,
64917 ZEND_NULL_HANDLER,
64918 ZEND_NULL_HANDLER,
64919 ZEND_NULL_HANDLER,
64920 ZEND_NULL_HANDLER,
64921 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER,
64922 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER,
64923 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER,
64924 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER,
64925 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER,
64926 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER,
64927 ZEND_NULL_HANDLER,
64928 ZEND_NULL_HANDLER,
64929 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
64930 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_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_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER,
64942 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER,
64943 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER,
64944 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER,
64945 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER,
64946 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER,
64947 ZEND_NULL_HANDLER,
64948 ZEND_NULL_HANDLER,
64949 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER,
64950 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER,
64951 ZEND_NULL_HANDLER,
64952 ZEND_NULL_HANDLER,
64953 ZEND_NULL_HANDLER,
64954 ZEND_NULL_HANDLER,
64955 ZEND_NULL_HANDLER,
64956 ZEND_NULL_HANDLER,
64957 ZEND_NULL_HANDLER,
64958 ZEND_NULL_HANDLER,
64959 ZEND_NULL_HANDLER,
64960 ZEND_NULL_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_NULL_HANDLER,
64982 ZEND_NULL_HANDLER,
64983 ZEND_NULL_HANDLER,
64984 ZEND_NULL_HANDLER,
64985 ZEND_NULL_HANDLER,
64986 ZEND_NULL_HANDLER,
64987 ZEND_NULL_HANDLER,
64988 ZEND_NULL_HANDLER,
64989 ZEND_NULL_HANDLER,
64990 ZEND_NULL_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_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
65002 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
65003 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65004 ZEND_NULL_HANDLER,
65005 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65006 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65007 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65008 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65009 ZEND_NULL_HANDLER,
65010 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65011 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65012 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65013 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65014 ZEND_NULL_HANDLER,
65015 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65016 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER,
65017 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER,
65018 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER,
65019 ZEND_NULL_HANDLER,
65020 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER,
65021 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
65022 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
65023 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65024 ZEND_NULL_HANDLER,
65025 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_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_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
65052 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
65053 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65054 ZEND_NULL_HANDLER,
65055 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65056 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65057 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65058 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65059 ZEND_NULL_HANDLER,
65060 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65061 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65062 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65063 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65064 ZEND_NULL_HANDLER,
65065 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65066 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER,
65067 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER,
65068 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER,
65069 ZEND_NULL_HANDLER,
65070 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER,
65071 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
65072 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
65073 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65074 ZEND_NULL_HANDLER,
65075 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER,
65076 ZEND_NULL_HANDLER,
65077 ZEND_NULL_HANDLER,
65078 ZEND_NULL_HANDLER,
65079 ZEND_NULL_HANDLER,
65080 ZEND_NULL_HANDLER,
65081 ZEND_NULL_HANDLER,
65082 ZEND_NULL_HANDLER,
65083 ZEND_NULL_HANDLER,
65084 ZEND_NULL_HANDLER,
65085 ZEND_NULL_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_NULL_HANDLER,
65112 ZEND_NULL_HANDLER,
65113 ZEND_NULL_HANDLER,
65114 ZEND_NULL_HANDLER,
65115 ZEND_NULL_HANDLER,
65116 ZEND_NULL_HANDLER,
65117 ZEND_NULL_HANDLER,
65118 ZEND_NULL_HANDLER,
65119 ZEND_NULL_HANDLER,
65120 ZEND_NULL_HANDLER,
65121 ZEND_NULL_HANDLER,
65122 ZEND_NULL_HANDLER,
65123 ZEND_NULL_HANDLER,
65124 ZEND_NULL_HANDLER,
65125 ZEND_NULL_HANDLER,
65126 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
65127 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
65128 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65129 ZEND_NULL_HANDLER,
65130 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65131 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65132 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65133 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65134 ZEND_NULL_HANDLER,
65135 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65136 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
65137 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
65138 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65139 ZEND_NULL_HANDLER,
65140 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65141 ZEND_NULL_HANDLER,
65142 ZEND_NULL_HANDLER,
65143 ZEND_NULL_HANDLER,
65144 ZEND_NULL_HANDLER,
65145 ZEND_NULL_HANDLER,
65146 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
65147 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
65148 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65149 ZEND_NULL_HANDLER,
65150 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
65151 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER,
65152 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER,
65153 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
65154 ZEND_NULL_HANDLER,
65155 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
65156 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
65157 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
65158 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65159 ZEND_NULL_HANDLER,
65160 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65161 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
65162 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
65163 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65164 ZEND_NULL_HANDLER,
65165 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65166 ZEND_NULL_HANDLER,
65167 ZEND_NULL_HANDLER,
65168 ZEND_NULL_HANDLER,
65169 ZEND_NULL_HANDLER,
65170 ZEND_NULL_HANDLER,
65171 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER,
65172 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER,
65173 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
65174 ZEND_NULL_HANDLER,
65175 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
65176 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
65177 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
65178 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65179 ZEND_NULL_HANDLER,
65180 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65181 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65182 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65183 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65184 ZEND_NULL_HANDLER,
65185 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65186 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
65187 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
65188 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65189 ZEND_NULL_HANDLER,
65190 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65191 ZEND_NULL_HANDLER,
65192 ZEND_NULL_HANDLER,
65193 ZEND_NULL_HANDLER,
65194 ZEND_NULL_HANDLER,
65195 ZEND_NULL_HANDLER,
65196 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
65197 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
65198 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65199 ZEND_NULL_HANDLER,
65200 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER,
65201 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER,
65202 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER,
65203 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER,
65204 ZEND_NULL_HANDLER,
65205 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER,
65206 ZEND_NULL_HANDLER,
65207 ZEND_NULL_HANDLER,
65208 ZEND_NULL_HANDLER,
65209 ZEND_NULL_HANDLER,
65210 ZEND_NULL_HANDLER,
65211 ZEND_NULL_HANDLER,
65212 ZEND_NULL_HANDLER,
65213 ZEND_NULL_HANDLER,
65214 ZEND_NULL_HANDLER,
65215 ZEND_NULL_HANDLER,
65216 ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER,
65217 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
65218 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
65219 ZEND_NULL_HANDLER,
65220 ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER,
65221 ZEND_NULL_HANDLER,
65222 ZEND_NULL_HANDLER,
65223 ZEND_NULL_HANDLER,
65224 ZEND_NULL_HANDLER,
65225 ZEND_NULL_HANDLER,
65226 ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER,
65227 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
65228 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
65229 ZEND_NULL_HANDLER,
65230 ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER,
65231 ZEND_NULL_HANDLER,
65232 ZEND_NULL_HANDLER,
65233 ZEND_NULL_HANDLER,
65234 ZEND_NULL_HANDLER,
65235 ZEND_NULL_HANDLER,
65236 ZEND_NULL_HANDLER,
65237 ZEND_NULL_HANDLER,
65238 ZEND_NULL_HANDLER,
65239 ZEND_NULL_HANDLER,
65240 ZEND_NULL_HANDLER,
65241 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER,
65242 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
65243 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
65244 ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER,
65245 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER,
65246 ZEND_NULL_HANDLER,
65247 ZEND_NULL_HANDLER,
65248 ZEND_NULL_HANDLER,
65249 ZEND_NULL_HANDLER,
65250 ZEND_NULL_HANDLER,
65251 ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER,
65252 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
65253 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
65254 ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER,
65255 ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER,
65256 ZEND_NULL_HANDLER,
65257 ZEND_NULL_HANDLER,
65258 ZEND_NULL_HANDLER,
65259 ZEND_NULL_HANDLER,
65260 ZEND_NULL_HANDLER,
65261 ZEND_NULL_HANDLER,
65262 ZEND_NULL_HANDLER,
65263 ZEND_NULL_HANDLER,
65264 ZEND_NULL_HANDLER,
65265 ZEND_NULL_HANDLER,
65266 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER,
65267 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
65268 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
65269 ZEND_NULL_HANDLER,
65270 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER,
65271 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER,
65272 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
65273 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
65274 ZEND_NULL_HANDLER,
65275 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER,
65276 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER,
65277 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
65278 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
65279 ZEND_NULL_HANDLER,
65280 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER,
65281 ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER,
65282 ZEND_NULL_HANDLER,
65283 ZEND_NULL_HANDLER,
65284 ZEND_NULL_HANDLER,
65285 ZEND_NULL_HANDLER,
65286 ZEND_NULL_HANDLER,
65287 ZEND_NULL_HANDLER,
65288 ZEND_NULL_HANDLER,
65289 ZEND_NULL_HANDLER,
65290 ZEND_NULL_HANDLER,
65291 ZEND_NULL_HANDLER,
65292 ZEND_NULL_HANDLER,
65293 ZEND_NULL_HANDLER,
65294 ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER,
65295 ZEND_NULL_HANDLER,
65296 ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER,
65297 ZEND_NULL_HANDLER,
65298 ZEND_NULL_HANDLER,
65299 ZEND_NULL_HANDLER,
65300 ZEND_NULL_HANDLER,
65301 ZEND_NULL_HANDLER,
65302 ZEND_NULL_HANDLER,
65303 ZEND_NULL_HANDLER,
65304 ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER,
65305 ZEND_NULL_HANDLER,
65306 ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER,
65307 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
65308 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
65309 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
65310 ZEND_NULL_HANDLER,
65311 ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
65312 ZEND_NULL_HANDLER,
65313 ZEND_NULL_HANDLER,
65314 ZEND_NULL_HANDLER,
65315 ZEND_NULL_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_NULL_HANDLER,
65327 ZEND_NULL_HANDLER,
65328 ZEND_NULL_HANDLER,
65329 ZEND_NULL_HANDLER,
65330 ZEND_NULL_HANDLER,
65331 ZEND_NULL_HANDLER,
65332 ZEND_NULL_HANDLER,
65333 ZEND_NULL_HANDLER,
65334 ZEND_NULL_HANDLER,
65335 ZEND_NULL_HANDLER,
65336 ZEND_NULL_HANDLER,
65337 ZEND_NULL_HANDLER,
65338 ZEND_NULL_HANDLER,
65339 ZEND_NULL_HANDLER,
65340 ZEND_NULL_HANDLER,
65341 ZEND_NULL_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_NULL_HANDLER,
65355 ZEND_NULL_HANDLER,
65356 ZEND_NULL_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_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
65365 ZEND_NULL_HANDLER,
65366 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
65367 ZEND_NULL_HANDLER,
65368 ZEND_NULL_HANDLER,
65369 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65370 ZEND_NULL_HANDLER,
65371 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
65372 ZEND_NULL_HANDLER,
65373 ZEND_NULL_HANDLER,
65374 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
65375 ZEND_NULL_HANDLER,
65376 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_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_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
65385 ZEND_NULL_HANDLER,
65386 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
65387 ZEND_NULL_HANDLER,
65388 ZEND_NULL_HANDLER,
65389 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
65390 ZEND_NULL_HANDLER,
65391 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
65392 ZEND_NULL_HANDLER,
65393 ZEND_NULL_HANDLER,
65394 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65395 ZEND_NULL_HANDLER,
65396 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
65397 ZEND_NULL_HANDLER,
65398 ZEND_NULL_HANDLER,
65399 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
65400 ZEND_NULL_HANDLER,
65401 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_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_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
65410 ZEND_NULL_HANDLER,
65411 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
65412 ZEND_NULL_HANDLER,
65413 ZEND_NULL_HANDLER,
65414 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
65415 ZEND_NULL_HANDLER,
65416 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
65417 ZEND_NULL_HANDLER,
65418 ZEND_NULL_HANDLER,
65419 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65420 ZEND_NULL_HANDLER,
65421 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65422 ZEND_NULL_HANDLER,
65423 ZEND_NULL_HANDLER,
65424 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
65425 ZEND_NULL_HANDLER,
65426 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
65427 ZEND_NULL_HANDLER,
65428 ZEND_NULL_HANDLER,
65429 ZEND_NULL_HANDLER,
65430 ZEND_NULL_HANDLER,
65431 ZEND_NULL_HANDLER,
65432 ZEND_NULL_HANDLER,
65433 ZEND_NULL_HANDLER,
65434 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
65435 ZEND_NULL_HANDLER,
65436 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER,
65437 ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER,
65438 ZEND_NULL_HANDLER,
65439 ZEND_NULL_HANDLER,
65440 ZEND_NULL_HANDLER,
65441 ZEND_NULL_HANDLER,
65442 ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
65443 ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER,
65444 ZEND_NULL_HANDLER,
65445 ZEND_NULL_HANDLER,
65446 ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER,
65447 ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER,
65448 ZEND_NULL_HANDLER,
65449 ZEND_NULL_HANDLER,
65450 ZEND_NULL_HANDLER,
65451 ZEND_NULL_HANDLER,
65452 ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
65453 ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER,
65454 ZEND_NULL_HANDLER,
65455 ZEND_NULL_HANDLER,
65456 ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER,
65457 ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER,
65458 ZEND_NULL_HANDLER,
65459 ZEND_NULL_HANDLER,
65460 ZEND_POST_INC_SPEC_VAR_HANDLER,
65461 ZEND_NULL_HANDLER,
65462 ZEND_POST_INC_SPEC_CV_HANDLER,
65463 ZEND_NULL_HANDLER,
65464 ZEND_NULL_HANDLER,
65465 ZEND_POST_DEC_SPEC_VAR_HANDLER,
65466 ZEND_NULL_HANDLER,
65467 ZEND_POST_DEC_SPEC_CV_HANDLER,
65468 ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER,
65469 ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER,
65470 ZEND_JMP_SPEC_HANDLER,
65471 ZEND_JMPZ_SPEC_CONST_HANDLER,
65472 ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
65473 ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
65474 ZEND_NULL_HANDLER,
65475 ZEND_JMPZ_SPEC_CV_HANDLER,
65476 ZEND_JMPNZ_SPEC_CONST_HANDLER,
65477 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
65478 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
65479 ZEND_NULL_HANDLER,
65480 ZEND_JMPNZ_SPEC_CV_HANDLER,
65481 ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
65482 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
65483 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
65484 ZEND_NULL_HANDLER,
65485 ZEND_JMPZ_EX_SPEC_CV_HANDLER,
65486 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
65487 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
65488 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
65489 ZEND_NULL_HANDLER,
65490 ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
65491 ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER,
65492 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
65493 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
65494 ZEND_NULL_HANDLER,
65495 ZEND_CASE_SPEC_TMPVAR_CV_HANDLER,
65496 ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER,
65497 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
65498 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
65499 ZEND_NULL_HANDLER,
65500 ZEND_NULL_HANDLER,
65501 ZEND_NULL_HANDLER,
65502 ZEND_NULL_HANDLER,
65503 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER,
65504 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER,
65505 ZEND_NULL_HANDLER,
65506 ZEND_NULL_HANDLER,
65507 ZEND_CAST_SPEC_CONST_HANDLER,
65508 ZEND_CAST_SPEC_TMP_HANDLER,
65509 ZEND_CAST_SPEC_VAR_HANDLER,
65510 ZEND_NULL_HANDLER,
65511 ZEND_CAST_SPEC_CV_HANDLER,
65512 ZEND_BOOL_SPEC_CONST_HANDLER,
65513 ZEND_BOOL_SPEC_TMPVAR_HANDLER,
65514 ZEND_BOOL_SPEC_TMPVAR_HANDLER,
65515 ZEND_NULL_HANDLER,
65516 ZEND_BOOL_SPEC_CV_HANDLER,
65517 ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER,
65518 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
65519 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
65520 ZEND_NULL_HANDLER,
65521 ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER,
65522 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
65523 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65524 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65525 ZEND_NULL_HANDLER,
65526 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
65527 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
65528 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65529 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
65530 ZEND_NULL_HANDLER,
65531 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
65532 ZEND_NULL_HANDLER,
65533 ZEND_NULL_HANDLER,
65534 ZEND_NULL_HANDLER,
65535 ZEND_NULL_HANDLER,
65536 ZEND_NULL_HANDLER,
65537 ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER,
65538 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
65539 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
65540 ZEND_NULL_HANDLER,
65541 ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER,
65542 ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER,
65543 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
65544 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
65545 ZEND_NULL_HANDLER,
65546 ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER,
65547 ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER,
65548 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
65549 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
65550 ZEND_NULL_HANDLER,
65551 ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER,
65552 ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER,
65553 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
65554 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
65555 ZEND_NULL_HANDLER,
65556 ZEND_ROPE_END_SPEC_TMP_CV_HANDLER,
65557 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
65558 ZEND_END_SILENCE_SPEC_TMP_HANDLER,
65559 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
65560 ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER,
65561 ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER,
65562 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
65563 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
65564 ZEND_INIT_FCALL_SPEC_CONST_HANDLER,
65565 ZEND_RETURN_SPEC_CONST_HANDLER,
65566 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65567 ZEND_RETURN_SPEC_TMP_HANDLER,
65568 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65569 ZEND_RETURN_SPEC_VAR_HANDLER,
65570 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65571 ZEND_NULL_HANDLER,
65572 ZEND_NULL_HANDLER,
65573 ZEND_RETURN_SPEC_CV_HANDLER,
65574 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
65575 ZEND_RECV_SPEC_UNUSED_HANDLER,
65576 ZEND_RECV_INIT_SPEC_CONST_HANDLER,
65577 ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER,
65578 ZEND_NULL_HANDLER,
65579 ZEND_NULL_HANDLER,
65580 ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER,
65581 ZEND_NULL_HANDLER,
65582 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
65583 ZEND_NULL_HANDLER,
65584 ZEND_NULL_HANDLER,
65585 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER,
65586 ZEND_NULL_HANDLER,
65587 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
65588 ZEND_NULL_HANDLER,
65589 ZEND_NULL_HANDLER,
65590 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER,
65591 ZEND_NULL_HANDLER,
65592 ZEND_NULL_HANDLER,
65593 ZEND_NULL_HANDLER,
65594 ZEND_NULL_HANDLER,
65595 ZEND_NULL_HANDLER,
65596 ZEND_NULL_HANDLER,
65597 ZEND_NULL_HANDLER,
65598 ZEND_NULL_HANDLER,
65599 ZEND_NULL_HANDLER,
65600 ZEND_NULL_HANDLER,
65601 ZEND_NULL_HANDLER,
65602 ZEND_NULL_HANDLER,
65603 ZEND_NULL_HANDLER,
65604 ZEND_NULL_HANDLER,
65605 ZEND_NULL_HANDLER,
65606 ZEND_NULL_HANDLER,
65607 ZEND_NULL_HANDLER,
65608 ZEND_NULL_HANDLER,
65609 ZEND_NULL_HANDLER,
65610 ZEND_NULL_HANDLER,
65611 ZEND_NULL_HANDLER,
65612 ZEND_NULL_HANDLER,
65613 ZEND_NULL_HANDLER,
65614 ZEND_NULL_HANDLER,
65615 ZEND_NULL_HANDLER,
65616 ZEND_NULL_HANDLER,
65617 ZEND_NULL_HANDLER,
65618 ZEND_NULL_HANDLER,
65619 ZEND_NULL_HANDLER,
65620 ZEND_NULL_HANDLER,
65621 ZEND_NULL_HANDLER,
65622 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
65623 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
65624 ZEND_NULL_HANDLER,
65625 ZEND_NULL_HANDLER,
65626 ZEND_NULL_HANDLER,
65627 ZEND_NULL_HANDLER,
65628 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER,
65629 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER,
65630 ZEND_NULL_HANDLER,
65631 ZEND_NULL_HANDLER,
65632 ZEND_NULL_HANDLER,
65633 ZEND_NULL_HANDLER,
65634 ZEND_NULL_HANDLER,
65635 ZEND_NULL_HANDLER,
65636 ZEND_NULL_HANDLER,
65637 ZEND_NULL_HANDLER,
65638 ZEND_NULL_HANDLER,
65639 ZEND_NULL_HANDLER,
65640 ZEND_NULL_HANDLER,
65641 ZEND_NULL_HANDLER,
65642 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
65643 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
65644 ZEND_NULL_HANDLER,
65645 ZEND_NULL_HANDLER,
65646 ZEND_NULL_HANDLER,
65647 ZEND_NULL_HANDLER,
65648 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER,
65649 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER,
65650 ZEND_NULL_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_SEND_REF_SPEC_VAR_CONST_HANDLER,
65663 ZEND_NULL_HANDLER,
65664 ZEND_NULL_HANDLER,
65665 ZEND_SEND_REF_SPEC_VAR_UNUSED_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_SEND_REF_SPEC_CV_CONST_HANDLER,
65673 ZEND_NULL_HANDLER,
65674 ZEND_NULL_HANDLER,
65675 ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER,
65676 ZEND_NULL_HANDLER,
65677 ZEND_NEW_SPEC_CONST_UNUSED_HANDLER,
65678 ZEND_NULL_HANDLER,
65679 ZEND_NEW_SPEC_VAR_UNUSED_HANDLER,
65680 ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER,
65681 ZEND_NULL_HANDLER,
65682 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
65683 ZEND_FREE_SPEC_TMPVAR_HANDLER,
65684 ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER,
65685 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
65686 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
65687 ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER,
65688 ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER,
65689 ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER,
65690 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
65691 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
65692 ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER,
65693 ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER,
65694 ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER,
65695 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
65696 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
65697 ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER,
65698 ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER,
65699 ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER,
65700 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
65701 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
65702 ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER,
65703 ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER,
65704 ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER,
65705 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
65706 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
65707 ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER,
65708 ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER,
65709 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER,
65710 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
65711 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
65712 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER,
65713 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER,
65714 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER,
65715 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
65716 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
65717 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER,
65718 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER,
65719 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER,
65720 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
65721 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
65722 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER,
65723 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER,
65724 ZEND_NULL_HANDLER,
65725 ZEND_NULL_HANDLER,
65726 ZEND_NULL_HANDLER,
65727 ZEND_NULL_HANDLER,
65728 ZEND_NULL_HANDLER,
65729 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER,
65730 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
65731 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
65732 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER,
65733 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER,
65734 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
65735 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65736 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
65737 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65738 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
65739 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65740 ZEND_NULL_HANDLER,
65741 ZEND_NULL_HANDLER,
65742 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
65743 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
65744 ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER,
65745 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
65746 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
65747 ZEND_NULL_HANDLER,
65748 ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER,
65749 ZEND_NULL_HANDLER,
65750 ZEND_NULL_HANDLER,
65751 ZEND_NULL_HANDLER,
65752 ZEND_NULL_HANDLER,
65753 ZEND_NULL_HANDLER,
65754 ZEND_NULL_HANDLER,
65755 ZEND_NULL_HANDLER,
65756 ZEND_NULL_HANDLER,
65757 ZEND_NULL_HANDLER,
65758 ZEND_NULL_HANDLER,
65759 ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER,
65760 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
65761 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
65762 ZEND_NULL_HANDLER,
65763 ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER,
65764 ZEND_NULL_HANDLER,
65765 ZEND_NULL_HANDLER,
65766 ZEND_NULL_HANDLER,
65767 ZEND_NULL_HANDLER,
65768 ZEND_NULL_HANDLER,
65769 ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER,
65770 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
65771 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
65772 ZEND_NULL_HANDLER,
65773 ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER,
65774 ZEND_NULL_HANDLER,
65775 ZEND_NULL_HANDLER,
65776 ZEND_NULL_HANDLER,
65777 ZEND_NULL_HANDLER,
65778 ZEND_NULL_HANDLER,
65779 ZEND_NULL_HANDLER,
65780 ZEND_NULL_HANDLER,
65781 ZEND_NULL_HANDLER,
65782 ZEND_NULL_HANDLER,
65783 ZEND_NULL_HANDLER,
65784 ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER,
65785 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
65786 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
65787 ZEND_NULL_HANDLER,
65788 ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER,
65789 ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER,
65790 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65791 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65792 ZEND_NULL_HANDLER,
65793 ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER,
65794 ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER,
65795 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
65796 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
65797 ZEND_NULL_HANDLER,
65798 ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER,
65799 ZEND_FE_RESET_R_SPEC_CONST_HANDLER,
65800 ZEND_FE_RESET_R_SPEC_TMP_HANDLER,
65801 ZEND_FE_RESET_R_SPEC_VAR_HANDLER,
65802 ZEND_NULL_HANDLER,
65803 ZEND_FE_RESET_R_SPEC_CV_HANDLER,
65804 ZEND_FE_FETCH_R_SPEC_VAR_HANDLER,
65805 ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER,
65806 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
65807 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
65808 ZEND_NULL_HANDLER,
65809 ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER,
65810 ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER,
65811 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
65812 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
65813 ZEND_NULL_HANDLER,
65814 ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER,
65815 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
65816 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65817 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65818 ZEND_NULL_HANDLER,
65819 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
65820 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
65821 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65822 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65823 ZEND_NULL_HANDLER,
65824 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
65825 ZEND_NULL_HANDLER,
65826 ZEND_NULL_HANDLER,
65827 ZEND_NULL_HANDLER,
65828 ZEND_NULL_HANDLER,
65829 ZEND_NULL_HANDLER,
65830 ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER,
65831 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
65832 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
65833 ZEND_NULL_HANDLER,
65834 ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
65835 ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER,
65836 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
65837 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
65838 ZEND_NULL_HANDLER,
65839 ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER,
65840 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
65841 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65842 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65843 ZEND_NULL_HANDLER,
65844 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
65845 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
65846 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65847 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
65848 ZEND_NULL_HANDLER,
65849 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
65850 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER,
65851 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
65852 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
65853 ZEND_NULL_HANDLER,
65854 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER,
65855 ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER,
65856 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
65857 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
65858 ZEND_NULL_HANDLER,
65859 ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER,
65860 ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER,
65861 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
65862 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
65863 ZEND_NULL_HANDLER,
65864 ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER,
65865 ZEND_NULL_HANDLER,
65866 ZEND_NULL_HANDLER,
65867 ZEND_NULL_HANDLER,
65868 ZEND_NULL_HANDLER,
65869 ZEND_NULL_HANDLER,
65870 ZEND_NULL_HANDLER,
65871 ZEND_NULL_HANDLER,
65872 ZEND_NULL_HANDLER,
65873 ZEND_NULL_HANDLER,
65874 ZEND_NULL_HANDLER,
65875 ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
65876 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
65877 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
65878 ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER,
65879 ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER,
65880 ZEND_NULL_HANDLER,
65881 ZEND_NULL_HANDLER,
65882 ZEND_NULL_HANDLER,
65883 ZEND_NULL_HANDLER,
65884 ZEND_NULL_HANDLER,
65885 ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER,
65886 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
65887 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
65888 ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER,
65889 ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER,
65890 ZEND_NULL_HANDLER,
65891 ZEND_NULL_HANDLER,
65892 ZEND_NULL_HANDLER,
65893 ZEND_NULL_HANDLER,
65894 ZEND_NULL_HANDLER,
65895 ZEND_NULL_HANDLER,
65896 ZEND_NULL_HANDLER,
65897 ZEND_NULL_HANDLER,
65898 ZEND_NULL_HANDLER,
65899 ZEND_NULL_HANDLER,
65900 ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER,
65901 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
65902 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
65903 ZEND_NULL_HANDLER,
65904 ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER,
65905 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER,
65906 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
65907 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
65908 ZEND_NULL_HANDLER,
65909 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER,
65910 ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER,
65911 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
65912 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
65913 ZEND_NULL_HANDLER,
65914 ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER,
65915 ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER,
65916 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
65917 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
65918 ZEND_NULL_HANDLER,
65919 ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER,
65920 ZEND_NULL_HANDLER,
65921 ZEND_NULL_HANDLER,
65922 ZEND_NULL_HANDLER,
65923 ZEND_NULL_HANDLER,
65924 ZEND_NULL_HANDLER,
65925 ZEND_NULL_HANDLER,
65926 ZEND_NULL_HANDLER,
65927 ZEND_NULL_HANDLER,
65928 ZEND_NULL_HANDLER,
65929 ZEND_NULL_HANDLER,
65930 ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
65931 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
65932 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
65933 ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER,
65934 ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER,
65935 ZEND_NULL_HANDLER,
65936 ZEND_NULL_HANDLER,
65937 ZEND_NULL_HANDLER,
65938 ZEND_NULL_HANDLER,
65939 ZEND_NULL_HANDLER,
65940 ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER,
65941 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
65942 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
65943 ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER,
65944 ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER,
65945 ZEND_NULL_HANDLER,
65946 ZEND_NULL_HANDLER,
65947 ZEND_NULL_HANDLER,
65948 ZEND_NULL_HANDLER,
65949 ZEND_NULL_HANDLER,
65950 ZEND_NULL_HANDLER,
65951 ZEND_NULL_HANDLER,
65952 ZEND_NULL_HANDLER,
65953 ZEND_NULL_HANDLER,
65954 ZEND_NULL_HANDLER,
65955 ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER,
65956 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
65957 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
65958 ZEND_NULL_HANDLER,
65959 ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER,
65960 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER,
65961 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
65962 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
65963 ZEND_NULL_HANDLER,
65964 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER,
65965 ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER,
65966 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
65967 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
65968 ZEND_NULL_HANDLER,
65969 ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER,
65970 ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER,
65971 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
65972 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
65973 ZEND_NULL_HANDLER,
65974 ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER,
65975 ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER,
65976 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
65977 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
65978 ZEND_NULL_HANDLER,
65979 ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER,
65980 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
65981 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
65982 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
65983 ZEND_NULL_HANDLER,
65984 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
65985 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
65986 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
65987 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
65988 ZEND_NULL_HANDLER,
65989 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
65990 ZEND_NULL_HANDLER,
65991 ZEND_NULL_HANDLER,
65992 ZEND_NULL_HANDLER,
65993 ZEND_NULL_HANDLER,
65994 ZEND_NULL_HANDLER,
65995 ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER,
65996 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
65997 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
65998 ZEND_NULL_HANDLER,
65999 ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
66000 ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER,
66001 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
66002 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
66003 ZEND_NULL_HANDLER,
66004 ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER,
66005 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
66006 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66007 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66008 ZEND_NULL_HANDLER,
66009 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
66010 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
66011 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66012 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
66013 ZEND_NULL_HANDLER,
66014 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
66015 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER,
66016 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
66017 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
66018 ZEND_NULL_HANDLER,
66019 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER,
66020 ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER,
66021 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
66022 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
66023 ZEND_NULL_HANDLER,
66024 ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER,
66025 ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
66026 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
66027 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
66028 ZEND_NULL_HANDLER,
66029 ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
66030 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
66031 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66032 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66033 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
66034 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER,
66035 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
66036 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66037 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66038 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER,
66039 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER,
66040 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66041 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66042 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66043 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
66044 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER,
66045 ZEND_NULL_HANDLER,
66046 ZEND_NULL_HANDLER,
66047 ZEND_NULL_HANDLER,
66048 ZEND_NULL_HANDLER,
66049 ZEND_NULL_HANDLER,
66050 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER,
66051 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66052 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66053 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
66054 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
66055 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
66056 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66057 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
66058 ZEND_NULL_HANDLER,
66059 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER,
66060 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
66061 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66062 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
66063 ZEND_NULL_HANDLER,
66064 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER,
66065 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66066 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66067 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
66068 ZEND_NULL_HANDLER,
66069 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER,
66070 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66071 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
66072 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
66073 ZEND_NULL_HANDLER,
66074 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER,
66075 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER,
66076 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66077 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
66078 ZEND_NULL_HANDLER,
66079 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER,
66080 ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER,
66081 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
66082 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
66083 ZEND_NULL_HANDLER,
66084 ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER,
66085 ZEND_NULL_HANDLER,
66086 ZEND_NULL_HANDLER,
66087 ZEND_NULL_HANDLER,
66088 ZEND_NULL_HANDLER,
66089 ZEND_NULL_HANDLER,
66090 ZEND_NULL_HANDLER,
66091 ZEND_NULL_HANDLER,
66092 ZEND_NULL_HANDLER,
66093 ZEND_NULL_HANDLER,
66094 ZEND_NULL_HANDLER,
66095 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
66096 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66097 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66098 ZEND_NULL_HANDLER,
66099 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER,
66100 ZEND_NULL_HANDLER,
66101 ZEND_NULL_HANDLER,
66102 ZEND_NULL_HANDLER,
66103 ZEND_NULL_HANDLER,
66104 ZEND_NULL_HANDLER,
66105 ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER,
66106 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
66107 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
66108 ZEND_NULL_HANDLER,
66109 ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER,
66110 ZEND_NULL_HANDLER,
66111 ZEND_NULL_HANDLER,
66112 ZEND_NULL_HANDLER,
66113 ZEND_NULL_HANDLER,
66114 ZEND_NULL_HANDLER,
66115 ZEND_NULL_HANDLER,
66116 ZEND_NULL_HANDLER,
66117 ZEND_NULL_HANDLER,
66118 ZEND_NULL_HANDLER,
66119 ZEND_NULL_HANDLER,
66120 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER,
66121 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66122 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
66123 ZEND_NULL_HANDLER,
66124 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER,
66125 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER,
66126 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
66127 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
66128 ZEND_NULL_HANDLER,
66129 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER,
66130 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER,
66131 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
66132 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
66133 ZEND_NULL_HANDLER,
66134 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER,
66135 ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER,
66136 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
66137 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
66138 ZEND_NULL_HANDLER,
66139 ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER,
66140 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66141 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66142 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66143 ZEND_NULL_HANDLER,
66144 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66145 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66146 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66147 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66148 ZEND_NULL_HANDLER,
66149 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66150 ZEND_NULL_HANDLER,
66151 ZEND_NULL_HANDLER,
66152 ZEND_NULL_HANDLER,
66153 ZEND_NULL_HANDLER,
66154 ZEND_NULL_HANDLER,
66155 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
66156 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66157 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
66158 ZEND_NULL_HANDLER,
66159 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
66160 ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
66161 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66162 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
66163 ZEND_NULL_HANDLER,
66164 ZEND_NULL_HANDLER,
66165 ZEND_NULL_HANDLER,
66166 ZEND_NULL_HANDLER,
66167 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER,
66168 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER,
66169 ZEND_NULL_HANDLER,
66170 ZEND_NULL_HANDLER,
66171 ZEND_EXT_STMT_SPEC_HANDLER,
66172 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
66173 ZEND_EXT_FCALL_END_SPEC_HANDLER,
66174 ZEND_EXT_NOP_SPEC_HANDLER,
66175 ZEND_TICKS_SPEC_HANDLER,
66176 ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER,
66177 ZEND_NULL_HANDLER,
66178 ZEND_NULL_HANDLER,
66179 ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER,
66180 ZEND_NULL_HANDLER,
66181 ZEND_CATCH_SPEC_CONST_HANDLER,
66182 ZEND_THROW_SPEC_CONST_HANDLER,
66183 ZEND_THROW_SPEC_TMPVAR_HANDLER,
66184 ZEND_THROW_SPEC_TMPVAR_HANDLER,
66185 ZEND_NULL_HANDLER,
66186 ZEND_THROW_SPEC_CV_HANDLER,
66187 ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER,
66188 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
66189 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
66190 ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66191 ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER,
66192 ZEND_CLONE_SPEC_CONST_HANDLER,
66193 ZEND_CLONE_SPEC_TMPVAR_HANDLER,
66194 ZEND_CLONE_SPEC_TMPVAR_HANDLER,
66195 ZEND_CLONE_SPEC_UNUSED_HANDLER,
66196 ZEND_CLONE_SPEC_CV_HANDLER,
66197 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
66198 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66199 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
66200 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66201 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
66202 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66203 ZEND_NULL_HANDLER,
66204 ZEND_NULL_HANDLER,
66205 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
66206 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
66207 ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
66208 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66209 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66210 ZEND_NULL_HANDLER,
66211 ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER,
66212 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
66213 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66214 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66215 ZEND_NULL_HANDLER,
66216 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
66217 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
66218 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66219 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
66220 ZEND_NULL_HANDLER,
66221 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
66222 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
66223 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66224 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66225 ZEND_NULL_HANDLER,
66226 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
66227 ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER,
66228 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
66229 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
66230 ZEND_NULL_HANDLER,
66231 ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER,
66232 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
66233 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66234 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
66235 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER,
66236 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER,
66237 ZEND_NULL_HANDLER,
66238 ZEND_NULL_HANDLER,
66239 ZEND_NULL_HANDLER,
66240 ZEND_NULL_HANDLER,
66241 ZEND_NULL_HANDLER,
66242 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
66243 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
66244 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
66245 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER,
66246 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER,
66247 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
66248 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66249 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
66250 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER,
66251 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
66252 ZEND_NULL_HANDLER,
66253 ZEND_NULL_HANDLER,
66254 ZEND_NULL_HANDLER,
66255 ZEND_NULL_HANDLER,
66256 ZEND_NULL_HANDLER,
66257 ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER,
66258 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
66259 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
66260 ZEND_NULL_HANDLER,
66261 ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER,
66262 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER,
66263 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66264 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66265 ZEND_NULL_HANDLER,
66266 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER,
66267 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66268 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66269 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66270 ZEND_NULL_HANDLER,
66271 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
66272 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66273 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66274 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66275 ZEND_NULL_HANDLER,
66276 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
66277 ZEND_NULL_HANDLER,
66278 ZEND_NULL_HANDLER,
66279 ZEND_NULL_HANDLER,
66280 ZEND_NULL_HANDLER,
66281 ZEND_NULL_HANDLER,
66282 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER,
66283 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
66284 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
66285 ZEND_NULL_HANDLER,
66286 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER,
66287 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
66288 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
66289 ZEND_NULL_HANDLER,
66290 ZEND_NULL_HANDLER,
66291 ZEND_NULL_HANDLER,
66292 ZEND_NULL_HANDLER,
66293 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER,
66294 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER,
66295 ZEND_NULL_HANDLER,
66296 ZEND_NULL_HANDLER,
66297 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
66298 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
66299 ZEND_NULL_HANDLER,
66300 ZEND_NULL_HANDLER,
66301 ZEND_NULL_HANDLER,
66302 ZEND_NULL_HANDLER,
66303 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER,
66304 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER,
66305 ZEND_NULL_HANDLER,
66306 ZEND_NULL_HANDLER,
66307 ZEND_NULL_HANDLER,
66308 ZEND_NULL_HANDLER,
66309 ZEND_NULL_HANDLER,
66310 ZEND_NULL_HANDLER,
66311 ZEND_NULL_HANDLER,
66312 ZEND_NULL_HANDLER,
66313 ZEND_NULL_HANDLER,
66314 ZEND_NULL_HANDLER,
66315 ZEND_NULL_HANDLER,
66316 ZEND_NULL_HANDLER,
66317 ZEND_NULL_HANDLER,
66318 ZEND_NULL_HANDLER,
66319 ZEND_NULL_HANDLER,
66320 ZEND_NULL_HANDLER,
66321 ZEND_NULL_HANDLER,
66322 ZEND_NULL_HANDLER,
66323 ZEND_NULL_HANDLER,
66324 ZEND_NULL_HANDLER,
66325 ZEND_NULL_HANDLER,
66326 ZEND_NULL_HANDLER,
66327 ZEND_NULL_HANDLER,
66328 ZEND_NULL_HANDLER,
66329 ZEND_NULL_HANDLER,
66330 ZEND_NULL_HANDLER,
66331 ZEND_NULL_HANDLER,
66332 ZEND_NULL_HANDLER,
66333 ZEND_NULL_HANDLER,
66334 ZEND_NULL_HANDLER,
66335 ZEND_NULL_HANDLER,
66336 ZEND_NULL_HANDLER,
66337 ZEND_NULL_HANDLER,
66338 ZEND_NULL_HANDLER,
66339 ZEND_NULL_HANDLER,
66340 ZEND_NULL_HANDLER,
66341 ZEND_NULL_HANDLER,
66342 ZEND_NULL_HANDLER,
66343 ZEND_NULL_HANDLER,
66344 ZEND_NULL_HANDLER,
66345 ZEND_NULL_HANDLER,
66346 ZEND_NULL_HANDLER,
66347 ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER,
66348 ZEND_NULL_HANDLER,
66349 ZEND_NULL_HANDLER,
66350 ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER,
66351 ZEND_NULL_HANDLER,
66352 ZEND_NULL_HANDLER,
66353 ZEND_NULL_HANDLER,
66354 ZEND_NULL_HANDLER,
66355 ZEND_NULL_HANDLER,
66356 ZEND_NULL_HANDLER,
66357 ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER,
66358 ZEND_NULL_HANDLER,
66359 ZEND_NULL_HANDLER,
66360 ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER,
66361 ZEND_NULL_HANDLER,
66362 ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER,
66363 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
66364 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
66365 ZEND_NULL_HANDLER,
66366 ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER,
66367 ZEND_SEND_ARRAY_SPEC_HANDLER,
66368 ZEND_SEND_USER_SPEC_CONST_HANDLER,
66369 ZEND_SEND_USER_SPEC_TMP_HANDLER,
66370 ZEND_SEND_USER_SPEC_VAR_HANDLER,
66371 ZEND_NULL_HANDLER,
66372 ZEND_SEND_USER_SPEC_CV_HANDLER,
66373 ZEND_STRLEN_SPEC_CONST_HANDLER,
66374 ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
66375 ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
66376 ZEND_NULL_HANDLER,
66377 ZEND_STRLEN_SPEC_CV_HANDLER,
66378 ZEND_DEFINED_SPEC_CONST_HANDLER,
66379 ZEND_TYPE_CHECK_SPEC_CONST_HANDLER,
66380 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
66381 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
66382 ZEND_NULL_HANDLER,
66383 ZEND_TYPE_CHECK_SPEC_CV_HANDLER,
66384 ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER,
66385 ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER,
66386 ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER,
66387 ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
66388 ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER,
66389 ZEND_FE_RESET_RW_SPEC_CONST_HANDLER,
66390 ZEND_FE_RESET_RW_SPEC_TMP_HANDLER,
66391 ZEND_FE_RESET_RW_SPEC_VAR_HANDLER,
66392 ZEND_NULL_HANDLER,
66393 ZEND_FE_RESET_RW_SPEC_CV_HANDLER,
66394 ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER,
66395 ZEND_FE_FREE_SPEC_TMPVAR_HANDLER,
66396 ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER,
66397 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
66398 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
66399 ZEND_NULL_HANDLER,
66400 ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER,
66401 ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER,
66402 ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER,
66403 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
66404 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
66405 ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER,
66406 ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER,
66407 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
66408 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
66409 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER,
66410 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER,
66411 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER,
66412 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER,
66413 ZEND_NULL_HANDLER,
66414 ZEND_NULL_HANDLER,
66415 ZEND_NULL_HANDLER,
66416 ZEND_NULL_HANDLER,
66417 ZEND_NULL_HANDLER,
66418 ZEND_NULL_HANDLER,
66419 ZEND_NULL_HANDLER,
66420 ZEND_NULL_HANDLER,
66421 ZEND_NULL_HANDLER,
66422 ZEND_NULL_HANDLER,
66423 ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER,
66424 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66425 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66426 ZEND_NULL_HANDLER,
66427 ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER,
66428 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
66429 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66430 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66431 ZEND_NULL_HANDLER,
66432 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
66433 ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER,
66434 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66435 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66436 ZEND_NULL_HANDLER,
66437 ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER,
66438 ZEND_NULL_HANDLER,
66439 ZEND_NULL_HANDLER,
66440 ZEND_NULL_HANDLER,
66441 ZEND_NULL_HANDLER,
66442 ZEND_NULL_HANDLER,
66443 ZEND_NULL_HANDLER,
66444 ZEND_NULL_HANDLER,
66445 ZEND_NULL_HANDLER,
66446 ZEND_NULL_HANDLER,
66447 ZEND_NULL_HANDLER,
66448 ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER,
66449 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66450 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
66451 ZEND_NULL_HANDLER,
66452 ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER,
66453 ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
66454 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66455 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66456 ZEND_NULL_HANDLER,
66457 ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
66458 ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER,
66459 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66460 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
66461 ZEND_NULL_HANDLER,
66462 ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER,
66463 ZEND_ECHO_SPEC_CONST_HANDLER,
66464 ZEND_ECHO_SPEC_TMPVAR_HANDLER,
66465 ZEND_ECHO_SPEC_TMPVAR_HANDLER,
66466 ZEND_NULL_HANDLER,
66467 ZEND_ECHO_SPEC_CV_HANDLER,
66468 ZEND_NULL_HANDLER,
66469 ZEND_NULL_HANDLER,
66470 ZEND_NULL_HANDLER,
66471 ZEND_NULL_HANDLER,
66472 ZEND_NULL_HANDLER,
66473 ZEND_NULL_HANDLER,
66474 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
66475 ZEND_NULL_HANDLER,
66476 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
66477 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER,
66478 ZEND_NULL_HANDLER,
66479 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
66480 ZEND_NULL_HANDLER,
66481 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
66482 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER,
66483 ZEND_NULL_HANDLER,
66484 ZEND_NULL_HANDLER,
66485 ZEND_NULL_HANDLER,
66486 ZEND_NULL_HANDLER,
66487 ZEND_NULL_HANDLER,
66488 ZEND_NULL_HANDLER,
66489 ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER,
66490 ZEND_NULL_HANDLER,
66491 ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER,
66492 ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER,
66493 ZEND_NULL_HANDLER,
66494 ZEND_GENERATOR_CREATE_SPEC_HANDLER,
66495 ZEND_NULL_HANDLER,
66496 ZEND_NULL_HANDLER,
66497 ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER,
66498 ZEND_NULL_HANDLER,
66499 ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER,
66500 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
66501 ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER,
66502 ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER,
66503 ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER,
66504 ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER,
66505 ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER,
66506 ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER,
66507 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER,
66508 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66509 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
66510 ZEND_NULL_HANDLER,
66511 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER,
66512 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66513 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66514 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66515 ZEND_NULL_HANDLER,
66516 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
66517 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
66518 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66519 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
66520 ZEND_NULL_HANDLER,
66521 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
66522 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER,
66523 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66524 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
66525 ZEND_NULL_HANDLER,
66526 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER,
66527 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER,
66528 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
66529 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
66530 ZEND_NULL_HANDLER,
66531 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER,
66532 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
66533 ZEND_USER_OPCODE_SPEC_HANDLER,
66534 ZEND_ASSERT_CHECK_SPEC_HANDLER,
66535 ZEND_JMP_SET_SPEC_CONST_HANDLER,
66536 ZEND_JMP_SET_SPEC_TMP_HANDLER,
66537 ZEND_JMP_SET_SPEC_VAR_HANDLER,
66538 ZEND_NULL_HANDLER,
66539 ZEND_JMP_SET_SPEC_CV_HANDLER,
66540 ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER,
66541 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER,
66542 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER,
66543 ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER,
66544 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
66545 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
66546 ZEND_NULL_HANDLER,
66547 ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER,
66548 ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER,
66549 ZEND_NULL_HANDLER,
66550 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
66551 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
66552 ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER,
66553 ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER,
66554 ZEND_CALL_TRAMPOLINE_SPEC_HANDLER,
66555 ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER,
66556 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
66557 ZEND_YIELD_SPEC_CONST_CONST_HANDLER,
66558 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
66559 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
66560 ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER,
66561 ZEND_YIELD_SPEC_CONST_CV_HANDLER,
66562 ZEND_YIELD_SPEC_TMP_CONST_HANDLER,
66563 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
66564 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
66565 ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER,
66566 ZEND_YIELD_SPEC_TMP_CV_HANDLER,
66567 ZEND_YIELD_SPEC_VAR_CONST_HANDLER,
66568 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
66569 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
66570 ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER,
66571 ZEND_YIELD_SPEC_VAR_CV_HANDLER,
66572 ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER,
66573 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
66574 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
66575 ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER,
66576 ZEND_YIELD_SPEC_UNUSED_CV_HANDLER,
66577 ZEND_YIELD_SPEC_CV_CONST_HANDLER,
66578 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
66579 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
66580 ZEND_YIELD_SPEC_CV_UNUSED_HANDLER,
66581 ZEND_YIELD_SPEC_CV_CV_HANDLER,
66582 ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER,
66583 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66584 ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER,
66585 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66586 ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER,
66587 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66588 ZEND_NULL_HANDLER,
66589 ZEND_NULL_HANDLER,
66590 ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER,
66591 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
66592 ZEND_FAST_CALL_SPEC_HANDLER,
66593 ZEND_FAST_RET_SPEC_HANDLER,
66594 ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER,
66595 ZEND_SEND_UNPACK_SPEC_HANDLER,
66596 ZEND_YIELD_FROM_SPEC_CONST_HANDLER,
66597 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
66598 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
66599 ZEND_NULL_HANDLER,
66600 ZEND_YIELD_FROM_SPEC_CV_HANDLER,
66601 ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER,
66602 ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER,
66603 ZEND_COALESCE_SPEC_CONST_HANDLER,
66604 ZEND_COALESCE_SPEC_TMP_HANDLER,
66605 ZEND_COALESCE_SPEC_VAR_HANDLER,
66606 ZEND_NULL_HANDLER,
66607 ZEND_COALESCE_SPEC_CV_HANDLER,
66608 ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER,
66609 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
66610 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
66611 ZEND_NULL_HANDLER,
66612 ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER,
66613 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
66614 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66615 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66616 ZEND_NULL_HANDLER,
66617 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
66618 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
66619 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66620 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
66621 ZEND_NULL_HANDLER,
66622 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
66623 ZEND_NULL_HANDLER,
66624 ZEND_NULL_HANDLER,
66625 ZEND_NULL_HANDLER,
66626 ZEND_NULL_HANDLER,
66627 ZEND_NULL_HANDLER,
66628 ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER,
66629 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
66630 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
66631 ZEND_NULL_HANDLER,
66632 ZEND_SPACESHIP_SPEC_CV_CV_HANDLER,
66633 ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66634 ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER,
66635 ZEND_NULL_HANDLER,
66636 ZEND_NULL_HANDLER,
66637 ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66638 ZEND_NULL_HANDLER,
66639 ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER,
66640 ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER,
66641 ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER,
66642 ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER,
66643 ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER,
66644 ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER,
66645 ZEND_UNSET_STATIC_PROP_SPEC_HANDLER,
66646 ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER,
66647 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER,
66648 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66649 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66650 ZEND_NULL_HANDLER,
66651 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
66652 ZEND_NULL_HANDLER,
66653 ZEND_NULL_HANDLER,
66654 ZEND_NULL_HANDLER,
66655 ZEND_NULL_HANDLER,
66656 ZEND_NULL_HANDLER,
66657 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER,
66658 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66659 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66660 ZEND_NULL_HANDLER,
66661 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
66662 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
66663 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66664 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66665 ZEND_NULL_HANDLER,
66666 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
66667 ZEND_NULL_HANDLER,
66668 ZEND_NULL_HANDLER,
66669 ZEND_NULL_HANDLER,
66670 ZEND_NULL_HANDLER,
66671 ZEND_NULL_HANDLER,
66672 ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER,
66673 ZEND_BIND_STATIC_SPEC_CV_HANDLER,
66674 ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER,
66675 ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
66676 ZEND_NULL_HANDLER,
66677 ZEND_NULL_HANDLER,
66678 ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
66679 ZEND_NULL_HANDLER,
66680 ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER,
66681 ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER,
66682 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66683 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66684 ZEND_NULL_HANDLER,
66685 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66686 ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER,
66687 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66688 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66689 ZEND_NULL_HANDLER,
66690 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
66691 ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER,
66692 ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER,
66693 ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER,
66694 ZEND_NULL_HANDLER,
66695 ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER,
66696 ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER,
66697 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
66698 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
66699 ZEND_NULL_HANDLER,
66700 ZEND_COUNT_SPEC_CV_UNUSED_HANDLER,
66701 ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER,
66702 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
66703 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
66704 ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66705 ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER,
66706 ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
66707 ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER,
66708 ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER,
66709 ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER,
66710 ZEND_NULL_HANDLER,
66711 ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER,
66712 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER,
66713 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
66714 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
66715 ZEND_NULL_HANDLER,
66716 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER,
66717 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
66718 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66719 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66720 ZEND_NULL_HANDLER,
66721 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
66722 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
66723 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66724 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
66725 ZEND_NULL_HANDLER,
66726 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
66727 ZEND_NULL_HANDLER,
66728 ZEND_NULL_HANDLER,
66729 ZEND_NULL_HANDLER,
66730 ZEND_NULL_HANDLER,
66731 ZEND_NULL_HANDLER,
66732 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER,
66733 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
66734 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
66735 ZEND_NULL_HANDLER,
66736 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER,
66737 ZEND_MATCH_SPEC_CONST_CONST_HANDLER,
66738 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66739 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66740 ZEND_NULL_HANDLER,
66741 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
66742 ZEND_NULL_HANDLER,
66743 ZEND_NULL_HANDLER,
66744 ZEND_NULL_HANDLER,
66745 ZEND_NULL_HANDLER,
66746 ZEND_NULL_HANDLER,
66747 ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER,
66748 ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER,
66749 ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER,
66750 ZEND_NULL_HANDLER,
66751 ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER,
66752 ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER,
66753 ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER,
66754 ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER,
66755 ZEND_NULL_HANDLER,
66756 ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER,
66757 ZEND_NULL_HANDLER,
66758 ZEND_NULL_HANDLER,
66759 ZEND_NULL_HANDLER,
66760 ZEND_NULL_HANDLER,
66761 ZEND_NULL_HANDLER,
66762 ZEND_NULL_HANDLER,
66763 ZEND_NULL_HANDLER,
66764 ZEND_NULL_HANDLER,
66765 ZEND_NULL_HANDLER,
66766 ZEND_NULL_HANDLER,
66767 ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER,
66768 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66769 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66770 ZEND_NULL_HANDLER,
66771 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
66772 ZEND_JMP_NULL_SPEC_CONST_HANDLER,
66773 ZEND_JMP_NULL_SPEC_TMP_HANDLER,
66774 ZEND_JMP_NULL_SPEC_VAR_HANDLER,
66775 ZEND_NULL_HANDLER,
66776 ZEND_JMP_NULL_SPEC_CV_HANDLER,
66777 ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
66778 ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER,
66779 ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
66780 ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER,
66781 ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER,
66782 ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER,
66783 ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER_HANDLER,
66784 ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER,
66785 ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER_HANDLER,
66786 ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER,
66787 ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER_HANDLER,
66788 ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER,
66789 ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER,
66790 ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER,
66791 ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER,
66792 ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER,
66793 ZEND_RECV_NOTYPE_SPEC_HANDLER,
66794 ZEND_NULL_HANDLER,
66795 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
66796 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
66797 ZEND_NULL_HANDLER,
66798 ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER,
66799 ZEND_JMP_FORWARD_SPEC_HANDLER,
66800 ZEND_NULL_HANDLER,
66801 ZEND_NULL_HANDLER,
66802 ZEND_NULL_HANDLER,
66803 ZEND_NULL_HANDLER,
66804 ZEND_NULL_HANDLER,
66805 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66806 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66807 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66808 ZEND_NULL_HANDLER,
66809 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66810 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66811 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66812 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66813 ZEND_NULL_HANDLER,
66814 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66815 ZEND_NULL_HANDLER,
66816 ZEND_NULL_HANDLER,
66817 ZEND_NULL_HANDLER,
66818 ZEND_NULL_HANDLER,
66819 ZEND_NULL_HANDLER,
66820 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66821 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66822 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66823 ZEND_NULL_HANDLER,
66824 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66825 ZEND_NULL_HANDLER,
66826 ZEND_NULL_HANDLER,
66827 ZEND_NULL_HANDLER,
66828 ZEND_NULL_HANDLER,
66829 ZEND_NULL_HANDLER,
66830 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66831 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66832 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66833 ZEND_NULL_HANDLER,
66834 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66835 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66836 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66837 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66838 ZEND_NULL_HANDLER,
66839 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66840 ZEND_NULL_HANDLER,
66841 ZEND_NULL_HANDLER,
66842 ZEND_NULL_HANDLER,
66843 ZEND_NULL_HANDLER,
66844 ZEND_NULL_HANDLER,
66845 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66846 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66847 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66848 ZEND_NULL_HANDLER,
66849 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66850 ZEND_NULL_HANDLER,
66851 ZEND_NULL_HANDLER,
66852 ZEND_NULL_HANDLER,
66853 ZEND_NULL_HANDLER,
66854 ZEND_NULL_HANDLER,
66855 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66856 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66857 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66858 ZEND_NULL_HANDLER,
66859 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66860 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66861 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66862 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66863 ZEND_NULL_HANDLER,
66864 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66865 ZEND_NULL_HANDLER,
66866 ZEND_NULL_HANDLER,
66867 ZEND_NULL_HANDLER,
66868 ZEND_NULL_HANDLER,
66869 ZEND_NULL_HANDLER,
66870 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66871 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66872 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66873 ZEND_NULL_HANDLER,
66874 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66875 ZEND_NULL_HANDLER,
66876 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
66877 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
66878 ZEND_NULL_HANDLER,
66879 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
66880 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66881 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66882 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66883 ZEND_NULL_HANDLER,
66884 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66885 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66886 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66887 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66888 ZEND_NULL_HANDLER,
66889 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66890 ZEND_NULL_HANDLER,
66891 ZEND_NULL_HANDLER,
66892 ZEND_NULL_HANDLER,
66893 ZEND_NULL_HANDLER,
66894 ZEND_NULL_HANDLER,
66895 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66896 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66897 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66898 ZEND_NULL_HANDLER,
66899 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66900 ZEND_NULL_HANDLER,
66901 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66902 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66903 ZEND_NULL_HANDLER,
66904 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66905 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66906 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66907 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66908 ZEND_NULL_HANDLER,
66909 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66910 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66911 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66912 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66913 ZEND_NULL_HANDLER,
66914 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66915 ZEND_NULL_HANDLER,
66916 ZEND_NULL_HANDLER,
66917 ZEND_NULL_HANDLER,
66918 ZEND_NULL_HANDLER,
66919 ZEND_NULL_HANDLER,
66920 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66921 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66922 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66923 ZEND_NULL_HANDLER,
66924 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66925 ZEND_NULL_HANDLER,
66926 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66927 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66928 ZEND_NULL_HANDLER,
66929 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66930 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66931 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66932 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66933 ZEND_NULL_HANDLER,
66934 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66935 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66936 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66937 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66938 ZEND_NULL_HANDLER,
66939 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66940 ZEND_NULL_HANDLER,
66941 ZEND_NULL_HANDLER,
66942 ZEND_NULL_HANDLER,
66943 ZEND_NULL_HANDLER,
66944 ZEND_NULL_HANDLER,
66945 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66946 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66947 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66948 ZEND_NULL_HANDLER,
66949 ZEND_SUB_DOUBLE_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_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66956 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66957 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66958 ZEND_NULL_HANDLER,
66959 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66960 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66961 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66962 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66963 ZEND_NULL_HANDLER,
66964 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66965 ZEND_NULL_HANDLER,
66966 ZEND_NULL_HANDLER,
66967 ZEND_NULL_HANDLER,
66968 ZEND_NULL_HANDLER,
66969 ZEND_NULL_HANDLER,
66970 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
66971 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66972 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66973 ZEND_NULL_HANDLER,
66974 ZEND_MUL_LONG_NO_OVERFLOW_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_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66981 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66982 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66983 ZEND_NULL_HANDLER,
66984 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66985 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66986 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66987 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66988 ZEND_NULL_HANDLER,
66989 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66990 ZEND_NULL_HANDLER,
66991 ZEND_NULL_HANDLER,
66992 ZEND_NULL_HANDLER,
66993 ZEND_NULL_HANDLER,
66994 ZEND_NULL_HANDLER,
66995 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66996 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66997 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66998 ZEND_NULL_HANDLER,
66999 ZEND_MUL_LONG_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_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67006 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67007 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67008 ZEND_NULL_HANDLER,
67009 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67010 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67011 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67012 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67013 ZEND_NULL_HANDLER,
67014 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67015 ZEND_NULL_HANDLER,
67016 ZEND_NULL_HANDLER,
67017 ZEND_NULL_HANDLER,
67018 ZEND_NULL_HANDLER,
67019 ZEND_NULL_HANDLER,
67020 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67021 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67022 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67023 ZEND_NULL_HANDLER,
67024 ZEND_MUL_DOUBLE_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_NULL_HANDLER,
67031 ZEND_NULL_HANDLER,
67032 ZEND_NULL_HANDLER,
67033 ZEND_NULL_HANDLER,
67034 ZEND_NULL_HANDLER,
67035 ZEND_NULL_HANDLER,
67036 ZEND_NULL_HANDLER,
67037 ZEND_NULL_HANDLER,
67038 ZEND_NULL_HANDLER,
67039 ZEND_NULL_HANDLER,
67040 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67041 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67042 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67043 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67044 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67045 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67046 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67047 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67048 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67049 ZEND_NULL_HANDLER,
67050 ZEND_NULL_HANDLER,
67051 ZEND_NULL_HANDLER,
67052 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67053 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67054 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67055 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67056 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67057 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67058 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67059 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67060 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67061 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67062 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67063 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67064 ZEND_NULL_HANDLER,
67065 ZEND_NULL_HANDLER,
67066 ZEND_NULL_HANDLER,
67067 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67068 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67069 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67070 ZEND_NULL_HANDLER,
67071 ZEND_NULL_HANDLER,
67072 ZEND_NULL_HANDLER,
67073 ZEND_NULL_HANDLER,
67074 ZEND_NULL_HANDLER,
67075 ZEND_NULL_HANDLER,
67076 ZEND_NULL_HANDLER,
67077 ZEND_NULL_HANDLER,
67078 ZEND_NULL_HANDLER,
67079 ZEND_NULL_HANDLER,
67080 ZEND_NULL_HANDLER,
67081 ZEND_NULL_HANDLER,
67082 ZEND_NULL_HANDLER,
67083 ZEND_NULL_HANDLER,
67084 ZEND_NULL_HANDLER,
67085 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67086 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67087 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67088 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67089 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67090 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67091 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67092 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67093 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67094 ZEND_NULL_HANDLER,
67095 ZEND_NULL_HANDLER,
67096 ZEND_NULL_HANDLER,
67097 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67098 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67099 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67100 ZEND_NULL_HANDLER,
67101 ZEND_NULL_HANDLER,
67102 ZEND_NULL_HANDLER,
67103 ZEND_NULL_HANDLER,
67104 ZEND_NULL_HANDLER,
67105 ZEND_NULL_HANDLER,
67106 ZEND_NULL_HANDLER,
67107 ZEND_NULL_HANDLER,
67108 ZEND_NULL_HANDLER,
67109 ZEND_NULL_HANDLER,
67110 ZEND_NULL_HANDLER,
67111 ZEND_NULL_HANDLER,
67112 ZEND_NULL_HANDLER,
67113 ZEND_NULL_HANDLER,
67114 ZEND_NULL_HANDLER,
67115 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67116 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67117 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67118 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67119 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67120 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67121 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67122 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67123 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67124 ZEND_NULL_HANDLER,
67125 ZEND_NULL_HANDLER,
67126 ZEND_NULL_HANDLER,
67127 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67128 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67129 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67130 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67131 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67132 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67133 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67134 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67135 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67136 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67137 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67138 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67139 ZEND_NULL_HANDLER,
67140 ZEND_NULL_HANDLER,
67141 ZEND_NULL_HANDLER,
67142 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67143 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67144 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67145 ZEND_NULL_HANDLER,
67146 ZEND_NULL_HANDLER,
67147 ZEND_NULL_HANDLER,
67148 ZEND_NULL_HANDLER,
67149 ZEND_NULL_HANDLER,
67150 ZEND_NULL_HANDLER,
67151 ZEND_NULL_HANDLER,
67152 ZEND_NULL_HANDLER,
67153 ZEND_NULL_HANDLER,
67154 ZEND_NULL_HANDLER,
67155 ZEND_NULL_HANDLER,
67156 ZEND_NULL_HANDLER,
67157 ZEND_NULL_HANDLER,
67158 ZEND_NULL_HANDLER,
67159 ZEND_NULL_HANDLER,
67160 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67161 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67162 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67163 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67164 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67165 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67166 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67167 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67168 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67169 ZEND_NULL_HANDLER,
67170 ZEND_NULL_HANDLER,
67171 ZEND_NULL_HANDLER,
67172 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67173 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67174 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67175 ZEND_NULL_HANDLER,
67176 ZEND_NULL_HANDLER,
67177 ZEND_NULL_HANDLER,
67178 ZEND_NULL_HANDLER,
67179 ZEND_NULL_HANDLER,
67180 ZEND_NULL_HANDLER,
67181 ZEND_NULL_HANDLER,
67182 ZEND_NULL_HANDLER,
67183 ZEND_NULL_HANDLER,
67184 ZEND_NULL_HANDLER,
67185 ZEND_NULL_HANDLER,
67186 ZEND_NULL_HANDLER,
67187 ZEND_NULL_HANDLER,
67188 ZEND_NULL_HANDLER,
67189 ZEND_NULL_HANDLER,
67190 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67191 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67192 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67193 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67194 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67195 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67196 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67197 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67198 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67199 ZEND_NULL_HANDLER,
67200 ZEND_NULL_HANDLER,
67201 ZEND_NULL_HANDLER,
67202 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67203 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67204 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67205 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67206 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67207 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67208 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67209 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67210 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67211 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67212 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67213 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67214 ZEND_NULL_HANDLER,
67215 ZEND_NULL_HANDLER,
67216 ZEND_NULL_HANDLER,
67217 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67218 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67219 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67220 ZEND_NULL_HANDLER,
67221 ZEND_NULL_HANDLER,
67222 ZEND_NULL_HANDLER,
67223 ZEND_NULL_HANDLER,
67224 ZEND_NULL_HANDLER,
67225 ZEND_NULL_HANDLER,
67226 ZEND_NULL_HANDLER,
67227 ZEND_NULL_HANDLER,
67228 ZEND_NULL_HANDLER,
67229 ZEND_NULL_HANDLER,
67230 ZEND_NULL_HANDLER,
67231 ZEND_NULL_HANDLER,
67232 ZEND_NULL_HANDLER,
67233 ZEND_NULL_HANDLER,
67234 ZEND_NULL_HANDLER,
67235 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67236 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67237 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67238 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67239 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67240 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67241 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67242 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67243 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67244 ZEND_NULL_HANDLER,
67245 ZEND_NULL_HANDLER,
67246 ZEND_NULL_HANDLER,
67247 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67248 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67249 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67250 ZEND_NULL_HANDLER,
67251 ZEND_NULL_HANDLER,
67252 ZEND_NULL_HANDLER,
67253 ZEND_NULL_HANDLER,
67254 ZEND_NULL_HANDLER,
67255 ZEND_NULL_HANDLER,
67256 ZEND_NULL_HANDLER,
67257 ZEND_NULL_HANDLER,
67258 ZEND_NULL_HANDLER,
67259 ZEND_NULL_HANDLER,
67260 ZEND_NULL_HANDLER,
67261 ZEND_NULL_HANDLER,
67262 ZEND_NULL_HANDLER,
67263 ZEND_NULL_HANDLER,
67264 ZEND_NULL_HANDLER,
67265 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67266 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67267 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67268 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67269 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67270 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67271 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67272 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67273 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67274 ZEND_NULL_HANDLER,
67275 ZEND_NULL_HANDLER,
67276 ZEND_NULL_HANDLER,
67277 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67278 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67279 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67280 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67281 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67282 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67283 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67284 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67285 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67286 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67287 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67288 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67289 ZEND_NULL_HANDLER,
67290 ZEND_NULL_HANDLER,
67291 ZEND_NULL_HANDLER,
67292 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67293 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67294 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67295 ZEND_NULL_HANDLER,
67296 ZEND_NULL_HANDLER,
67297 ZEND_NULL_HANDLER,
67298 ZEND_NULL_HANDLER,
67299 ZEND_NULL_HANDLER,
67300 ZEND_NULL_HANDLER,
67301 ZEND_NULL_HANDLER,
67302 ZEND_NULL_HANDLER,
67303 ZEND_NULL_HANDLER,
67304 ZEND_NULL_HANDLER,
67305 ZEND_NULL_HANDLER,
67306 ZEND_NULL_HANDLER,
67307 ZEND_NULL_HANDLER,
67308 ZEND_NULL_HANDLER,
67309 ZEND_NULL_HANDLER,
67310 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67311 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67312 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67313 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67314 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67315 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67316 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67317 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67318 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67319 ZEND_NULL_HANDLER,
67320 ZEND_NULL_HANDLER,
67321 ZEND_NULL_HANDLER,
67322 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67323 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67324 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67325 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
67326 ZEND_NULL_HANDLER,
67327 ZEND_NULL_HANDLER,
67328 ZEND_NULL_HANDLER,
67329 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
67330 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
67331 ZEND_NULL_HANDLER,
67332 ZEND_NULL_HANDLER,
67333 ZEND_NULL_HANDLER,
67334 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
67335 ZEND_NULL_HANDLER,
67336 ZEND_NULL_HANDLER,
67337 ZEND_NULL_HANDLER,
67338 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67339 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67340 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67341 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67342 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67343 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67344 ZEND_NULL_HANDLER,
67345 ZEND_NULL_HANDLER,
67346 ZEND_NULL_HANDLER,
67347 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67348 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67349 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67350 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67351 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67352 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67353 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67354 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67355 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67356 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67357 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67358 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67359 ZEND_NULL_HANDLER,
67360 ZEND_NULL_HANDLER,
67361 ZEND_NULL_HANDLER,
67362 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67363 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67364 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67365 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67366 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67367 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67368 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67369 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67370 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67371 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67372 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67373 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67374 ZEND_NULL_HANDLER,
67375 ZEND_NULL_HANDLER,
67376 ZEND_NULL_HANDLER,
67377 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67378 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67379 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67380 ZEND_NULL_HANDLER,
67381 ZEND_NULL_HANDLER,
67382 ZEND_NULL_HANDLER,
67383 ZEND_NULL_HANDLER,
67384 ZEND_NULL_HANDLER,
67385 ZEND_NULL_HANDLER,
67386 ZEND_NULL_HANDLER,
67387 ZEND_NULL_HANDLER,
67388 ZEND_NULL_HANDLER,
67389 ZEND_NULL_HANDLER,
67390 ZEND_NULL_HANDLER,
67391 ZEND_NULL_HANDLER,
67392 ZEND_NULL_HANDLER,
67393 ZEND_NULL_HANDLER,
67394 ZEND_NULL_HANDLER,
67395 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67396 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67397 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67398 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67399 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67400 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67401 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67402 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67403 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67404 ZEND_NULL_HANDLER,
67405 ZEND_NULL_HANDLER,
67406 ZEND_NULL_HANDLER,
67407 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67408 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67409 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67410 ZEND_NULL_HANDLER,
67411 ZEND_NULL_HANDLER,
67412 ZEND_NULL_HANDLER,
67413 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67414 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67415 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67416 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67417 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67418 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67419 ZEND_NULL_HANDLER,
67420 ZEND_NULL_HANDLER,
67421 ZEND_NULL_HANDLER,
67422 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67423 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67424 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67425 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67426 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67427 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67428 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67429 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67430 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67431 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67432 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67433 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67434 ZEND_NULL_HANDLER,
67435 ZEND_NULL_HANDLER,
67436 ZEND_NULL_HANDLER,
67437 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67438 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67439 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67440 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67441 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67442 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67443 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67444 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67445 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67446 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67447 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67448 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67449 ZEND_NULL_HANDLER,
67450 ZEND_NULL_HANDLER,
67451 ZEND_NULL_HANDLER,
67452 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67453 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67454 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67455 ZEND_NULL_HANDLER,
67456 ZEND_NULL_HANDLER,
67457 ZEND_NULL_HANDLER,
67458 ZEND_NULL_HANDLER,
67459 ZEND_NULL_HANDLER,
67460 ZEND_NULL_HANDLER,
67461 ZEND_NULL_HANDLER,
67462 ZEND_NULL_HANDLER,
67463 ZEND_NULL_HANDLER,
67464 ZEND_NULL_HANDLER,
67465 ZEND_NULL_HANDLER,
67466 ZEND_NULL_HANDLER,
67467 ZEND_NULL_HANDLER,
67468 ZEND_NULL_HANDLER,
67469 ZEND_NULL_HANDLER,
67470 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67471 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67472 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67473 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67474 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67475 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67476 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67477 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67478 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67479 ZEND_NULL_HANDLER,
67480 ZEND_NULL_HANDLER,
67481 ZEND_NULL_HANDLER,
67482 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67483 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67484 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67485 ZEND_NULL_HANDLER,
67486 ZEND_NULL_HANDLER,
67487 ZEND_NULL_HANDLER,
67488 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67489 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67490 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67491 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67492 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67493 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67494 ZEND_NULL_HANDLER,
67495 ZEND_NULL_HANDLER,
67496 ZEND_NULL_HANDLER,
67497 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
67498 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67499 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67500 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67501 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67502 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67503 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67504 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67505 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67506 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67507 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67508 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67509 ZEND_NULL_HANDLER,
67510 ZEND_NULL_HANDLER,
67511 ZEND_NULL_HANDLER,
67512 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67513 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67514 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67515 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67516 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67517 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67518 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67519 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67520 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67521 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67522 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67523 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67524 ZEND_NULL_HANDLER,
67525 ZEND_NULL_HANDLER,
67526 ZEND_NULL_HANDLER,
67527 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67528 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67529 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67530 ZEND_NULL_HANDLER,
67531 ZEND_NULL_HANDLER,
67532 ZEND_NULL_HANDLER,
67533 ZEND_NULL_HANDLER,
67534 ZEND_NULL_HANDLER,
67535 ZEND_NULL_HANDLER,
67536 ZEND_NULL_HANDLER,
67537 ZEND_NULL_HANDLER,
67538 ZEND_NULL_HANDLER,
67539 ZEND_NULL_HANDLER,
67540 ZEND_NULL_HANDLER,
67541 ZEND_NULL_HANDLER,
67542 ZEND_NULL_HANDLER,
67543 ZEND_NULL_HANDLER,
67544 ZEND_NULL_HANDLER,
67545 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
67546 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67547 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67548 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67549 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67550 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67551 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67552 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67553 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67554 ZEND_NULL_HANDLER,
67555 ZEND_NULL_HANDLER,
67556 ZEND_NULL_HANDLER,
67557 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67558 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67559 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67560 ZEND_NULL_HANDLER,
67561 ZEND_NULL_HANDLER,
67562 ZEND_NULL_HANDLER,
67563 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67564 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67565 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67566 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67567 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67568 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67569 ZEND_NULL_HANDLER,
67570 ZEND_NULL_HANDLER,
67571 ZEND_NULL_HANDLER,
67572 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
67573 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
67574 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
67575 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67576 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67577 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67578 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67579 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67580 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67581 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67582 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67583 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67584 ZEND_NULL_HANDLER,
67585 ZEND_NULL_HANDLER,
67586 ZEND_NULL_HANDLER,
67587 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67588 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67589 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67590 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67591 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67592 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67593 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67594 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67595 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67596 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67597 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67598 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67599 ZEND_NULL_HANDLER,
67600 ZEND_NULL_HANDLER,
67601 ZEND_NULL_HANDLER,
67602 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67603 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67604 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67605 ZEND_NULL_HANDLER,
67606 ZEND_NULL_HANDLER,
67607 ZEND_NULL_HANDLER,
67608 ZEND_NULL_HANDLER,
67609 ZEND_NULL_HANDLER,
67610 ZEND_NULL_HANDLER,
67611 ZEND_NULL_HANDLER,
67612 ZEND_NULL_HANDLER,
67613 ZEND_NULL_HANDLER,
67614 ZEND_NULL_HANDLER,
67615 ZEND_NULL_HANDLER,
67616 ZEND_NULL_HANDLER,
67617 ZEND_NULL_HANDLER,
67618 ZEND_NULL_HANDLER,
67619 ZEND_NULL_HANDLER,
67620 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
67621 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
67622 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
67623 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67624 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67625 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67626 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67627 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67628 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67629 ZEND_NULL_HANDLER,
67630 ZEND_NULL_HANDLER,
67631 ZEND_NULL_HANDLER,
67632 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
67633 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
67634 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
67635 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
67636 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
67637 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
67638 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
67639 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
67640 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
67641 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
67642 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
67643 ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
67644 ZEND_POST_INC_LONG_SPEC_CV_HANDLER,
67645 ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
67646 ZEND_POST_DEC_LONG_SPEC_CV_HANDLER,
67647 ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER,
67648 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67649 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67650 ZEND_NULL_HANDLER,
67651 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
67652 ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER,
67653 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67654 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67655 ZEND_NULL_HANDLER,
67656 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
67657 ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER,
67658 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67659 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67660 ZEND_NULL_HANDLER,
67661 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
67662 ZEND_NULL_HANDLER,
67663 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67664 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67665 ZEND_NULL_HANDLER,
67666 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
67667 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
67668 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67669 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67670 ZEND_NULL_HANDLER,
67671 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67672 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
67673 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67674 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67675 ZEND_NULL_HANDLER,
67676 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
67677 ZEND_NULL_HANDLER,
67678 ZEND_NULL_HANDLER,
67679 ZEND_NULL_HANDLER,
67680 ZEND_NULL_HANDLER,
67681 ZEND_NULL_HANDLER,
67682 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER,
67683 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67684 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67685 ZEND_NULL_HANDLER,
67686 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
67687 ZEND_NULL_HANDLER,
67688 ZEND_NULL_HANDLER,
67689 ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER,
67690 ZEND_NULL_HANDLER,
67691 ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER,
67692 ZEND_NULL_HANDLER,
67693 ZEND_NULL_HANDLER,
67694 ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER,
67695 ZEND_NULL_HANDLER,
67696 ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER,
67697 ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER,
67698 ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER,
67699 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
67700 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER,
67701 ZEND_NULL_HANDLER
67702 };
67703 static const uint32_t specs[] = {
67704 0,
67705 1 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67706 26 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67707 51 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67708 76 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67709 101 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67710 126 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67711 151 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67712 176 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67713 201 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67714 226 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67715 251 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67716 276 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67717 301 | SPEC_RULE_OP1,
67718 306 | SPEC_RULE_OP1,
67719 311 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67720 336 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67721 361 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
67722 386 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
67723 461 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
67724 536 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
67725 611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
67726 686 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL,
67727 736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67728 861 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67729 986 | SPEC_RULE_OP_DATA,
67730 991 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67731 1016 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67732 1041 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67733 1066,
67734 1067 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67735 1092 | SPEC_RULE_OP1,
67736 1097 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
67737 1222,
67738 1223 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
67739 1233 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
67740 1243 | SPEC_RULE_OP1,
67741 1248 | SPEC_RULE_OP1,
67742 1253,
67743 1253,
67744 1254,
67745 1254,
67746 1255,
67747 1256 | SPEC_RULE_OP1,
67748 1261 | SPEC_RULE_OP1,
67749 3486,
67750 1266 | SPEC_RULE_OP1,
67751 1271 | SPEC_RULE_OP1,
67752 1276 | SPEC_RULE_OP2,
67753 1281,
67754 1282 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67755 1292 | SPEC_RULE_OP1,
67756 1297 | SPEC_RULE_OP1,
67757 1302 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67758 1327 | SPEC_RULE_OP2,
67759 1332 | SPEC_RULE_OP2,
67760 1337 | SPEC_RULE_OP2,
67761 1342,
67762 1343,
67763 1344,
67764 1345 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
67765 1349,
67766 1350 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67767 1360,
67768 1361,
67769 1362 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67770 1387 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67771 1437 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67772 1462 | SPEC_RULE_OP1,
67773 1467,
67774 1468,
67775 1469 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67776 1494 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67777 1519 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67778 1529 | SPEC_RULE_OP1,
67779 1534 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67780 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67781 1584 | SPEC_RULE_OP1,
67782 1589,
67783 3486,
67784 1590 | SPEC_RULE_OP1,
67785 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67786 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67787 1645 | SPEC_RULE_OP1,
67788 1650 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67789 1675 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67790 1700 | SPEC_RULE_OP1,
67791 1705 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67792 1730 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67793 1755 | SPEC_RULE_OP1,
67794 1760 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67795 1785 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67796 1810 | SPEC_RULE_OP1,
67797 1815 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67798 1840 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67799 1865 | SPEC_RULE_OP1,
67800 1870 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67801 1895 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67802 1920 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67803 1945,
67804 1946 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67805 1956,
67806 1957,
67807 1958,
67808 1959,
67809 1960,
67810 1961 | SPEC_RULE_OP2,
67811 1966,
67812 1967 | SPEC_RULE_OP1,
67813 1972 | SPEC_RULE_OP2,
67814 1977 | SPEC_RULE_OP1,
67815 1982 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67816 1992 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67817 2017 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67818 2042 | SPEC_RULE_OP1,
67819 2047 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67820 2072 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
67821 2122 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67822 2147 | SPEC_RULE_OP2,
67823 2152,
67824 2153 | SPEC_RULE_OP1,
67825 2158 | SPEC_RULE_OP1,
67826 2163,
67827 2164 | SPEC_RULE_OP1,
67828 2169 | SPEC_RULE_OP1,
67829 2174 | SPEC_RULE_OP1,
67830 2179,
67831 2180,
67832 2181 | SPEC_RULE_OP2,
67833 2186 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
67834 2190 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
67835 2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
67836 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67837 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67838 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67839 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67840 2248 | SPEC_RULE_OP1,
67841 2253,
67842 2254 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67843 2279,
67844 2280 | SPEC_RULE_OP1,
67845 2285,
67846 2286,
67847 2287,
67848 2288,
67849 2289,
67850 2290,
67851 2291,
67852 2292 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67853 2317,
67854 2318,
67855 2319,
67856 2320 | SPEC_RULE_OP1,
67857 2325,
67858 2326 | SPEC_RULE_ISSET,
67859 2328 | SPEC_RULE_OP2,
67860 2333,
67861 2334 | SPEC_RULE_OP1,
67862 2339 | SPEC_RULE_OBSERVER,
67863 2341,
67864 2342 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67865 2367 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
67866 2377,
67867 2378,
67868 2379,
67869 2380,
67870 2381 | SPEC_RULE_OP1,
67871 2386,
67872 2387,
67873 2388 | SPEC_RULE_OP1,
67874 2393 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67875 2418,
67876 2419 | SPEC_RULE_OP1,
67877 2424,
67878 2425,
67879 2426,
67880 2427,
67881 2428,
67882 2429,
67883 2430,
67884 2431,
67885 2432 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67886 2457,
67887 2458,
67888 2459,
67889 2460 | SPEC_RULE_OP2,
67890 2465,
67891 2466 | SPEC_RULE_OP1,
67892 2471 | SPEC_RULE_OP1,
67893 2476 | SPEC_RULE_OP1,
67894 2481 | SPEC_RULE_OP1,
67895 2486 | SPEC_RULE_OP1,
67896 2491,
67897 2492 | SPEC_RULE_OP1,
67898 2497 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67899 2522 | SPEC_RULE_OP1,
67900 2527 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
67901 2552 | SPEC_RULE_OP1,
67902 2557 | SPEC_RULE_OP1,
67903 2562,
67904 2563,
67905 2564,
67906 2565,
67907 2566,
67908 2567 | SPEC_RULE_OBSERVER,
67909 2569 | SPEC_RULE_OBSERVER,
67910 2571 | SPEC_RULE_OBSERVER,
67911 2573 | SPEC_RULE_OBSERVER,
67912 2575,
67913 2576,
67914 3486,
67915 3486,
67916 3486,
67917 3486,
67918 3486,
67919 3486,
67920 3486,
67921 3486,
67922 3486,
67923 3486,
67924 3486,
67925 3486,
67926 3486,
67927 3486,
67928 3486,
67929 3486,
67930 3486,
67931 3486,
67932 3486,
67933 3486,
67934 3486,
67935 3486,
67936 3486,
67937 3486,
67938 3486,
67939 3486,
67940 3486,
67941 3486,
67942 3486,
67943 3486,
67944 3486,
67945 3486,
67946 3486,
67947 3486,
67948 3486,
67949 3486,
67950 3486,
67951 3486,
67952 3486,
67953 3486,
67954 3486,
67955 3486,
67956 3486,
67957 3486,
67958 3486,
67959 3486,
67960 };
67961 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
67962 zend_opcode_handler_funcs = labels;
67963 zend_spec_handlers = specs;
67964 execute_ex(NULL);
67965 #else
67966 zend_opcode_handlers = labels;
67967 zend_handlers_count = sizeof(labels) / sizeof(void*);
67968 zend_spec_handlers = specs;
67969 #endif
67970 VM_TRACE_START();
67971 }
67972
67973 static HashTable *zend_handlers_table = NULL;
67974
67975 void zend_vm_dtor(void)
67976 {
67977 VM_TRACE_END();
67978 if (zend_handlers_table) {
67979 zend_hash_destroy(zend_handlers_table);
67980 free(zend_handlers_table);
67981 zend_handlers_table = NULL;
67982 }
67983 }
67984
67985 static void init_opcode_serialiser(void)
67986 {
67987 int i;
67988 zval tmp;
67989
67990 zend_handlers_table = malloc(sizeof(HashTable));
67991 zend_hash_init(zend_handlers_table, zend_handlers_count, NULL, NULL, 1);
67992 zend_hash_real_init(zend_handlers_table, 0);
67993 Z_TYPE_INFO(tmp) = IS_LONG;
67994 for (i = 0; i < zend_handlers_count; i++) {
67995 Z_LVAL(tmp) = i;
67996 zend_hash_index_add(zend_handlers_table, (zend_long)(uintptr_t)zend_opcode_handlers[i], &tmp);
67997 }
67998 }
67999
68000 ZEND_API void ZEND_FASTCALL zend_serialize_opcode_handler(zend_op *op)
68001 {
68002 zval *zv;
68003
68004 if (!zend_handlers_table) {
68005 init_opcode_serialiser();
68006 }
68007 zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
68008 ZEND_ASSERT(zv != NULL);
68009 op->handler = (const void *)(uintptr_t)Z_LVAL_P(zv);
68010 }
68011
68012 ZEND_API void ZEND_FASTCALL zend_deserialize_opcode_handler(zend_op *op)
68013 {
68014 op->handler = zend_opcode_handlers[(uintptr_t)op->handler];
68015 }
68016
68017 ZEND_API const void* ZEND_FASTCALL zend_get_opcode_handler_func(const zend_op *op)
68018 {
68019 #if ZEND_VM_KIND == ZEND_VM_KIND_CALL
68020 return op->handler;
68021 #elif ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68022 zval *zv;
68023
68024 if (!zend_handlers_table) {
68025 init_opcode_serialiser();
68026 }
68027 zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
68028 ZEND_ASSERT(zv != NULL);
68029 return zend_opcode_handler_funcs[Z_LVAL_P(zv)];
68030 #else
68031 return NULL;
68032 #endif
68033 }
68034
68035 ZEND_API const zend_op *zend_get_halt_op(void)
68036 {
68037 #if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68038 return &hybrid_halt_op;
68039 #else
68040 return NULL;
68041 #endif
68042 }
68043
68044 ZEND_API int zend_vm_kind(void)
68045 {
68046 return ZEND_VM_KIND;
68047 }
68048
68049 static uint32_t ZEND_FASTCALL zend_vm_get_opcode_handler_idx(uint32_t spec, const zend_op* op)
68050 {
68051 static const int zend_vm_decode[] = {
68052 _UNUSED_CODE, /* 0 = IS_UNUSED */
68053 _CONST_CODE, /* 1 = IS_CONST */
68054 _TMP_CODE, /* 2 = IS_TMP_VAR */
68055 _UNUSED_CODE, /* 3 */
68056 _VAR_CODE, /* 4 = IS_VAR */
68057 _UNUSED_CODE, /* 5 */
68058 _UNUSED_CODE, /* 6 */
68059 _UNUSED_CODE, /* 7 */
68060 _CV_CODE /* 8 = IS_CV */
68061 };
68062 uint32_t offset = 0;
68063 if (spec & SPEC_RULE_OP1) offset = offset * 5 + zend_vm_decode[op->op1_type];
68064 if (spec & SPEC_RULE_OP2) offset = offset * 5 + zend_vm_decode[op->op2_type];
68065 if (spec & SPEC_EXTRA_MASK) {
68066 if (spec & SPEC_RULE_RETVAL) {
68067 offset = offset * 2 + (op->result_type != IS_UNUSED);
68068 if ((spec & SPEC_RULE_OBSERVER) && ZEND_OBSERVER_ENABLED) {
68069 offset += 2;
68070 }
68071 } else if (spec & SPEC_RULE_QUICK_ARG) {
68072 offset = offset * 2 + (op->op2.num <= MAX_ARG_FLAG_NUM);
68073 } else if (spec & SPEC_RULE_OP_DATA) {
68074 offset = offset * 5 + zend_vm_decode[(op + 1)->op1_type];
68075 } else if (spec & SPEC_RULE_ISSET) {
68076 offset = offset * 2 + (op->extended_value & ZEND_ISEMPTY);
68077 } else if (spec & SPEC_RULE_SMART_BRANCH) {
68078 offset = offset * 3;
68079 if (op->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR)) {
68080 offset += 1;
68081 } else if (op->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)) {
68082 offset += 2;
68083 }
68084 } else if (spec & SPEC_RULE_OBSERVER) {
68085 offset = offset * 2;
68086 if (ZEND_OBSERVER_ENABLED) {
68087 offset += 1;
68088 }
68089 }
68090 }
68091 return (spec & SPEC_START_MASK) + offset;
68092 }
68093
68094 #if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC
68095 static const void *zend_vm_get_opcode_handler(uint8_t opcode, const zend_op* op)
68096 {
68097 return zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
68098 }
68099 #endif
68100
68101 #if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
68102 static const void *zend_vm_get_opcode_handler_func(uint8_t opcode, const zend_op* op)
68103 {
68104 uint32_t spec = zend_spec_handlers[opcode];
68105 return zend_opcode_handler_funcs[zend_vm_get_opcode_handler_idx(spec, op)];
68106 }
68107
68108 #endif
68109
68110 ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler(zend_op* op)
68111 {
68112 uint8_t opcode = zend_user_opcodes[op->opcode];
68113
68114 if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
68115 if (op->op1_type < op->op2_type) {
68116 zend_swap_operands(op);
68117 }
68118 }
68119 op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
68120 }
68121
68122 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)
68123 {
68124 uint8_t opcode = zend_user_opcodes[op->opcode];
68125 uint32_t spec = zend_spec_handlers[opcode];
68126 switch (opcode) {
68127 case ZEND_ADD:
68128 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68129 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68130 break;
68131 }
68132 spec = 2585 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68133 if (op->op1_type < op->op2_type) {
68134 zend_swap_operands(op);
68135 }
68136 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68137 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68138 break;
68139 }
68140 spec = 2610 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68141 if (op->op1_type < op->op2_type) {
68142 zend_swap_operands(op);
68143 }
68144 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68145 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68146 break;
68147 }
68148 spec = 2635 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68149 if (op->op1_type < op->op2_type) {
68150 zend_swap_operands(op);
68151 }
68152 }
68153 break;
68154 case ZEND_SUB:
68155 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68156 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68157 break;
68158 }
68159 spec = 2660 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68160 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68161 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68162 break;
68163 }
68164 spec = 2685 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68165 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68166 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68167 break;
68168 }
68169 spec = 2710 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68170 }
68171 break;
68172 case ZEND_MUL:
68173 if (op->op1_type < op->op2_type) {
68174 zend_swap_operands(op);
68175 }
68176 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68177 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68178 break;
68179 }
68180 spec = 2735 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68181 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68182 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68183 break;
68184 }
68185 spec = 2760 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68186 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68187 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68188 break;
68189 }
68190 spec = 2785 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68191 }
68192 break;
68193 case ZEND_IS_IDENTICAL:
68194 if (op->op1_type < op->op2_type) {
68195 zend_swap_operands(op);
68196 }
68197 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68198 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68199 break;
68200 }
68201 spec = 2810 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68202 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68203 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68204 break;
68205 }
68206 spec = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68207 } 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))) {
68208 spec = 3110 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68209 }
68210 break;
68211 case ZEND_IS_NOT_IDENTICAL:
68212 if (op->op1_type < op->op2_type) {
68213 zend_swap_operands(op);
68214 }
68215 if (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 = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68220 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68221 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68222 break;
68223 }
68224 spec = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68225 } 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))) {
68226 spec = 3115 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
68227 }
68228 break;
68229 case ZEND_IS_EQUAL:
68230 if (op->op1_type < op->op2_type) {
68231 zend_swap_operands(op);
68232 }
68233 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68234 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68235 break;
68236 }
68237 spec = 2810 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68238 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68239 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68240 break;
68241 }
68242 spec = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68243 }
68244 break;
68245 case ZEND_IS_NOT_EQUAL:
68246 if (op->op1_type < op->op2_type) {
68247 zend_swap_operands(op);
68248 }
68249 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68250 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68251 break;
68252 }
68253 spec = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68254 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68255 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68256 break;
68257 }
68258 spec = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
68259 }
68260 break;
68261 case ZEND_IS_SMALLER:
68262 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
68263 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68264 break;
68265 }
68266 spec = 3120 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68267 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
68268 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68269 break;
68270 }
68271 spec = 3195 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68272 }
68273 break;
68274 case ZEND_IS_SMALLER_OR_EQUAL:
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 = 3270 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
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 = 3345 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
68285 }
68286 break;
68287 case ZEND_QM_ASSIGN:
68288 if (op1_info == MAY_BE_LONG) {
68289 spec = 3432 | SPEC_RULE_OP1;
68290 } else if (op1_info == MAY_BE_DOUBLE) {
68291 spec = 3437 | SPEC_RULE_OP1;
68292 } 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))))) {
68293 spec = 3442 | SPEC_RULE_OP1;
68294 }
68295 break;
68296 case ZEND_PRE_INC:
68297 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68298 spec = 3420 | SPEC_RULE_RETVAL;
68299 } else if (op1_info == MAY_BE_LONG) {
68300 spec = 3422 | SPEC_RULE_RETVAL;
68301 }
68302 break;
68303 case ZEND_PRE_DEC:
68304 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68305 spec = 3424 | SPEC_RULE_RETVAL;
68306 } else if (op1_info == MAY_BE_LONG) {
68307 spec = 3426 | SPEC_RULE_RETVAL;
68308 }
68309 break;
68310 case ZEND_POST_INC:
68311 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68312 spec = 3428;
68313 } else if (op1_info == MAY_BE_LONG) {
68314 spec = 3429;
68315 }
68316 break;
68317 case ZEND_POST_DEC:
68318 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
68319 spec = 3430;
68320 } else if (op1_info == MAY_BE_LONG) {
68321 spec = 3431;
68322 }
68323 break;
68324 case ZEND_JMP:
68325 if (OP_JMP_ADDR(op, op->op1) > op) {
68326 spec = 2584;
68327 }
68328 break;
68329 case ZEND_INIT_FCALL:
68330 if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) {
68331 spec = 2577;
68332 }
68333 break;
68334 case ZEND_RECV:
68335 if (op->op2.num == MAY_BE_ANY) {
68336 spec = 2578;
68337 }
68338 break;
68339 case ZEND_SEND_VAL:
68340 if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
68341 spec = 3482;
68342 }
68343 break;
68344 case ZEND_SEND_VAR_EX:
68345 if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
68346 spec = 3477 | SPEC_RULE_OP1;
68347 }
68348 break;
68349 case ZEND_FE_FETCH_R:
68350 if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
68351 spec = 3484 | SPEC_RULE_RETVAL;
68352 }
68353 break;
68354 case ZEND_FETCH_DIM_R:
68355 if (!(op2_info & (MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))) {
68356 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
68357 break;
68358 }
68359 spec = 3447 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
68360 }
68361 break;
68362 case ZEND_SEND_VAL_EX:
68363 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))) {
68364 spec = 3483;
68365 }
68366 break;
68367 case ZEND_SEND_VAR:
68368 if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
68369 spec = 3472 | SPEC_RULE_OP1;
68370 }
68371 break;
68372 case ZEND_COUNT:
68373 if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) {
68374 spec = 2579 | SPEC_RULE_OP1;
68375 }
68376 break;
68377 case ZEND_BW_OR:
68378 case ZEND_BW_AND:
68379 case ZEND_BW_XOR:
68380 case ZEND_BOOL_XOR:
68381 if (op->op1_type < op->op2_type) {
68382 zend_swap_operands(op);
68383 }
68384 break;
68385 case ZEND_USER_OPCODE:
68386 if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
68387 if (op->op1_type < op->op2_type) {
68388 zend_swap_operands(op);
68389 }
68390 }
68391 break;
68392 default:
68393 break;
68394 }
68395 op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(spec, op)];
68396 }
68397
68398 ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data* ex)
68399 {
68400 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
68401 opcode_handler_t handler;
68402 #endif
68403 int ret;
68404 #ifdef ZEND_VM_IP_GLOBAL_REG
68405 const zend_op *orig_opline = opline;
68406 #endif
68407 #ifdef ZEND_VM_FP_GLOBAL_REG
68408 zend_execute_data *orig_execute_data = execute_data;
68409 execute_data = ex;
68410 #else
68411 zend_execute_data *execute_data = ex;
68412 #endif
68413
68414 LOAD_OPLINE();
68415 #if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
68416 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
68417 handler = (opcode_handler_t)zend_vm_get_opcode_handler_func(zend_user_opcodes[opline->opcode], opline);
68418 handler(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68419 if (EXPECTED(opline != &hybrid_halt_op)) {
68420 #else
68421 ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68422 if (EXPECTED(opline)) {
68423 #endif
68424 ret = execute_data != ex ? (int)(execute_data->prev_execute_data != ex) + 1 : 0;
68425 SAVE_OPLINE();
68426 } else {
68427 ret = -1;
68428 }
68429 #else
68430 ret = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
68431 SAVE_OPLINE();
68432 #endif
68433 #ifdef ZEND_VM_FP_GLOBAL_REG
68434 execute_data = orig_execute_data;
68435 #endif
68436 #ifdef ZEND_VM_IP_GLOBAL_REG
68437 opline = orig_opline;
68438 #endif
68439 return ret;
68440 }
68441
68442
