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 EG(current_execute_data) = execute_data;
1303 zend_vm_stack_free_args(call);
1304
1305 uint32_t call_info = ZEND_CALL_INFO(call);
1306 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1307 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1308 zend_free_extra_named_params(call->extra_named_params);
1309 }
1310 zend_vm_stack_free_call_frame_ex(call_info, call);
1311 } else {
1312 EG(vm_stack_top) = (zval*)call;
1313 }
1314
1315 if (!0) {
1316 i_zval_ptr_dtor(ret);
1317 }
1318
1319 if (UNEXPECTED(EG(exception) != NULL)) {
1320 zend_rethrow_exception(execute_data);
1321 HANDLE_EXCEPTION();
1322 }
1323
1324 ZEND_VM_SET_OPCODE(opline + 1);
1325 ZEND_VM_CONTINUE();
1326 }
1327
ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1328 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1329 {
1330 USE_OPLINE
1331 zend_execute_data *call = EX(call);
1332 zend_function *fbc = call->func;
1333 zval *ret;
1334 zval retval;
1335
1336 SAVE_OPLINE();
1337 EX(call) = call->prev_execute_data;
1338
1339 call->prev_execute_data = execute_data;
1340 EG(current_execute_data) = call;
1341
1342 #if ZEND_DEBUG
1343 bool should_throw = zend_internal_call_should_throw(fbc, call);
1344 #endif
1345
1346 ret = 1 ? EX_VAR(opline->result.var) : &retval;
1347 ZVAL_NULL(ret);
1348
1349 fbc->internal_function.handler(call, ret);
1350
1351 #if ZEND_DEBUG
1352 if (!EG(exception) && call->func) {
1353 if (should_throw) {
1354 zend_internal_call_arginfo_violation(call->func);
1355 }
1356 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1357 zend_verify_internal_return_type(call->func, ret));
1358 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1359 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1360 zend_verify_internal_func_info(call->func, ret);
1361 }
1362 #endif
1363
1364 EG(current_execute_data) = execute_data;
1365 zend_vm_stack_free_args(call);
1366
1367 uint32_t call_info = ZEND_CALL_INFO(call);
1368 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1369 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1370 zend_free_extra_named_params(call->extra_named_params);
1371 }
1372 zend_vm_stack_free_call_frame_ex(call_info, call);
1373 } else {
1374 EG(vm_stack_top) = (zval*)call;
1375 }
1376
1377 if (!1) {
1378 i_zval_ptr_dtor(ret);
1379 }
1380
1381 if (UNEXPECTED(EG(exception) != NULL)) {
1382 zend_rethrow_exception(execute_data);
1383 HANDLE_EXCEPTION();
1384 }
1385
1386 ZEND_VM_SET_OPCODE(opline + 1);
1387 ZEND_VM_CONTINUE();
1388 }
1389
ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1390 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1391 {
1392 USE_OPLINE
1393 zend_execute_data *call = EX(call);
1394 zend_function *fbc = call->func;
1395 zval *ret;
1396 zval retval;
1397
1398 SAVE_OPLINE();
1399 EX(call) = call->prev_execute_data;
1400
1401 call->prev_execute_data = execute_data;
1402 EG(current_execute_data) = call;
1403
1404 #if ZEND_DEBUG
1405 bool should_throw = zend_internal_call_should_throw(fbc, call);
1406 #endif
1407
1408 ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
1409 ZVAL_NULL(ret);
1410
1411 zend_observer_fcall_begin(call);
1412 fbc->internal_function.handler(call, ret);
1413
1414 #if ZEND_DEBUG
1415 if (!EG(exception) && call->func) {
1416 if (should_throw) {
1417 zend_internal_call_arginfo_violation(call->func);
1418 }
1419 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1420 zend_verify_internal_return_type(call->func, ret));
1421 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1422 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1423 zend_verify_internal_func_info(call->func, ret);
1424 }
1425 #endif
1426 zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
1427
1428 EG(current_execute_data) = execute_data;
1429 zend_vm_stack_free_args(call);
1430
1431 uint32_t call_info = ZEND_CALL_INFO(call);
1432 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1433 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1434 zend_free_extra_named_params(call->extra_named_params);
1435 }
1436 zend_vm_stack_free_call_frame_ex(call_info, call);
1437 } else {
1438 EG(vm_stack_top) = (zval*)call;
1439 }
1440
1441 if (!RETURN_VALUE_USED(opline)) {
1442 i_zval_ptr_dtor(ret);
1443 }
1444
1445 if (UNEXPECTED(EG(exception) != NULL)) {
1446 zend_rethrow_exception(execute_data);
1447 HANDLE_EXCEPTION();
1448 }
1449
1450 ZEND_VM_SET_OPCODE(opline + 1);
1451 ZEND_VM_CONTINUE();
1452 }
1453
ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1454 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1455 {
1456 USE_OPLINE
1457 zend_execute_data *call = EX(call);
1458 zend_function *fbc = call->func;
1459 zval *ret;
1460
1461 SAVE_OPLINE();
1462 EX(call) = call->prev_execute_data;
1463
1464 ret = NULL;
1465 if (0) {
1466 ret = EX_VAR(opline->result.var);
1467 }
1468
1469 call->prev_execute_data = execute_data;
1470 execute_data = call;
1471 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1472 LOAD_OPLINE_EX();
1473
1474
1475 ZEND_VM_ENTER_EX();
1476 }
1477
ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1478 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1479 {
1480 USE_OPLINE
1481 zend_execute_data *call = EX(call);
1482 zend_function *fbc = call->func;
1483 zval *ret;
1484
1485 SAVE_OPLINE();
1486 EX(call) = call->prev_execute_data;
1487
1488 ret = NULL;
1489 if (1) {
1490 ret = EX_VAR(opline->result.var);
1491 }
1492
1493 call->prev_execute_data = execute_data;
1494 execute_data = call;
1495 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1496 LOAD_OPLINE_EX();
1497
1498
1499 ZEND_VM_ENTER_EX();
1500 }
1501
ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1502 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1503 {
1504 USE_OPLINE
1505 zend_execute_data *call = EX(call);
1506 zend_function *fbc = call->func;
1507 zval *ret;
1508
1509 SAVE_OPLINE();
1510 EX(call) = call->prev_execute_data;
1511
1512 ret = NULL;
1513 if (RETURN_VALUE_USED(opline)) {
1514 ret = EX_VAR(opline->result.var);
1515 }
1516
1517 call->prev_execute_data = execute_data;
1518 execute_data = call;
1519 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1520 LOAD_OPLINE_EX();
1521 SAVE_OPLINE();
1522 zend_observer_fcall_begin(execute_data);
1523
1524 ZEND_VM_ENTER_EX();
1525 }
1526
ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1527 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1528 {
1529 USE_OPLINE
1530 zend_execute_data *call = EX(call);
1531 zend_function *fbc = call->func;
1532 zval *ret;
1533
1534 SAVE_OPLINE();
1535 EX(call) = call->prev_execute_data;
1536
1537 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1538 ret = NULL;
1539 if (0) {
1540 ret = EX_VAR(opline->result.var);
1541 }
1542
1543 call->prev_execute_data = execute_data;
1544 execute_data = call;
1545 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1546 LOAD_OPLINE_EX();
1547
1548
1549 ZEND_VM_ENTER_EX();
1550 } else {
1551 zval retval;
1552 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1553 if (0) {
1554 ret = NULL;
1555 }
1556
1557 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
1558 zend_deprecated_function(fbc);
1559 if (UNEXPECTED(EG(exception) != NULL)) {
1560 UNDEF_RESULT();
1561 if (!0) {
1562 ret = &retval;
1563 ZVAL_UNDEF(ret);
1564 }
1565 goto fcall_by_name_end;
1566 }
1567 }
1568
1569 call->prev_execute_data = execute_data;
1570 EG(current_execute_data) = call;
1571
1572 #if ZEND_DEBUG
1573 bool should_throw = zend_internal_call_should_throw(fbc, call);
1574 #endif
1575
1576 ret = 0 ? EX_VAR(opline->result.var) : &retval;
1577 ZVAL_NULL(ret);
1578
1579 fbc->internal_function.handler(call, ret);
1580
1581 #if ZEND_DEBUG
1582 if (!EG(exception) && call->func) {
1583 if (should_throw) {
1584 zend_internal_call_arginfo_violation(call->func);
1585 }
1586 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1587 zend_verify_internal_return_type(call->func, ret));
1588 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1589 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1590 zend_verify_internal_func_info(call->func, ret);
1591 }
1592 #endif
1593
1594 EG(current_execute_data) = execute_data;
1595
1596 fcall_by_name_end:
1597 zend_vm_stack_free_args(call);
1598
1599 uint32_t call_info = ZEND_CALL_INFO(call);
1600 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1601 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1602 zend_free_extra_named_params(call->extra_named_params);
1603 }
1604 zend_vm_stack_free_call_frame_ex(call_info, call);
1605 } else {
1606 EG(vm_stack_top) = (zval*)call;
1607 }
1608
1609 if (!0) {
1610 i_zval_ptr_dtor(ret);
1611 }
1612 }
1613
1614 if (UNEXPECTED(EG(exception) != NULL)) {
1615 zend_rethrow_exception(execute_data);
1616 HANDLE_EXCEPTION();
1617 }
1618 ZEND_VM_SET_OPCODE(opline + 1);
1619 ZEND_VM_CONTINUE();
1620 }
1621
ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1622 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1623 {
1624 USE_OPLINE
1625 zend_execute_data *call = EX(call);
1626 zend_function *fbc = call->func;
1627 zval *ret;
1628
1629 SAVE_OPLINE();
1630 EX(call) = call->prev_execute_data;
1631
1632 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1633 ret = NULL;
1634 if (1) {
1635 ret = EX_VAR(opline->result.var);
1636 }
1637
1638 call->prev_execute_data = execute_data;
1639 execute_data = call;
1640 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1641 LOAD_OPLINE_EX();
1642
1643
1644 ZEND_VM_ENTER_EX();
1645 } else {
1646 zval retval;
1647 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1648 if (0) {
1649 ret = NULL;
1650 }
1651
1652 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
1653 zend_deprecated_function(fbc);
1654 if (UNEXPECTED(EG(exception) != NULL)) {
1655 UNDEF_RESULT();
1656 if (!1) {
1657 ret = &retval;
1658 ZVAL_UNDEF(ret);
1659 }
1660 goto fcall_by_name_end;
1661 }
1662 }
1663
1664 call->prev_execute_data = execute_data;
1665 EG(current_execute_data) = call;
1666
1667 #if ZEND_DEBUG
1668 bool should_throw = zend_internal_call_should_throw(fbc, call);
1669 #endif
1670
1671 ret = 1 ? EX_VAR(opline->result.var) : &retval;
1672 ZVAL_NULL(ret);
1673
1674 fbc->internal_function.handler(call, ret);
1675
1676 #if ZEND_DEBUG
1677 if (!EG(exception) && call->func) {
1678 if (should_throw) {
1679 zend_internal_call_arginfo_violation(call->func);
1680 }
1681 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1682 zend_verify_internal_return_type(call->func, ret));
1683 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1684 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1685 zend_verify_internal_func_info(call->func, ret);
1686 }
1687 #endif
1688
1689 EG(current_execute_data) = execute_data;
1690
1691 fcall_by_name_end:
1692 zend_vm_stack_free_args(call);
1693
1694 uint32_t call_info = ZEND_CALL_INFO(call);
1695 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1696 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1697 zend_free_extra_named_params(call->extra_named_params);
1698 }
1699 zend_vm_stack_free_call_frame_ex(call_info, call);
1700 } else {
1701 EG(vm_stack_top) = (zval*)call;
1702 }
1703
1704 if (!1) {
1705 i_zval_ptr_dtor(ret);
1706 }
1707 }
1708
1709 if (UNEXPECTED(EG(exception) != NULL)) {
1710 zend_rethrow_exception(execute_data);
1711 HANDLE_EXCEPTION();
1712 }
1713 ZEND_VM_SET_OPCODE(opline + 1);
1714 ZEND_VM_CONTINUE();
1715 }
1716
ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1717 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1718 {
1719 USE_OPLINE
1720 zend_execute_data *call = EX(call);
1721 zend_function *fbc = call->func;
1722 zval *ret;
1723
1724 SAVE_OPLINE();
1725 EX(call) = call->prev_execute_data;
1726
1727 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1728 ret = NULL;
1729 if (RETURN_VALUE_USED(opline)) {
1730 ret = EX_VAR(opline->result.var);
1731 }
1732
1733 call->prev_execute_data = execute_data;
1734 execute_data = call;
1735 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
1736 LOAD_OPLINE_EX();
1737 SAVE_OPLINE();
1738 zend_observer_fcall_begin(execute_data);
1739
1740 ZEND_VM_ENTER_EX();
1741 } else {
1742 zval retval;
1743 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1744 if (1) {
1745 ret = NULL;
1746 }
1747
1748 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
1749 zend_deprecated_function(fbc);
1750 if (UNEXPECTED(EG(exception) != NULL)) {
1751 UNDEF_RESULT();
1752 if (!RETURN_VALUE_USED(opline)) {
1753 ret = &retval;
1754 ZVAL_UNDEF(ret);
1755 }
1756 goto fcall_by_name_end;
1757 }
1758 }
1759
1760 call->prev_execute_data = execute_data;
1761 EG(current_execute_data) = call;
1762
1763 #if ZEND_DEBUG
1764 bool should_throw = zend_internal_call_should_throw(fbc, call);
1765 #endif
1766
1767 ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
1768 ZVAL_NULL(ret);
1769
1770 zend_observer_fcall_begin(call);
1771 fbc->internal_function.handler(call, ret);
1772
1773 #if ZEND_DEBUG
1774 if (!EG(exception) && call->func) {
1775 if (should_throw) {
1776 zend_internal_call_arginfo_violation(call->func);
1777 }
1778 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1779 zend_verify_internal_return_type(call->func, ret));
1780 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1781 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1782 zend_verify_internal_func_info(call->func, ret);
1783 }
1784 #endif
1785 zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
1786
1787 EG(current_execute_data) = execute_data;
1788
1789 fcall_by_name_end:
1790 zend_vm_stack_free_args(call);
1791
1792 uint32_t call_info = ZEND_CALL_INFO(call);
1793 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
1794 if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
1795 zend_free_extra_named_params(call->extra_named_params);
1796 }
1797 zend_vm_stack_free_call_frame_ex(call_info, call);
1798 } else {
1799 EG(vm_stack_top) = (zval*)call;
1800 }
1801
1802 if (!RETURN_VALUE_USED(opline)) {
1803 i_zval_ptr_dtor(ret);
1804 }
1805 }
1806
1807 if (UNEXPECTED(EG(exception) != NULL)) {
1808 zend_rethrow_exception(execute_data);
1809 HANDLE_EXCEPTION();
1810 }
1811 ZEND_VM_SET_OPCODE(opline + 1);
1812 ZEND_VM_CONTINUE();
1813 }
1814
ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1815 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1816 {
1817 USE_OPLINE
1818 zend_execute_data *call = EX(call);
1819 zend_function *fbc = call->func;
1820 zval *ret;
1821
1822 SAVE_OPLINE();
1823 EX(call) = call->prev_execute_data;
1824
1825 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1826 ret = NULL;
1827 if (0) {
1828 ret = EX_VAR(opline->result.var);
1829 }
1830
1831 call->prev_execute_data = execute_data;
1832 execute_data = call;
1833 i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
1834
1835 if (EXPECTED(zend_execute_ex == execute_ex)) {
1836 LOAD_OPLINE_EX();
1837
1838
1839 ZEND_VM_ENTER_EX();
1840 } else {
1841 SAVE_OPLINE_EX();
1842
1843 execute_data = EX(prev_execute_data);
1844 LOAD_OPLINE();
1845 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
1846 zend_execute_ex(call);
1847 }
1848 } else {
1849 zval retval;
1850 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1851 if (0) {
1852 ret = NULL;
1853 }
1854
1855 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
1856 zend_deprecated_function(fbc);
1857 if (UNEXPECTED(EG(exception) != NULL)) {
1858 UNDEF_RESULT();
1859 if (!0) {
1860 ret = &retval;
1861 ZVAL_UNDEF(ret);
1862 }
1863 goto fcall_end;
1864 }
1865 }
1866
1867 call->prev_execute_data = execute_data;
1868 EG(current_execute_data) = call;
1869
1870 #if ZEND_DEBUG
1871 bool should_throw = zend_internal_call_should_throw(fbc, call);
1872 #endif
1873
1874 ret = 0 ? EX_VAR(opline->result.var) : &retval;
1875 ZVAL_NULL(ret);
1876
1877 if (!zend_execute_internal) {
1878 /* saves one function call if zend_execute_internal is not used */
1879 fbc->internal_function.handler(call, ret);
1880 } else {
1881 zend_execute_internal(call, ret);
1882 }
1883
1884 #if ZEND_DEBUG
1885 if (!EG(exception) && call->func && !(call->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE)) {
1886 if (should_throw) {
1887 zend_internal_call_arginfo_violation(call->func);
1888 }
1889 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1890 zend_verify_internal_return_type(call->func, ret));
1891 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
1892 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
1893 zend_verify_internal_func_info(call->func, ret);
1894 }
1895 #endif
1896
1897 EG(current_execute_data) = execute_data;
1898
1899 fcall_end:
1900 zend_vm_stack_free_args(call);
1901 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
1902 zend_free_extra_named_params(call->extra_named_params);
1903 }
1904
1905 if (!0) {
1906 i_zval_ptr_dtor(ret);
1907 }
1908 }
1909
1910 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
1911 OBJ_RELEASE(Z_OBJ(call->This));
1912 }
1913
1914 zend_vm_stack_free_call_frame(call);
1915 if (UNEXPECTED(EG(exception) != NULL)) {
1916 zend_rethrow_exception(execute_data);
1917 HANDLE_EXCEPTION();
1918 }
1919
1920 ZEND_VM_SET_OPCODE(opline + 1);
1921 ZEND_VM_CONTINUE();
1922 }
1923
ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)1924 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
1925 {
1926 USE_OPLINE
1927 zend_execute_data *call = EX(call);
1928 zend_function *fbc = call->func;
1929 zval *ret;
1930
1931 SAVE_OPLINE();
1932 EX(call) = call->prev_execute_data;
1933
1934 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
1935 ret = NULL;
1936 if (1) {
1937 ret = EX_VAR(opline->result.var);
1938 }
1939
1940 call->prev_execute_data = execute_data;
1941 execute_data = call;
1942 i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
1943
1944 if (EXPECTED(zend_execute_ex == execute_ex)) {
1945 LOAD_OPLINE_EX();
1946
1947
1948 ZEND_VM_ENTER_EX();
1949 } else {
1950 SAVE_OPLINE_EX();
1951
1952 execute_data = EX(prev_execute_data);
1953 LOAD_OPLINE();
1954 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
1955 zend_execute_ex(call);
1956 }
1957 } else {
1958 zval retval;
1959 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
1960 if (0) {
1961 ret = NULL;
1962 }
1963
1964 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
1965 zend_deprecated_function(fbc);
1966 if (UNEXPECTED(EG(exception) != NULL)) {
1967 UNDEF_RESULT();
1968 if (!1) {
1969 ret = &retval;
1970 ZVAL_UNDEF(ret);
1971 }
1972 goto fcall_end;
1973 }
1974 }
1975
1976 call->prev_execute_data = execute_data;
1977 EG(current_execute_data) = call;
1978
1979 #if ZEND_DEBUG
1980 bool should_throw = zend_internal_call_should_throw(fbc, call);
1981 #endif
1982
1983 ret = 1 ? EX_VAR(opline->result.var) : &retval;
1984 ZVAL_NULL(ret);
1985
1986 if (!zend_execute_internal) {
1987 /* saves one function call if zend_execute_internal is not used */
1988 fbc->internal_function.handler(call, ret);
1989 } else {
1990 zend_execute_internal(call, ret);
1991 }
1992
1993 #if ZEND_DEBUG
1994 if (!EG(exception) && call->func && !(call->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE)) {
1995 if (should_throw) {
1996 zend_internal_call_arginfo_violation(call->func);
1997 }
1998 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
1999 zend_verify_internal_return_type(call->func, ret));
2000 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
2001 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
2002 zend_verify_internal_func_info(call->func, ret);
2003 }
2004 #endif
2005
2006 EG(current_execute_data) = execute_data;
2007
2008 fcall_end:
2009 zend_vm_stack_free_args(call);
2010 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
2011 zend_free_extra_named_params(call->extra_named_params);
2012 }
2013
2014 if (!1) {
2015 i_zval_ptr_dtor(ret);
2016 }
2017 }
2018
2019 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
2020 OBJ_RELEASE(Z_OBJ(call->This));
2021 }
2022
2023 zend_vm_stack_free_call_frame(call);
2024 if (UNEXPECTED(EG(exception) != NULL)) {
2025 zend_rethrow_exception(execute_data);
2026 HANDLE_EXCEPTION();
2027 }
2028
2029 ZEND_VM_SET_OPCODE(opline + 1);
2030 ZEND_VM_CONTINUE();
2031 }
2032
ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2033 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2034 {
2035 USE_OPLINE
2036 zend_execute_data *call = EX(call);
2037 zend_function *fbc = call->func;
2038 zval *ret;
2039
2040 SAVE_OPLINE();
2041 EX(call) = call->prev_execute_data;
2042
2043 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
2044 ret = NULL;
2045 if (RETURN_VALUE_USED(opline)) {
2046 ret = EX_VAR(opline->result.var);
2047 }
2048
2049 call->prev_execute_data = execute_data;
2050 execute_data = call;
2051 i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
2052
2053 if (EXPECTED(zend_execute_ex == execute_ex)) {
2054 LOAD_OPLINE_EX();
2055 SAVE_OPLINE();
2056 zend_observer_fcall_begin(execute_data);
2057 ZEND_VM_ENTER_EX();
2058 } else {
2059 SAVE_OPLINE_EX();
2060 zend_observer_fcall_begin(execute_data);
2061 execute_data = EX(prev_execute_data);
2062 LOAD_OPLINE();
2063 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
2064 zend_execute_ex(call);
2065 }
2066 } else {
2067 zval retval;
2068 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
2069 if (1) {
2070 ret = NULL;
2071 }
2072
2073 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
2074 zend_deprecated_function(fbc);
2075 if (UNEXPECTED(EG(exception) != NULL)) {
2076 UNDEF_RESULT();
2077 if (!RETURN_VALUE_USED(opline)) {
2078 ret = &retval;
2079 ZVAL_UNDEF(ret);
2080 }
2081 goto fcall_end;
2082 }
2083 }
2084
2085 call->prev_execute_data = execute_data;
2086 EG(current_execute_data) = call;
2087
2088 #if ZEND_DEBUG
2089 bool should_throw = zend_internal_call_should_throw(fbc, call);
2090 #endif
2091
2092 ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
2093 ZVAL_NULL(ret);
2094
2095 zend_observer_fcall_begin(call);
2096 if (!zend_execute_internal) {
2097 /* saves one function call if zend_execute_internal is not used */
2098 fbc->internal_function.handler(call, ret);
2099 } else {
2100 zend_execute_internal(call, ret);
2101 }
2102
2103 #if ZEND_DEBUG
2104 if (!EG(exception) && call->func && !(call->func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE)) {
2105 if (should_throw) {
2106 zend_internal_call_arginfo_violation(call->func);
2107 }
2108 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
2109 zend_verify_internal_return_type(call->func, ret));
2110 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
2111 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
2112 zend_verify_internal_func_info(call->func, ret);
2113 }
2114 #endif
2115 zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
2116
2117 EG(current_execute_data) = execute_data;
2118
2119 fcall_end:
2120 zend_vm_stack_free_args(call);
2121 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
2122 zend_free_extra_named_params(call->extra_named_params);
2123 }
2124
2125 if (!RETURN_VALUE_USED(opline)) {
2126 i_zval_ptr_dtor(ret);
2127 }
2128 }
2129
2130 if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
2131 OBJ_RELEASE(Z_OBJ(call->This));
2132 }
2133
2134 zend_vm_stack_free_call_frame(call);
2135 if (UNEXPECTED(EG(exception) != NULL)) {
2136 zend_rethrow_exception(execute_data);
2137 HANDLE_EXCEPTION();
2138 }
2139
2140 ZEND_VM_SET_OPCODE(opline + 1);
2141 ZEND_VM_CONTINUE();
2142 }
2143
ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2144 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2145 {
2146 zval *return_value = EX(return_value);
2147
2148 if (EXPECTED(return_value)) {
2149 USE_OPLINE
2150 zend_generator *generator;
2151 zend_execute_data *gen_execute_data;
2152 uint32_t num_args, used_stack, call_info;
2153
2154 SAVE_OPLINE();
2155 object_init_ex(return_value, zend_ce_generator);
2156
2157 /*
2158 * Normally the execute_data is allocated on the VM stack (because it does
2159 * not actually do any allocation and thus is faster). For generators
2160 * though this behavior would be suboptimal, because the (rather large)
2161 * structure would have to be copied back and forth every time execution is
2162 * suspended or resumed. That's why for generators the execution context
2163 * is allocated on heap.
2164 */
2165 num_args = EX_NUM_ARGS();
2166 if (EXPECTED(num_args <= EX(func)->op_array.num_args)) {
2167 used_stack = (ZEND_CALL_FRAME_SLOT + EX(func)->op_array.last_var + EX(func)->op_array.T) * sizeof(zval);
2168 gen_execute_data = (zend_execute_data*)emalloc(used_stack);
2169 used_stack = (ZEND_CALL_FRAME_SLOT + EX(func)->op_array.last_var) * sizeof(zval);
2170 } else {
2171 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);
2172 gen_execute_data = (zend_execute_data*)emalloc(used_stack);
2173 }
2174 memcpy(gen_execute_data, execute_data, used_stack);
2175
2176 /* Save execution context in generator object. */
2177 generator = (zend_generator *) Z_OBJ_P(EX(return_value));
2178 generator->execute_data = gen_execute_data;
2179 generator->frozen_call_stack = NULL;
2180 generator->execute_fake.opline = NULL;
2181 generator->execute_fake.func = NULL;
2182 generator->execute_fake.prev_execute_data = NULL;
2183 ZVAL_OBJ(&generator->execute_fake.This, (zend_object *) generator);
2184
2185 gen_execute_data->opline = opline + 1;
2186 /* EX(return_value) keeps pointer to zend_object (not a real zval) */
2187 gen_execute_data->return_value = (zval*)generator;
2188 call_info = Z_TYPE_INFO(EX(This));
2189 if ((call_info & Z_TYPE_MASK) == IS_OBJECT
2190 && (!(call_info & (ZEND_CALL_CLOSURE|ZEND_CALL_RELEASE_THIS))
2191 /* Bug #72523 */
2192 || UNEXPECTED(zend_execute_ex != execute_ex))) {
2193 ZEND_ADD_CALL_FLAG_EX(call_info, ZEND_CALL_RELEASE_THIS);
2194 Z_ADDREF(gen_execute_data->This);
2195 }
2196 ZEND_ADD_CALL_FLAG_EX(call_info, (ZEND_CALL_TOP_FUNCTION | ZEND_CALL_ALLOCATED | ZEND_CALL_GENERATOR));
2197 Z_TYPE_INFO(gen_execute_data->This) = call_info;
2198 gen_execute_data->prev_execute_data = NULL;
2199
2200 call_info = EX_CALL_INFO();
2201 EG(current_execute_data) = EX(prev_execute_data);
2202 if (EXPECTED(!(call_info & (ZEND_CALL_TOP|ZEND_CALL_ALLOCATED)))) {
2203 EG(vm_stack_top) = (zval*)execute_data;
2204 execute_data = EX(prev_execute_data);
2205 LOAD_NEXT_OPLINE();
2206 ZEND_VM_LEAVE();
2207 } else if (EXPECTED(!(call_info & ZEND_CALL_TOP))) {
2208 zend_execute_data *old_execute_data = execute_data;
2209 execute_data = EX(prev_execute_data);
2210 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
2211 LOAD_NEXT_OPLINE();
2212 ZEND_VM_LEAVE();
2213 } else {
2214 ZEND_VM_RETURN();
2215 }
2216 } else {
2217 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
2218 }
2219 }
2220
zend_cannot_pass_by_ref_helper_SPEC(uint32_t _arg_num,zval * _arg ZEND_OPCODE_HANDLER_ARGS_DC)2221 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)
2222 {
2223 USE_OPLINE
2224
2225 SAVE_OPLINE();
2226
2227 zend_cannot_pass_by_reference(_arg_num);
2228 FREE_OP(opline->op1_type, opline->op1.var);
2229 ZVAL_UNDEF(_arg);
2230 HANDLE_EXCEPTION();
2231 }
2232
ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2233 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2234 {
2235 USE_OPLINE
2236 zval *args;
2237 uint32_t arg_num;
2238
2239 SAVE_OPLINE();
2240 args = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
2241 arg_num = ZEND_CALL_NUM_ARGS(EX(call)) + 1;
2242
2243 send_again:
2244 if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
2245 HashTable *ht = Z_ARRVAL_P(args);
2246 zval *arg, *top;
2247 zend_string *name;
2248 bool have_named_params = 0;
2249
2250 zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, zend_hash_num_elements(ht));
2251
2252 // TODO: Speed this up using a flag that specifies whether there are any ref parameters.
2253 if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_REFCOUNT_P(args) > 1) {
2254 uint32_t tmp_arg_num = arg_num;
2255 bool separate = 0;
2256
2257 /* check if any of arguments are going to be passed by reference */
2258 ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2259 if (UNEXPECTED(name)) {
2260 void *cache_slot[2] = {NULL, NULL};
2261 tmp_arg_num = zend_get_arg_offset_by_name(
2262 EX(call)->func, name, cache_slot) + 1;
2263 }
2264 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, tmp_arg_num)) {
2265 separate = 1;
2266 break;
2267 }
2268 tmp_arg_num++;
2269 } ZEND_HASH_FOREACH_END();
2270 if (separate) {
2271 SEPARATE_ARRAY(args);
2272 ht = Z_ARRVAL_P(args);
2273 }
2274 }
2275
2276 ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2277 if (UNEXPECTED(name)) {
2278 void *cache_slot[2] = {NULL, NULL};
2279 have_named_params = 1;
2280 top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2281 if (UNEXPECTED(!top)) {
2282 FREE_OP(opline->op1_type, opline->op1.var);
2283 HANDLE_EXCEPTION();
2284 }
2285 } else {
2286 if (have_named_params) {
2287 zend_throw_error(NULL,
2288 "Cannot use positional argument after named argument during unpacking");
2289 FREE_OP(opline->op1_type, opline->op1.var);
2290 HANDLE_EXCEPTION();
2291 }
2292
2293 top = ZEND_CALL_ARG(EX(call), arg_num);
2294 ZEND_CALL_NUM_ARGS(EX(call))++;
2295 }
2296
2297 if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2298 if (Z_ISREF_P(arg)) {
2299 Z_ADDREF_P(arg);
2300 ZVAL_REF(top, Z_REF_P(arg));
2301 } else if (opline->op1_type & (IS_VAR|IS_CV)) {
2302 /* array is already separated above */
2303 ZVAL_MAKE_REF_EX(arg, 2);
2304 ZVAL_REF(top, Z_REF_P(arg));
2305 } else {
2306 Z_TRY_ADDREF_P(arg);
2307 ZVAL_NEW_REF(top, arg);
2308 }
2309 } else {
2310 ZVAL_COPY_DEREF(top, arg);
2311 }
2312
2313 arg_num++;
2314 } ZEND_HASH_FOREACH_END();
2315
2316 } else if (EXPECTED(Z_TYPE_P(args) == IS_OBJECT)) {
2317 zend_class_entry *ce = Z_OBJCE_P(args);
2318 zend_object_iterator *iter;
2319 bool have_named_params = 0;
2320
2321 if (!ce || !ce->get_iterator) {
2322 zend_type_error("Only arrays and Traversables can be unpacked");
2323 } else {
2324
2325 iter = ce->get_iterator(ce, args, 0);
2326 if (UNEXPECTED(!iter)) {
2327 FREE_OP(opline->op1_type, opline->op1.var);
2328 if (!EG(exception)) {
2329 zend_throw_exception_ex(
2330 NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
2331 );
2332 }
2333 HANDLE_EXCEPTION();
2334 }
2335
2336 const zend_object_iterator_funcs *funcs = iter->funcs;
2337 if (funcs->rewind) {
2338 funcs->rewind(iter);
2339 }
2340
2341 for (; funcs->valid(iter) == SUCCESS; ++arg_num) {
2342 zval *arg, *top;
2343
2344 if (UNEXPECTED(EG(exception) != NULL)) {
2345 break;
2346 }
2347
2348 arg = funcs->get_current_data(iter);
2349 if (UNEXPECTED(EG(exception) != NULL)) {
2350 break;
2351 }
2352
2353 zend_string *name = NULL;
2354 if (funcs->get_current_key) {
2355 zval key;
2356 funcs->get_current_key(iter, &key);
2357 if (UNEXPECTED(EG(exception) != NULL)) {
2358 break;
2359 }
2360
2361 if (UNEXPECTED(Z_TYPE(key) != IS_LONG)) {
2362 if (UNEXPECTED(Z_TYPE(key) != IS_STRING)) {
2363 zend_throw_error(NULL,
2364 "Keys must be of type int|string during argument unpacking");
2365 zval_ptr_dtor(&key);
2366 break;
2367 }
2368
2369 name = Z_STR_P(&key);
2370 }
2371 }
2372
2373 if (UNEXPECTED(name)) {
2374 void *cache_slot[2] = {NULL, NULL};
2375 have_named_params = 1;
2376 top = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2377 if (UNEXPECTED(!top)) {
2378 zend_string_release(name);
2379 break;
2380 }
2381
2382 ZVAL_DEREF(arg);
2383 Z_TRY_ADDREF_P(arg);
2384
2385 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2386 zend_error(
2387 E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
2388 " by unpacking a Traversable, passing by-value instead", arg_num,
2389 EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
2390 EX(call)->func->common.scope ? "::" : "",
2391 ZSTR_VAL(EX(call)->func->common.function_name)
2392 );
2393 ZVAL_NEW_REF(top, arg);
2394 } else {
2395 ZVAL_COPY_VALUE(top, arg);
2396 }
2397
2398 zend_string_release(name);
2399 } else {
2400 if (have_named_params) {
2401 zend_throw_error(NULL,
2402 "Cannot use positional argument after named argument during unpacking");
2403 break;
2404 }
2405
2406 zend_vm_stack_extend_call_frame(&EX(call), arg_num - 1, 1);
2407 top = ZEND_CALL_ARG(EX(call), arg_num);
2408 ZVAL_DEREF(arg);
2409 Z_TRY_ADDREF_P(arg);
2410
2411 if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2412 zend_error(
2413 E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
2414 " by unpacking a Traversable, passing by-value instead", arg_num,
2415 EX(call)->func->common.scope ? ZSTR_VAL(EX(call)->func->common.scope->name) : "",
2416 EX(call)->func->common.scope ? "::" : "",
2417 ZSTR_VAL(EX(call)->func->common.function_name)
2418 );
2419 ZVAL_NEW_REF(top, arg);
2420 } else {
2421 ZVAL_COPY_VALUE(top, arg);
2422 }
2423
2424 ZEND_CALL_NUM_ARGS(EX(call))++;
2425 }
2426
2427 funcs->move_forward(iter);
2428 }
2429
2430 zend_iterator_dtor(iter);
2431 }
2432 } else if (EXPECTED(Z_ISREF_P(args))) {
2433 args = Z_REFVAL_P(args);
2434 goto send_again;
2435 } else {
2436 if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(args) == IS_UNDEF)) {
2437 ZVAL_UNDEFINED_OP1();
2438 }
2439 zend_type_error("Only arrays and Traversables can be unpacked");
2440 }
2441
2442 FREE_OP(opline->op1_type, opline->op1.var);
2443 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2444 }
2445
ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2446 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2447 {
2448 USE_OPLINE
2449 zval *args;
2450
2451 SAVE_OPLINE();
2452 args = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
2453
2454 if (UNEXPECTED(Z_TYPE_P(args) != IS_ARRAY)) {
2455 if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_ISREF_P(args)) {
2456 args = Z_REFVAL_P(args);
2457 if (EXPECTED(Z_TYPE_P(args) == IS_ARRAY)) {
2458 goto send_array;
2459 }
2460 }
2461 zend_type_error("call_user_func_array(): Argument #2 ($args) must be of type array, %s given", zend_zval_value_name(args));
2462 FREE_OP(opline->op2_type, opline->op2.var);
2463 FREE_OP(opline->op1_type, opline->op1.var);
2464 HANDLE_EXCEPTION();
2465 } else {
2466 uint32_t arg_num;
2467 HashTable *ht;
2468 zval *arg, *param;
2469
2470 send_array:
2471 ht = Z_ARRVAL_P(args);
2472 if (opline->op2_type != IS_UNUSED) {
2473 /* We don't need to handle named params in this case,
2474 * because array_slice() is called with $preserve_keys == false. */
2475 zval *op2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
2476 uint32_t skip = opline->extended_value;
2477 uint32_t count = zend_hash_num_elements(ht);
2478 zend_long len;
2479 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
2480 len = Z_LVAL_P(op2);
2481 } else if (Z_TYPE_P(op2) == IS_NULL) {
2482 len = count - skip;
2483 } else if (EX_USES_STRICT_TYPES()
2484 || !zend_parse_arg_long_weak(op2, &len, /* arg_num */ 3)) {
2485 zend_type_error(
2486 "array_slice(): Argument #3 ($length) must be of type ?int, %s given",
2487 zend_zval_value_name(op2));
2488 FREE_OP(opline->op2_type, opline->op2.var);
2489 FREE_OP(opline->op1_type, opline->op1.var);
2490 HANDLE_EXCEPTION();
2491 }
2492
2493 if (len < 0) {
2494 len += (zend_long)(count - skip);
2495 }
2496 if (skip < count && len > 0) {
2497 if (len > (zend_long)(count - skip)) {
2498 len = (zend_long)(count - skip);
2499 }
2500 zend_vm_stack_extend_call_frame(&EX(call), 0, len);
2501 arg_num = 1;
2502 param = ZEND_CALL_ARG(EX(call), 1);
2503 ZEND_HASH_FOREACH_VAL(ht, arg) {
2504 bool must_wrap = 0;
2505 if (skip > 0) {
2506 skip--;
2507 continue;
2508 } else if ((zend_long)(arg_num - 1) >= len) {
2509 break;
2510 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2511 if (UNEXPECTED(!Z_ISREF_P(arg))) {
2512 if (!ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
2513 /* By-value send is not allowed -- emit a warning,
2514 * but still perform the call. */
2515 zend_param_must_be_ref(EX(call)->func, arg_num);
2516 must_wrap = 1;
2517 }
2518 }
2519 } else {
2520 if (Z_ISREF_P(arg) &&
2521 !(EX(call)->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
2522 /* don't separate references for __call */
2523 arg = Z_REFVAL_P(arg);
2524 }
2525 }
2526 if (EXPECTED(!must_wrap)) {
2527 ZVAL_COPY(param, arg);
2528 } else {
2529 Z_TRY_ADDREF_P(arg);
2530 ZVAL_NEW_REF(param, arg);
2531 }
2532 ZEND_CALL_NUM_ARGS(EX(call))++;
2533 arg_num++;
2534 param++;
2535 } ZEND_HASH_FOREACH_END();
2536 }
2537 FREE_OP(opline->op2_type, opline->op2.var);
2538 } else {
2539 zend_string *name;
2540 bool have_named_params;
2541 zend_vm_stack_extend_call_frame(&EX(call), 0, zend_hash_num_elements(ht));
2542 arg_num = 1;
2543 param = ZEND_CALL_ARG(EX(call), 1);
2544 have_named_params = 0;
2545 ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
2546 if (name) {
2547 void *cache_slot[2] = {NULL, NULL};
2548 have_named_params = 1;
2549 param = zend_handle_named_arg(&EX(call), name, &arg_num, cache_slot);
2550 if (!param) {
2551 FREE_OP(opline->op1_type, opline->op1.var);
2552 HANDLE_EXCEPTION();
2553 }
2554 } else if (have_named_params) {
2555 zend_throw_error(NULL,
2556 "Cannot use positional argument after named argument");
2557 FREE_OP(opline->op1_type, opline->op1.var);
2558 HANDLE_EXCEPTION();
2559 }
2560
2561 bool must_wrap = 0;
2562 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
2579 if (EXPECTED(!must_wrap)) {
2580 ZVAL_COPY(param, arg);
2581 } else {
2582 Z_TRY_ADDREF_P(arg);
2583 ZVAL_NEW_REF(param, arg);
2584 }
2585 if (!name) {
2586 ZEND_CALL_NUM_ARGS(EX(call))++;
2587 arg_num++;
2588 param++;
2589 }
2590 } ZEND_HASH_FOREACH_END();
2591 }
2592 }
2593 FREE_OP(opline->op1_type, opline->op1.var);
2594 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2595 }
2596
zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)2597 static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
2598 {
2599 #ifdef ZEND_VM_IP_GLOBAL_REG
2600 USE_OPLINE
2601
2602 SAVE_OPLINE();
2603 #endif
2604 zend_missing_arg_error(execute_data);
2605 HANDLE_EXCEPTION();
2606 }
2607
zend_verify_recv_arg_type_helper_SPEC(zval * op_1 ZEND_OPCODE_HANDLER_ARGS_DC)2608 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)
2609 {
2610 USE_OPLINE
2611
2612 SAVE_OPLINE();
2613 if (UNEXPECTED(!zend_verify_recv_arg_type(EX(func), opline->op1.num, op_1, CACHE_ADDR(opline->extended_value)))) {
2614 HANDLE_EXCEPTION();
2615 }
2616
2617 ZEND_VM_NEXT_OPCODE();
2618 }
2619
ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2620 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2621 {
2622 USE_OPLINE
2623 uint32_t arg_num = opline->op1.num;
2624
2625 if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
2626 ZEND_VM_TAIL_CALL(zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
2627 }
2628
2629 ZEND_VM_NEXT_OPCODE();
2630 }
2631
zend_case_helper_SPEC(zval * op_1,zval * op_2 ZEND_OPCODE_HANDLER_ARGS_DC)2632 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)
2633 {
2634 int ret;
2635 USE_OPLINE
2636
2637 SAVE_OPLINE();
2638 if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
2639 op_1 = ZVAL_UNDEFINED_OP1();
2640 }
2641 if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
2642 op_2 = ZVAL_UNDEFINED_OP2();
2643 }
2644 ret = zend_compare(op_1, op_2);
2645 if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
2646 zval_ptr_dtor_nogc(op_2);
2647 }
2648 ZEND_VM_SMART_BRANCH(ret == 0, 1);
2649 }
2650
ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2651 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2652 {
2653 USE_OPLINE
2654 zval *op1;
2655 HashTable *result_ht;
2656
2657 SAVE_OPLINE();
2658 op1 = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
2659 result_ht = Z_ARRVAL_P(EX_VAR(opline->result.var));
2660
2661 add_unpack_again:
2662 if (EXPECTED(Z_TYPE_P(op1) == IS_ARRAY)) {
2663 HashTable *ht = Z_ARRVAL_P(op1);
2664 zval *val;
2665
2666 if (HT_IS_PACKED(ht) && (zend_hash_num_elements(result_ht) == 0 || HT_IS_PACKED(result_ht))) {
2667 zend_hash_extend(result_ht, result_ht->nNumUsed + zend_hash_num_elements(ht), 1);
2668 ZEND_HASH_FILL_PACKED(result_ht) {
2669 ZEND_HASH_PACKED_FOREACH_VAL(ht, val) {
2670 if (UNEXPECTED(Z_ISREF_P(val)) &&
2671 UNEXPECTED(Z_REFCOUNT_P(val) == 1)) {
2672 val = Z_REFVAL_P(val);
2673 }
2674 Z_TRY_ADDREF_P(val);
2675 ZEND_HASH_FILL_ADD(val);
2676 } ZEND_HASH_FOREACH_END();
2677 } ZEND_HASH_FILL_END();
2678 } else {
2679 zend_string *key;
2680
2681 ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
2682 if (UNEXPECTED(Z_ISREF_P(val)) &&
2683 UNEXPECTED(Z_REFCOUNT_P(val) == 1)) {
2684 val = Z_REFVAL_P(val);
2685 }
2686 Z_TRY_ADDREF_P(val);
2687 if (key) {
2688 zend_hash_update(result_ht, key, val);
2689 } else {
2690 if (!zend_hash_next_index_insert(result_ht, val)) {
2691 zend_cannot_add_element();
2692 zval_ptr_dtor_nogc(val);
2693 break;
2694 }
2695 }
2696 } ZEND_HASH_FOREACH_END();
2697 }
2698 } else if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
2699 zend_class_entry *ce = Z_OBJCE_P(op1);
2700 zend_object_iterator *iter;
2701
2702 if (!ce || !ce->get_iterator) {
2703 zend_type_error("Only arrays and Traversables can be unpacked");
2704 } else {
2705 iter = ce->get_iterator(ce, op1, 0);
2706 if (UNEXPECTED(!iter)) {
2707 FREE_OP(opline->op1_type, opline->op1.var);
2708 if (!EG(exception)) {
2709 zend_throw_exception_ex(
2710 NULL, 0, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)
2711 );
2712 }
2713 HANDLE_EXCEPTION();
2714 }
2715
2716 const zend_object_iterator_funcs *funcs = iter->funcs;
2717 if (funcs->rewind) {
2718 funcs->rewind(iter);
2719 }
2720
2721 for (; funcs->valid(iter) == SUCCESS; ) {
2722 zval *val;
2723
2724 if (UNEXPECTED(EG(exception) != NULL)) {
2725 break;
2726 }
2727
2728 val = funcs->get_current_data(iter);
2729 if (UNEXPECTED(EG(exception) != NULL)) {
2730 break;
2731 }
2732
2733 zval key;
2734 if (funcs->get_current_key) {
2735 funcs->get_current_key(iter, &key);
2736 if (UNEXPECTED(EG(exception) != NULL)) {
2737 break;
2738 }
2739
2740 if (UNEXPECTED(Z_TYPE(key) != IS_LONG && Z_TYPE(key) != IS_STRING)) {
2741 zend_throw_error(NULL,
2742 "Keys must be of type int|string during array unpacking");
2743 zval_ptr_dtor(&key);
2744 break;
2745 }
2746 } else {
2747 ZVAL_UNDEF(&key);
2748 }
2749
2750 ZVAL_DEREF(val);
2751 Z_TRY_ADDREF_P(val);
2752
2753 zend_ulong num_key;
2754 if (Z_TYPE(key) == IS_STRING && !ZEND_HANDLE_NUMERIC(Z_STR(key), num_key)) {
2755 zend_hash_update(result_ht, Z_STR(key), val);
2756 zval_ptr_dtor_str(&key);
2757 } else {
2758 zval_ptr_dtor(&key);
2759 if (!zend_hash_next_index_insert(result_ht, val)) {
2760 zend_cannot_add_element();
2761 zval_ptr_dtor_nogc(val);
2762 break;
2763 }
2764 }
2765
2766 funcs->move_forward(iter);
2767 if (UNEXPECTED(EG(exception))) {
2768 break;
2769 }
2770 }
2771
2772 zend_iterator_dtor(iter);
2773 }
2774 } else if (EXPECTED(Z_ISREF_P(op1))) {
2775 op1 = Z_REFVAL_P(op1);
2776 goto add_unpack_again;
2777 } else {
2778 zend_throw_error(NULL, "Only arrays and Traversables can be unpacked");
2779 }
2780
2781 FREE_OP(opline->op1_type, opline->op1.var);
2782 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2783 }
2784
ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2785 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2786 {
2787 USE_OPLINE
2788 zval *varname;
2789 zend_string *name, *tmp_name = NULL;
2790 zend_class_entry *ce;
2791
2792 SAVE_OPLINE();
2793
2794 if (opline->op2_type == IS_CONST) {
2795 ce = CACHED_PTR(opline->extended_value);
2796 if (UNEXPECTED(ce == NULL)) {
2797 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);
2798 if (UNEXPECTED(ce == NULL)) {
2799 FREE_OP(opline->op1_type, opline->op1.var);
2800 HANDLE_EXCEPTION();
2801 }
2802 /*CACHE_PTR(opline->extended_value, ce);*/
2803 }
2804 } else if (opline->op2_type == IS_UNUSED) {
2805 ce = zend_fetch_class(NULL, opline->op2.num);
2806 if (UNEXPECTED(ce == NULL)) {
2807 FREE_OP(opline->op1_type, opline->op1.var);
2808 HANDLE_EXCEPTION();
2809 }
2810 } else {
2811 ce = Z_CE_P(EX_VAR(opline->op2.var));
2812 }
2813
2814 varname = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
2815 if (opline->op1_type == IS_CONST) {
2816 name = Z_STR_P(varname);
2817 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
2818 name = Z_STR_P(varname);
2819 } else {
2820 if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
2821 varname = ZVAL_UNDEFINED_OP1();
2822 }
2823 name = zval_try_get_tmp_string(varname, &tmp_name);
2824 if (UNEXPECTED(!name)) {
2825 FREE_OP(opline->op1_type, opline->op1.var);
2826 HANDLE_EXCEPTION();
2827 }
2828 }
2829
2830 zend_std_unset_static_property(ce, name);
2831
2832 zend_tmp_string_release(tmp_name);
2833 FREE_OP(opline->op1_type, opline->op1.var);
2834 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2835 }
2836
zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)2837 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
2838 {
2839 USE_OPLINE
2840 zval *array;
2841 zval *value;
2842 uint32_t value_type;
2843 HashTable *fe_ht;
2844 HashPosition pos;
2845 Bucket *p;
2846 zend_object_iterator *iter;
2847
2848 array = EX_VAR(opline->op1.var);
2849 SAVE_OPLINE();
2850
2851 ZEND_ASSERT(Z_TYPE_P(array) == IS_OBJECT);
2852 if ((iter = zend_iterator_unwrap(array)) == NULL) {
2853 /* plain object */
2854
2855 fe_ht = Z_OBJPROP_P(array);
2856 pos = zend_hash_iterator_pos(Z_FE_ITER_P(array), fe_ht);
2857 p = fe_ht->arData + pos;
2858 while (1) {
2859 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
2860 /* reached end of iteration */
2861 goto fe_fetch_r_exit;
2862 }
2863 pos++;
2864 value = &p->val;
2865 value_type = Z_TYPE_INFO_P(value);
2866 if (EXPECTED(value_type != IS_UNDEF)) {
2867 if (UNEXPECTED(value_type == IS_INDIRECT)) {
2868 value = Z_INDIRECT_P(value);
2869 value_type = Z_TYPE_INFO_P(value);
2870 if (EXPECTED(value_type != IS_UNDEF)
2871 && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
2872 break;
2873 }
2874 } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
2875 || !p->key
2876 || zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
2877 break;
2878 }
2879 }
2880 p++;
2881 }
2882 EG(ht_iterators)[Z_FE_ITER_P(array)].pos = pos;
2883 if (RETURN_VALUE_USED(opline)) {
2884 if (UNEXPECTED(!p->key)) {
2885 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
2886 } else if (ZSTR_VAL(p->key)[0]) {
2887 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
2888 } else {
2889 const char *class_name, *prop_name;
2890 size_t prop_name_len;
2891 zend_unmangle_property_name_ex(
2892 p->key, &class_name, &prop_name, &prop_name_len);
2893 ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
2894 }
2895 }
2896 } else {
2897 const zend_object_iterator_funcs *funcs = iter->funcs;
2898 if (EXPECTED(++iter->index > 0)) {
2899 /* This could cause an endless loop if index becomes zero again.
2900 * In case that ever happens we need an additional flag. */
2901 funcs->move_forward(iter);
2902 if (UNEXPECTED(EG(exception) != NULL)) {
2903 UNDEF_RESULT();
2904 HANDLE_EXCEPTION();
2905 }
2906 if (UNEXPECTED(funcs->valid(iter) == FAILURE)) {
2907 /* reached end of iteration */
2908 if (UNEXPECTED(EG(exception) != NULL)) {
2909 UNDEF_RESULT();
2910 HANDLE_EXCEPTION();
2911 }
2912 fe_fetch_r_exit:
2913 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
2914 ZEND_VM_CONTINUE();
2915 }
2916 }
2917 value = funcs->get_current_data(iter);
2918 if (UNEXPECTED(EG(exception) != NULL)) {
2919 UNDEF_RESULT();
2920 HANDLE_EXCEPTION();
2921 }
2922 if (!value) {
2923 /* failure in get_current_data */
2924 goto fe_fetch_r_exit;
2925 }
2926 if (RETURN_VALUE_USED(opline)) {
2927 if (funcs->get_current_key) {
2928 funcs->get_current_key(iter, EX_VAR(opline->result.var));
2929 if (UNEXPECTED(EG(exception) != NULL)) {
2930 UNDEF_RESULT();
2931 HANDLE_EXCEPTION();
2932 }
2933 } else {
2934 ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
2935 }
2936 }
2937 value_type = Z_TYPE_INFO_P(value);
2938 }
2939
2940 if (EXPECTED(opline->op2_type == IS_CV)) {
2941 zval *variable_ptr = EX_VAR(opline->op2.var);
2942 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
2943 } else {
2944 zval *res = EX_VAR(opline->op2.var);
2945 zend_refcounted *gc = Z_COUNTED_P(value);
2946
2947 ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
2948 if (Z_TYPE_INFO_REFCOUNTED(value_type)) {
2949 GC_ADDREF(gc);
2950 }
2951 }
2952 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
2953 }
2954
ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2955 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2956 {
2957 USE_OPLINE
2958 zval *value;
2959 zend_result fetch_result;
2960 bool result;
2961
2962 SAVE_OPLINE();
2963
2964 fetch_result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
2965
2966 if (!(opline->extended_value & ZEND_ISEMPTY)) {
2967 result = fetch_result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
2968 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
2969 } else {
2970 result = fetch_result != SUCCESS || !i_zend_is_true(value);
2971 }
2972
2973 ZEND_VM_SMART_BRANCH(result, 1);
2974 }
2975
ZEND_EXIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)2976 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
2977 {
2978 USE_OPLINE
2979
2980 SAVE_OPLINE();
2981 if (opline->op1_type != IS_UNUSED) {
2982 zval *ptr = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
2983
2984 do {
2985 if (Z_TYPE_P(ptr) == IS_LONG) {
2986 EG(exit_status) = Z_LVAL_P(ptr);
2987 } else {
2988 if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_ISREF_P(ptr)) {
2989 ptr = Z_REFVAL_P(ptr);
2990 if (Z_TYPE_P(ptr) == IS_LONG) {
2991 EG(exit_status) = Z_LVAL_P(ptr);
2992 break;
2993 }
2994 }
2995 zend_print_zval(ptr, 0);
2996 }
2997 } while (0);
2998 FREE_OP(opline->op1_type, opline->op1.var);
2999 }
3000
3001 if (!EG(exception)) {
3002 zend_throw_unwind_exit();
3003 }
3004 HANDLE_EXCEPTION();
3005 }
3006
ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3007 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3008 {
3009 USE_OPLINE
3010
3011 ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting));
3012
3013 if (!E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))) {
3014 do {
3015 /* Do not silence fatal errors */
3016 EG(error_reporting) &= E_FATAL_ERRORS;
3017 if (!EG(error_reporting_ini_entry)) {
3018 zval *zv = zend_hash_find_known_hash(EG(ini_directives), ZSTR_KNOWN(ZEND_STR_ERROR_REPORTING));
3019 if (zv) {
3020 EG(error_reporting_ini_entry) = (zend_ini_entry *)Z_PTR_P(zv);
3021 } else {
3022 break;
3023 }
3024 }
3025 if (!EG(error_reporting_ini_entry)->modified) {
3026 if (!EG(modified_ini_directives)) {
3027 ALLOC_HASHTABLE(EG(modified_ini_directives));
3028 zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
3029 }
3030 if (EXPECTED(zend_hash_add_ptr(EG(modified_ini_directives), ZSTR_KNOWN(ZEND_STR_ERROR_REPORTING), EG(error_reporting_ini_entry)) != NULL)) {
3031 EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
3032 EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
3033 EG(error_reporting_ini_entry)->modified = 1;
3034 }
3035 }
3036 } while (0);
3037 }
3038 ZEND_VM_NEXT_OPCODE();
3039 }
3040
ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3041 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3042 {
3043 USE_OPLINE
3044
3045 if (!EG(no_extensions)) {
3046 SAVE_OPLINE();
3047 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_statement_handler, execute_data);
3048 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3049 }
3050 ZEND_VM_NEXT_OPCODE();
3051 }
3052
ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3053 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3054 {
3055 USE_OPLINE
3056
3057 if (!EG(no_extensions)) {
3058 SAVE_OPLINE();
3059 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_begin_handler, execute_data);
3060 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3061 }
3062 ZEND_VM_NEXT_OPCODE();
3063 }
3064
ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3065 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3066 {
3067 USE_OPLINE
3068
3069 if (!EG(no_extensions)) {
3070 SAVE_OPLINE();
3071 zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_fcall_end_handler, execute_data);
3072 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3073 }
3074 ZEND_VM_NEXT_OPCODE();
3075 }
3076
ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3077 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3078 {
3079 zval *zv;
3080 zend_class_entry *ce;
3081 USE_OPLINE
3082
3083 ce = CACHED_PTR(opline->extended_value);
3084 if (UNEXPECTED(ce == NULL)) {
3085 zend_string *rtd_key = Z_STR_P(RT_CONSTANT(opline, opline->op1));
3086 zv = zend_hash_find_known_hash(EG(class_table), rtd_key);
3087 ZEND_ASSERT(zv != NULL);
3088 ce = Z_CE_P(zv);
3089 if (!(ce->ce_flags & ZEND_ACC_LINKED)) {
3090 SAVE_OPLINE();
3091 ce = zend_do_link_class(ce, (opline->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL, rtd_key);
3092 if (!ce) {
3093 HANDLE_EXCEPTION();
3094 }
3095 }
3096 CACHE_PTR(opline->extended_value, ce);
3097 }
3098 Z_CE_P(EX_VAR(opline->result.var)) = ce;
3099 ZEND_VM_NEXT_OPCODE();
3100 }
3101
ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3102 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3103 {
3104 zend_function *func;
3105 USE_OPLINE
3106
3107 SAVE_OPLINE();
3108 func = (zend_function *) EX(func)->op_array.dynamic_func_defs[opline->op2.num];
3109 do_bind_function(func, RT_CONSTANT(opline, opline->op1));
3110 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3111 }
3112
ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3113 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3114 {
3115 USE_OPLINE
3116
3117 if ((uint32_t)++EG(ticks_count) >= opline->extended_value) {
3118 EG(ticks_count) = 0;
3119 if (zend_ticks_function) {
3120 SAVE_OPLINE();
3121 zend_fiber_switch_block();
3122 zend_ticks_function(opline->extended_value);
3123 zend_fiber_switch_unblock();
3124 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3125 }
3126 }
3127 ZEND_VM_NEXT_OPCODE();
3128 }
3129
ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3130 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3131 {
3132 USE_OPLINE
3133
3134 ZEND_VM_NEXT_OPCODE();
3135 }
3136
ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3137 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3138 {
3139 USE_OPLINE
3140
3141 ZEND_VM_NEXT_OPCODE();
3142 }
3143
zend_dispatch_try_catch_finally_helper_SPEC(uint32_t try_catch_offset,uint32_t op_num ZEND_OPCODE_HANDLER_ARGS_DC)3144 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)
3145 {
3146 /* May be NULL during generator closing (only finally blocks are executed) */
3147 zend_object *ex = EG(exception);
3148
3149 /* Walk try/catch/finally structures upwards, performing the necessary actions */
3150 for (; try_catch_offset != (uint32_t) -1; try_catch_offset--) {
3151 zend_try_catch_element *try_catch =
3152 &EX(func)->op_array.try_catch_array[try_catch_offset];
3153
3154 if (op_num < try_catch->catch_op && ex) {
3155 /* Go to catch block */
3156 cleanup_live_vars(execute_data, op_num, try_catch->catch_op);
3157 ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->catch_op], 0);
3158
3159 } else if (op_num < try_catch->finally_op) {
3160 if (ex && zend_is_unwind_exit(ex)) {
3161 /* Don't execute finally blocks on exit (for now) */
3162 continue;
3163 }
3164
3165 /* Go to finally block */
3166 zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var);
3167 cleanup_live_vars(execute_data, op_num, try_catch->finally_op);
3168 Z_OBJ_P(fast_call) = EG(exception);
3169 EG(exception) = NULL;
3170 Z_OPLINE_NUM_P(fast_call) = (uint32_t)-1;
3171 ZEND_VM_JMP_EX(&EX(func)->op_array.opcodes[try_catch->finally_op], 0);
3172
3173 } else if (op_num < try_catch->finally_end) {
3174 zval *fast_call = EX_VAR(EX(func)->op_array.opcodes[try_catch->finally_end].op1.var);
3175
3176 /* cleanup incomplete RETURN statement */
3177 if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1
3178 && (EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2_type & (IS_TMP_VAR | IS_VAR))) {
3179 zval *return_value = EX_VAR(EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2.var);
3180
3181 zval_ptr_dtor(return_value);
3182 }
3183
3184 /* Chain potential exception from wrapping finally block */
3185 if (Z_OBJ_P(fast_call)) {
3186 if (ex) {
3187 if (zend_is_unwind_exit(ex) || zend_is_graceful_exit(ex)) {
3188 /* discard the previously thrown exception */
3189 OBJ_RELEASE(Z_OBJ_P(fast_call));
3190 } else {
3191 zend_exception_set_previous(ex, Z_OBJ_P(fast_call));
3192 }
3193 } else {
3194 ex = EG(exception) = Z_OBJ_P(fast_call);
3195 }
3196 }
3197 }
3198 }
3199
3200 /* Uncaught exception */
3201 if (zend_observer_fcall_op_array_extension != -1) {
3202 zend_observer_fcall_end(execute_data, NULL);
3203 }
3204 cleanup_live_vars(execute_data, op_num, 0);
3205 if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
3206 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
3207 EG(current_execute_data) = EX(prev_execute_data);
3208 zend_generator_close(generator, 1);
3209 ZEND_VM_RETURN();
3210 } else {
3211 /* We didn't execute RETURN, and have to initialize return_value */
3212 if (EX(return_value)) {
3213 ZVAL_UNDEF(EX(return_value));
3214 }
3215 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3216 }
3217 }
3218
ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3219 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3220 {
3221 const zend_op *throw_op = EG(opline_before_exception);
3222
3223 /* Exception was thrown before executing any op */
3224 if (UNEXPECTED(!throw_op)) {
3225 ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(-1, 0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
3226 }
3227
3228 uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes;
3229 int i, current_try_catch_offset = -1;
3230
3231 if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE)
3232 && throw_op->extended_value & ZEND_FREE_ON_RETURN) {
3233 /* exceptions thrown because of loop var destruction on return/break/...
3234 * are logically thrown at the end of the foreach loop, so adjust the
3235 * throw_op_num.
3236 */
3237 const zend_live_range *range = find_live_range(
3238 &EX(func)->op_array, throw_op_num, throw_op->op1.var);
3239 /* free op1 of the corresponding RETURN */
3240 for (i = throw_op_num; i < range->end; i++) {
3241 if (EX(func)->op_array.opcodes[i].opcode == ZEND_FREE
3242 || EX(func)->op_array.opcodes[i].opcode == ZEND_FE_FREE) {
3243 /* pass */
3244 } else {
3245 if (EX(func)->op_array.opcodes[i].opcode == ZEND_RETURN
3246 && (EX(func)->op_array.opcodes[i].op1_type & (IS_VAR|IS_TMP_VAR))) {
3247 zval_ptr_dtor(EX_VAR(EX(func)->op_array.opcodes[i].op1.var));
3248 }
3249 break;
3250 }
3251 }
3252 throw_op_num = range->end;
3253 }
3254
3255 /* Find the innermost try/catch/finally the exception was thrown in */
3256 for (i = 0; i < EX(func)->op_array.last_try_catch; i++) {
3257 zend_try_catch_element *try_catch = &EX(func)->op_array.try_catch_array[i];
3258 if (try_catch->try_op > throw_op_num) {
3259 /* further blocks will not be relevant... */
3260 break;
3261 }
3262 if (throw_op_num < try_catch->catch_op || throw_op_num < try_catch->finally_end) {
3263 current_try_catch_offset = i;
3264 }
3265 }
3266
3267 cleanup_unfinished_calls(execute_data, throw_op_num);
3268
3269 if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) {
3270 switch (throw_op->opcode) {
3271 case ZEND_ADD_ARRAY_ELEMENT:
3272 case ZEND_ADD_ARRAY_UNPACK:
3273 case ZEND_ROPE_INIT:
3274 case ZEND_ROPE_ADD:
3275 break; /* exception while building structures, live range handling will free those */
3276
3277 case ZEND_FETCH_CLASS:
3278 case ZEND_DECLARE_ANON_CLASS:
3279 break; /* return value is zend_class_entry pointer */
3280
3281 default:
3282 /* smart branch opcodes may not initialize result */
3283 if (!zend_is_smart_branch(throw_op)) {
3284 zval_ptr_dtor_nogc(EX_VAR(throw_op->result.var));
3285 }
3286 }
3287 }
3288
3289 ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(current_try_catch_offset, throw_op_num ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
3290 }
3291
ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3292 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3293 {
3294 USE_OPLINE
3295 int ret;
3296
3297 SAVE_OPLINE();
3298 ret = zend_user_opcode_handlers[opline->opcode](execute_data);
3299 opline = EX(opline);
3300
3301 switch (ret) {
3302 case ZEND_USER_OPCODE_CONTINUE:
3303 ZEND_VM_CONTINUE();
3304 case ZEND_USER_OPCODE_RETURN:
3305 if (UNEXPECTED((EX_CALL_INFO() & ZEND_CALL_GENERATOR) != 0)) {
3306 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
3307 EG(current_execute_data) = EX(prev_execute_data);
3308 zend_generator_close(generator, 1);
3309 ZEND_VM_RETURN();
3310 } else {
3311 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3312 }
3313 case ZEND_USER_OPCODE_ENTER:
3314 ZEND_VM_ENTER();
3315 case ZEND_USER_OPCODE_LEAVE:
3316 ZEND_VM_LEAVE();
3317 case ZEND_USER_OPCODE_DISPATCH:
3318 ZEND_VM_DISPATCH(opline->opcode, opline);
3319 default:
3320 ZEND_VM_DISPATCH((uint8_t)(ret & 0xff), opline);
3321 }
3322 }
3323
zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)3324 static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
3325 {
3326 USE_OPLINE
3327
3328 SAVE_OPLINE();
3329 zend_throw_error(NULL, "Cannot yield from finally in a force-closed generator");
3330 FREE_OP(opline->op2_type, opline->op2.var);
3331 FREE_OP(opline->op1_type, opline->op1.var);
3332 UNDEF_RESULT();
3333 HANDLE_EXCEPTION();
3334 }
3335
ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3336 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3337 {
3338 USE_OPLINE
3339 zval *fast_call = EX_VAR(opline->op1.var);
3340 SAVE_OPLINE();
3341
3342 /* cleanup incomplete RETURN statement */
3343 if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1
3344 && (EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2_type & (IS_TMP_VAR | IS_VAR))) {
3345 zval *return_value = EX_VAR(EX(func)->op_array.opcodes[Z_OPLINE_NUM_P(fast_call)].op2.var);
3346
3347 zval_ptr_dtor(return_value);
3348 }
3349
3350 /* cleanup delayed exception */
3351 if (Z_OBJ_P(fast_call) != NULL) {
3352 /* discard the previously thrown exception */
3353 OBJ_RELEASE(Z_OBJ_P(fast_call));
3354 Z_OBJ_P(fast_call) = NULL;
3355 }
3356
3357 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3358 }
3359
ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3360 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3361 {
3362 USE_OPLINE
3363 zval *fast_call = EX_VAR(opline->result.var);
3364
3365 Z_OBJ_P(fast_call) = NULL;
3366 /* set return address */
3367 Z_OPLINE_NUM_P(fast_call) = opline - EX(func)->op_array.opcodes;
3368 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op1), 0);
3369 }
3370
ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3371 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3372 {
3373 USE_OPLINE
3374 zval *fast_call = EX_VAR(opline->op1.var);
3375 uint32_t current_try_catch_offset, current_op_num;
3376
3377 if (Z_OPLINE_NUM_P(fast_call) != (uint32_t)-1) {
3378 const zend_op *fast_ret = EX(func)->op_array.opcodes + Z_OPLINE_NUM_P(fast_call);
3379
3380 ZEND_VM_JMP_EX(fast_ret + 1, 0);
3381 }
3382
3383 /* special case for unhandled exceptions */
3384 EG(exception) = Z_OBJ_P(fast_call);
3385 Z_OBJ_P(fast_call) = NULL;
3386 current_try_catch_offset = opline->op2.num;
3387 current_op_num = opline - EX(func)->op_array.opcodes;
3388 ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(current_try_catch_offset, current_op_num ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
3389 }
3390
ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3391 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3392 {
3393 USE_OPLINE
3394
3395 if (EG(assertions) <= 0) {
3396 zend_op *target = OP_JMP_ADDR(opline, opline->op2);
3397 if (RETURN_VALUE_USED(opline)) {
3398 ZVAL_TRUE(EX_VAR(opline->result.var));
3399 }
3400 ZEND_VM_JMP_EX(target, 0);
3401 } else {
3402 ZEND_VM_NEXT_OPCODE();
3403 }
3404 }
3405
ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3406 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3407 {
3408 zend_array *args = NULL;
3409 zend_function *fbc = EX(func);
3410 zval *ret = EX(return_value);
3411 uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS);
3412 uint32_t num_args = EX_NUM_ARGS();
3413 zend_execute_data *call;
3414
3415 SAVE_OPLINE();
3416
3417 if (num_args) {
3418 zval *p = ZEND_CALL_ARG(execute_data, 1);
3419 zval *end = p + num_args;
3420
3421 args = zend_new_array(num_args);
3422 zend_hash_real_init_packed(args);
3423 ZEND_HASH_FILL_PACKED(args) {
3424 do {
3425 ZEND_HASH_FILL_ADD(p);
3426 p++;
3427 } while (p != end);
3428 } ZEND_HASH_FILL_END();
3429 }
3430
3431 call = execute_data;
3432 execute_data = EG(current_execute_data) = EX(prev_execute_data);
3433
3434 call->func = (fbc->op_array.fn_flags & ZEND_ACC_STATIC) ? fbc->op_array.scope->__callstatic : fbc->op_array.scope->__call;
3435 ZEND_ASSERT(zend_vm_calc_used_stack(2, call->func) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call));
3436 ZEND_CALL_NUM_ARGS(call) = 2;
3437
3438 ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name);
3439
3440 zval *call_args = ZEND_CALL_ARG(call, 2);
3441 if (args) {
3442 ZVAL_ARR(call_args, args);
3443 } else {
3444 ZVAL_EMPTY_ARRAY(call_args);
3445 }
3446 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3447 if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) {
3448 GC_ADDREF(call->extra_named_params);
3449 ZVAL_ARR(call_args, call->extra_named_params);
3450 } else {
3451 SEPARATE_ARRAY(call_args);
3452 zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref);
3453 }
3454 }
3455 zend_free_trampoline(fbc);
3456 fbc = call->func;
3457
3458 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
3459 if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3460 init_func_run_time_cache(&fbc->op_array);
3461 }
3462 execute_data = call;
3463 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
3464 if (EXPECTED(zend_execute_ex == execute_ex)) {
3465 LOAD_OPLINE_EX();
3466
3467
3468 ZEND_VM_ENTER_EX();
3469 } else {
3470 SAVE_OPLINE_EX();
3471
3472 execute_data = EX(prev_execute_data);
3473 if (execute_data) {
3474 LOAD_OPLINE();
3475 }
3476 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
3477 zend_execute_ex(call);
3478 }
3479 } else {
3480 zval retval;
3481
3482 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
3483
3484 EG(current_execute_data) = call;
3485
3486 #if ZEND_DEBUG
3487 bool should_throw = zend_internal_call_should_throw(fbc, call);
3488 #endif
3489
3490 if (ret == NULL) {
3491 ret = &retval;
3492 }
3493
3494 ZVAL_NULL(ret);
3495
3496 if (!zend_execute_internal) {
3497 /* saves one function call if zend_execute_internal is not used */
3498 fbc->internal_function.handler(call, ret);
3499 } else {
3500 zend_execute_internal(call, ret);
3501 }
3502
3503 #if ZEND_DEBUG
3504 if (!EG(exception) && call->func) {
3505 if (should_throw) {
3506 zend_internal_call_arginfo_violation(call->func);
3507 }
3508 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
3509 zend_verify_internal_return_type(call->func, ret));
3510 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
3511 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
3512 zend_verify_internal_func_info(call->func, ret);
3513 }
3514 #endif
3515
3516 EG(current_execute_data) = call->prev_execute_data;
3517
3518 zend_vm_stack_free_args(call);
3519 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3520 zend_free_extra_named_params(call->extra_named_params);
3521 }
3522 if (ret == &retval) {
3523 zval_ptr_dtor(ret);
3524 }
3525 }
3526
3527 execute_data = EG(current_execute_data);
3528
3529 if (!execute_data || !EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
3530 ZEND_VM_RETURN();
3531 }
3532
3533 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
3534 zend_object *object = Z_OBJ(call->This);
3535 OBJ_RELEASE(object);
3536 }
3537 zend_vm_stack_free_call_frame(call);
3538
3539 if (UNEXPECTED(EG(exception) != NULL)) {
3540 zend_rethrow_exception(execute_data);
3541 HANDLE_EXCEPTION_LEAVE();
3542 }
3543
3544 LOAD_OPLINE();
3545 ZEND_VM_INC_OPCODE();
3546 ZEND_VM_LEAVE();
3547 }
3548
ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3549 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3550 {
3551 zend_array *args = NULL;
3552 zend_function *fbc = EX(func);
3553 zval *ret = EX(return_value);
3554 uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS);
3555 uint32_t num_args = EX_NUM_ARGS();
3556 zend_execute_data *call;
3557
3558 SAVE_OPLINE();
3559
3560 if (num_args) {
3561 zval *p = ZEND_CALL_ARG(execute_data, 1);
3562 zval *end = p + num_args;
3563
3564 args = zend_new_array(num_args);
3565 zend_hash_real_init_packed(args);
3566 ZEND_HASH_FILL_PACKED(args) {
3567 do {
3568 ZEND_HASH_FILL_ADD(p);
3569 p++;
3570 } while (p != end);
3571 } ZEND_HASH_FILL_END();
3572 }
3573
3574 call = execute_data;
3575 execute_data = EG(current_execute_data) = EX(prev_execute_data);
3576
3577 call->func = (fbc->op_array.fn_flags & ZEND_ACC_STATIC) ? fbc->op_array.scope->__callstatic : fbc->op_array.scope->__call;
3578 ZEND_ASSERT(zend_vm_calc_used_stack(2, call->func) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call));
3579 ZEND_CALL_NUM_ARGS(call) = 2;
3580
3581 ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name);
3582
3583 zval *call_args = ZEND_CALL_ARG(call, 2);
3584 if (args) {
3585 ZVAL_ARR(call_args, args);
3586 } else {
3587 ZVAL_EMPTY_ARRAY(call_args);
3588 }
3589 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3590 if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) {
3591 GC_ADDREF(call->extra_named_params);
3592 ZVAL_ARR(call_args, call->extra_named_params);
3593 } else {
3594 SEPARATE_ARRAY(call_args);
3595 zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref);
3596 }
3597 }
3598 zend_free_trampoline(fbc);
3599 fbc = call->func;
3600
3601 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
3602 if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3603 init_func_run_time_cache(&fbc->op_array);
3604 }
3605 execute_data = call;
3606 i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
3607 if (EXPECTED(zend_execute_ex == execute_ex)) {
3608 LOAD_OPLINE_EX();
3609 SAVE_OPLINE();
3610 zend_observer_fcall_begin(execute_data);
3611 ZEND_VM_ENTER_EX();
3612 } else {
3613 SAVE_OPLINE_EX();
3614 zend_observer_fcall_begin(execute_data);
3615 execute_data = EX(prev_execute_data);
3616 if (execute_data) {
3617 LOAD_OPLINE();
3618 }
3619 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
3620 zend_execute_ex(call);
3621 }
3622 } else {
3623 zval retval;
3624
3625 ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
3626
3627 EG(current_execute_data) = call;
3628
3629 #if ZEND_DEBUG
3630 bool should_throw = zend_internal_call_should_throw(fbc, call);
3631 #endif
3632
3633 if (ret == NULL) {
3634 ret = &retval;
3635 }
3636
3637 ZVAL_NULL(ret);
3638 zend_observer_fcall_begin(call);
3639 if (!zend_execute_internal) {
3640 /* saves one function call if zend_execute_internal is not used */
3641 fbc->internal_function.handler(call, ret);
3642 } else {
3643 zend_execute_internal(call, ret);
3644 }
3645
3646 #if ZEND_DEBUG
3647 if (!EG(exception) && call->func) {
3648 if (should_throw) {
3649 zend_internal_call_arginfo_violation(call->func);
3650 }
3651 ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
3652 zend_verify_internal_return_type(call->func, ret));
3653 ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
3654 ? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
3655 zend_verify_internal_func_info(call->func, ret);
3656 }
3657 #endif
3658 zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
3659
3660 EG(current_execute_data) = call->prev_execute_data;
3661
3662 zend_vm_stack_free_args(call);
3663 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
3664 zend_free_extra_named_params(call->extra_named_params);
3665 }
3666 if (ret == &retval) {
3667 zval_ptr_dtor(ret);
3668 }
3669 }
3670
3671 execute_data = EG(current_execute_data);
3672
3673 if (!execute_data || !EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
3674 ZEND_VM_RETURN();
3675 }
3676
3677 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
3678 zend_object *object = Z_OBJ(call->This);
3679 OBJ_RELEASE(object);
3680 }
3681 zend_vm_stack_free_call_frame(call);
3682
3683 if (UNEXPECTED(EG(exception) != NULL)) {
3684 zend_rethrow_exception(execute_data);
3685 HANDLE_EXCEPTION_LEAVE();
3686 }
3687
3688 LOAD_OPLINE();
3689 ZEND_VM_INC_OPCODE();
3690 ZEND_VM_LEAVE();
3691 }
3692
ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3693 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3694 {
3695 USE_OPLINE
3696 SAVE_OPLINE();
3697 zend_frameless_function_2 function = (zend_frameless_function_2)ZEND_FLF_HANDLER(opline);
3698 ZVAL_NULL(EX_VAR(opline->result.var));
3699 zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3700 zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3701 if (EG(exception)) {
3702 FREE_OP(opline->op1_type, opline->op1.var);
3703 FREE_OP(opline->op2_type, opline->op2.var);
3704 HANDLE_EXCEPTION();
3705 }
3706 function(EX_VAR(opline->result.var), arg1, arg2);
3707 FREE_OP(opline->op1_type, opline->op1.var);
3708 /* Set OP1 to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3709 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3710 ZVAL_UNDEF(EX_VAR(opline->op1.var));
3711 }
3712 FREE_OP(opline->op2_type, opline->op2.var);
3713 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3714 }
3715
ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3716 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3717 {
3718 USE_OPLINE
3719 SAVE_OPLINE();
3720 zend_frameless_function_3 function = (zend_frameless_function_3)ZEND_FLF_HANDLER(opline);
3721 ZVAL_NULL(EX_VAR(opline->result.var));
3722 zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
3723 zval *arg2 = get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R);
3724 zval *arg3 = get_op_data_zval_ptr_deref_r((opline+1)->op1_type, (opline+1)->op1);
3725 if (EG(exception)) {
3726 FREE_OP(opline->op1_type, opline->op1.var);
3727 FREE_OP(opline->op2_type, opline->op2.var);
3728 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3729 HANDLE_EXCEPTION();
3730 }
3731 function(EX_VAR(opline->result.var), arg1, arg2, arg3);
3732 FREE_OP(opline->op1_type, opline->op1.var);
3733 /* Set to UNDEF in case FREE_OP(opline->op2_type, opline->op2.var) throws. */
3734 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
3735 ZVAL_UNDEF(EX_VAR(opline->op1.var));
3736 }
3737 FREE_OP(opline->op2_type, opline->op2.var);
3738 if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) {
3739 ZVAL_UNDEF(EX_VAR(opline->op2.var));
3740 }
3741 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
3742 ZEND_VM_NEXT_OPCODE_EX(1, 2);
3743 }
3744
ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3745 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3746 {
3747 USE_OPLINE
3748
3749 OPLINE = OP_JMP_ADDR(opline, opline->op1);
3750 ZEND_VM_CONTINUE();
3751 }
3752
zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)3753 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_interrupt_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
3754 {
3755 zend_atomic_bool_store_ex(&EG(vm_interrupt), false);
3756 SAVE_OPLINE();
3757 if (zend_atomic_bool_load_ex(&EG(timed_out))) {
3758 zend_timeout();
3759 } else if (zend_interrupt_function) {
3760 zend_interrupt_function(execute_data);
3761 if (EG(exception)) {
3762 /* We have to UNDEF result, because ZEND_HANDLE_EXCEPTION is going to free it */
3763 const zend_op *throw_op = EG(opline_before_exception);
3764
3765 if (throw_op
3766 && throw_op->result_type & (IS_TMP_VAR|IS_VAR)
3767 && throw_op->opcode != ZEND_ADD_ARRAY_ELEMENT
3768 && throw_op->opcode != ZEND_ADD_ARRAY_UNPACK
3769 && throw_op->opcode != ZEND_ROPE_INIT
3770 && throw_op->opcode != ZEND_ROPE_ADD) {
3771 ZVAL_UNDEF(ZEND_CALL_VAR(EG(current_execute_data), throw_op->result.var));
3772
3773 }
3774 }
3775 ZEND_VM_ENTER();
3776 }
3777 ZEND_VM_CONTINUE();
3778 }
ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3779 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3780 {
3781 USE_OPLINE
3782 zend_function *fbc;
3783 zval *function_name, *func;
3784 zend_execute_data *call;
3785
3786 fbc = CACHED_PTR(opline->result.num);
3787 if (UNEXPECTED(fbc == NULL)) {
3788 function_name = (zval*)RT_CONSTANT(opline, opline->op2);
3789 func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(function_name+1));
3790 if (UNEXPECTED(func == NULL)) {
3791 ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3792 }
3793 fbc = Z_FUNC_P(func);
3794 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3795 init_func_run_time_cache(&fbc->op_array);
3796 }
3797 CACHE_PTR(opline->result.num, fbc);
3798 }
3799 call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
3800 fbc, opline->extended_value, NULL);
3801 call->prev_execute_data = EX(call);
3802 EX(call) = call;
3803
3804 ZEND_VM_NEXT_OPCODE();
3805 }
3806
ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3807 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3808 {
3809 USE_OPLINE
3810 zval *function_name;
3811 zend_execute_data *call;
3812
3813 SAVE_OPLINE();
3814 function_name = RT_CONSTANT(opline, opline->op2);
3815
3816 try_function_name:
3817 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
3818 call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
3819 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
3820 call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
3821 } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
3822 call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
3823 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
3824 function_name = Z_REFVAL_P(function_name);
3825 goto try_function_name;
3826 } else {
3827 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
3828 function_name = ZVAL_UNDEFINED_OP2();
3829 if (UNEXPECTED(EG(exception) != NULL)) {
3830 HANDLE_EXCEPTION();
3831 }
3832 }
3833 zend_throw_error(NULL, "Value of type %s is not callable",
3834 zend_zval_type_name(function_name));
3835 call = NULL;
3836 }
3837
3838 if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
3839
3840 if (UNEXPECTED(EG(exception))) {
3841 if (call) {
3842 if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
3843 zend_string_release_ex(call->func->common.function_name, 0);
3844 zend_free_trampoline(call->func);
3845 }
3846 zend_vm_stack_free_call_frame(call);
3847 }
3848 HANDLE_EXCEPTION();
3849 }
3850 } else if (!call) {
3851 HANDLE_EXCEPTION();
3852 }
3853
3854 call->prev_execute_data = EX(call);
3855 EX(call) = call;
3856
3857 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
3858 }
3859
ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3860 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3861 {
3862 USE_OPLINE
3863 zval *func_name;
3864 zval *func;
3865 zend_function *fbc;
3866 zend_execute_data *call;
3867
3868 fbc = CACHED_PTR(opline->result.num);
3869 if (UNEXPECTED(fbc == NULL)) {
3870 func_name = (zval *)RT_CONSTANT(opline, opline->op2);
3871 func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name + 1));
3872 if (func == NULL) {
3873 func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name + 2));
3874 if (UNEXPECTED(func == NULL)) {
3875 ZEND_VM_TAIL_CALL(zend_undefined_function_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
3876 }
3877 }
3878 fbc = Z_FUNC_P(func);
3879 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3880 init_func_run_time_cache(&fbc->op_array);
3881 }
3882 CACHE_PTR(opline->result.num, fbc);
3883 }
3884
3885 call = _zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION,
3886 fbc, opline->extended_value, NULL);
3887 call->prev_execute_data = EX(call);
3888 EX(call) = call;
3889
3890 ZEND_VM_NEXT_OPCODE();
3891 }
3892
ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3893 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3894 {
3895 USE_OPLINE
3896 zval *fname;
3897 zval *func;
3898 zend_function *fbc;
3899 zend_execute_data *call;
3900
3901 fbc = CACHED_PTR(opline->result.num);
3902 if (UNEXPECTED(fbc == NULL)) {
3903 fname = (zval*)RT_CONSTANT(opline, opline->op2);
3904 func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(fname));
3905 ZEND_ASSERT(func != NULL && "Function existence must be checked at compile time");
3906 fbc = Z_FUNC_P(func);
3907 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
3908 init_func_run_time_cache(&fbc->op_array);
3909 }
3910 CACHE_PTR(opline->result.num, fbc);
3911 }
3912
3913 call = _zend_vm_stack_push_call_frame_ex(
3914 opline->op1.num, ZEND_CALL_NESTED_FUNCTION,
3915 fbc, opline->extended_value, NULL);
3916 call->prev_execute_data = EX(call);
3917 EX(call) = call;
3918
3919 ZEND_VM_NEXT_OPCODE();
3920 }
3921
ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3922 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3923 {
3924 USE_OPLINE
3925 uint32_t arg_num;
3926 zval *param;
3927
3928 ZEND_VM_REPEATABLE_OPCODE
3929
3930 arg_num = opline->op1.num;
3931 param = EX_VAR(opline->result.var);
3932 if (arg_num > EX_NUM_ARGS()) {
3933 zval *default_value = RT_CONSTANT(opline, opline->op2);
3934
3935 if (Z_OPT_TYPE_P(default_value) == IS_CONSTANT_AST) {
3936 zval *cache_val = (zval*)CACHE_ADDR(Z_CACHE_SLOT_P(default_value));
3937
3938 /* we keep in cache only not refcounted values */
3939 if (Z_TYPE_P(cache_val) != IS_UNDEF) {
3940 ZVAL_COPY_VALUE(param, cache_val);
3941 } else {
3942 SAVE_OPLINE();
3943 ZVAL_COPY(param, default_value);
3944 zend_ast_evaluate_ctx ctx = {0};
3945 if (UNEXPECTED(zval_update_constant_with_ctx(param, EX(func)->op_array.scope, &ctx) != SUCCESS)) {
3946 zval_ptr_dtor_nogc(param);
3947 ZVAL_UNDEF(param);
3948 HANDLE_EXCEPTION();
3949 }
3950 if (!Z_REFCOUNTED_P(param) && !ctx.had_side_effects) {
3951 ZVAL_COPY_VALUE(cache_val, param);
3952 }
3953 }
3954 goto recv_init_check_type;
3955 } else {
3956 ZVAL_COPY(param, default_value);
3957 }
3958 } else {
3959 recv_init_check_type:
3960 if ((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0) {
3961 SAVE_OPLINE();
3962 if (UNEXPECTED(!zend_verify_recv_arg_type(EX(func), arg_num, param, CACHE_ADDR(opline->extended_value)))) {
3963 HANDLE_EXCEPTION();
3964 }
3965 }
3966 }
3967
3968 ZEND_VM_REPEAT_OPCODE(ZEND_RECV_INIT);
3969 ZEND_VM_NEXT_OPCODE();
3970 }
3971
ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)3972 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
3973 {
3974 USE_OPLINE
3975 zval *function_name;
3976 zend_execute_data *call;
3977
3978 SAVE_OPLINE();
3979 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
3980
3981 try_function_name:
3982 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
3983 call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
3984 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
3985 call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
3986 } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
3987 call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
3988 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
3989 function_name = Z_REFVAL_P(function_name);
3990 goto try_function_name;
3991 } else {
3992 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
3993 function_name = ZVAL_UNDEFINED_OP2();
3994 if (UNEXPECTED(EG(exception) != NULL)) {
3995 HANDLE_EXCEPTION();
3996 }
3997 }
3998 zend_throw_error(NULL, "Value of type %s is not callable",
3999 zend_zval_type_name(function_name));
4000 call = NULL;
4001 }
4002
4003 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) {
4004 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
4005 if (UNEXPECTED(EG(exception))) {
4006 if (call) {
4007 if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4008 zend_string_release_ex(call->func->common.function_name, 0);
4009 zend_free_trampoline(call->func);
4010 }
4011 zend_vm_stack_free_call_frame(call);
4012 }
4013 HANDLE_EXCEPTION();
4014 }
4015 } else if (!call) {
4016 HANDLE_EXCEPTION();
4017 }
4018
4019 call->prev_execute_data = EX(call);
4020 EX(call) = call;
4021
4022 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4023 }
4024
ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4025 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4026 {
4027 USE_OPLINE
4028 uint32_t arg_num = opline->op1.num;
4029 zval *param;
4030
4031 if (UNEXPECTED(arg_num > EX_NUM_ARGS())) {
4032 ZEND_VM_TAIL_CALL(zend_missing_arg_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4033 }
4034
4035 param = EX_VAR(opline->result.var);
4036
4037 if (UNEXPECTED(!(opline->op2.num & (1u << Z_TYPE_P(param))))) {
4038 ZEND_VM_TAIL_CALL(zend_verify_recv_arg_type_helper_SPEC(param ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
4039 }
4040
4041 ZEND_VM_NEXT_OPCODE();
4042 }
4043
ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4044 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4045 {
4046 USE_OPLINE
4047 uint32_t arg_num = opline->op1.num;
4048 uint32_t arg_count = EX_NUM_ARGS();
4049 zval *params;
4050
4051 SAVE_OPLINE();
4052
4053 params = EX_VAR(opline->result.var);
4054
4055 if (arg_num <= arg_count) {
4056 ZEND_ASSERT(EX(func)->common.fn_flags & ZEND_ACC_VARIADIC);
4057 ZEND_ASSERT(EX(func)->common.num_args == arg_num - 1);
4058 zend_arg_info *arg_info = &EX(func)->common.arg_info[arg_num - 1];
4059
4060 array_init_size(params, arg_count - arg_num + 1);
4061 zend_hash_real_init_packed(Z_ARRVAL_P(params));
4062 ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(params)) {
4063 zval *param = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T);
4064 if (ZEND_TYPE_IS_SET(arg_info->type)) {
4065 ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_FREE_EXTRA_ARGS);
4066 do {
4067 if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param, CACHE_ADDR(opline->extended_value)))) {
4068 ZEND_HASH_FILL_FINISH();
4069 HANDLE_EXCEPTION();
4070 }
4071
4072 if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4073 ZEND_HASH_FILL_ADD(param);
4074 param++;
4075 } while (++arg_num <= arg_count);
4076 } else {
4077 do {
4078 if (Z_OPT_REFCOUNTED_P(param)) Z_ADDREF_P(param);
4079 ZEND_HASH_FILL_ADD(param);
4080 param++;
4081 } while (++arg_num <= arg_count);
4082 }
4083 } ZEND_HASH_FILL_END();
4084 } else {
4085 ZVAL_EMPTY_ARRAY(params);
4086 }
4087
4088 if (EX_CALL_INFO() & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
4089 zend_string *name;
4090 zval *param;
4091 zend_arg_info *arg_info = &EX(func)->common.arg_info[EX(func)->common.num_args];
4092 if (ZEND_TYPE_IS_SET(arg_info->type)) {
4093 SEPARATE_ARRAY(params);
4094 ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) {
4095 if (UNEXPECTED(!zend_verify_variadic_arg_type(EX(func), arg_info, arg_num, param, CACHE_ADDR(opline->extended_value)))) {
4096 HANDLE_EXCEPTION();
4097 }
4098 Z_TRY_ADDREF_P(param);
4099 zend_hash_add_new(Z_ARRVAL_P(params), name, param);
4100 } ZEND_HASH_FOREACH_END();
4101 } else if (zend_hash_num_elements(Z_ARRVAL_P(params)) == 0) {
4102 GC_ADDREF(EX(extra_named_params));
4103 ZVAL_ARR(params, EX(extra_named_params));
4104 } else {
4105 SEPARATE_ARRAY(params);
4106 ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(EX(extra_named_params), name, param) {
4107 Z_TRY_ADDREF_P(param);
4108 zend_hash_add_new(Z_ARRVAL_P(params), name, param);
4109 } ZEND_HASH_FOREACH_END();
4110 }
4111 }
4112
4113 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4114 }
4115
ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4116 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4117 {
4118 USE_OPLINE
4119 SAVE_OPLINE();
4120 zend_frameless_function_1 function = (zend_frameless_function_1)ZEND_FLF_HANDLER(opline);
4121 ZVAL_NULL(EX_VAR(opline->result.var));
4122 zval *arg1 = get_zval_ptr_deref(opline->op1_type, opline->op1, BP_VAR_R);
4123 if (EG(exception)) {
4124 FREE_OP(opline->op1_type, opline->op1.var);
4125 HANDLE_EXCEPTION();
4126 }
4127 function(EX_VAR(opline->result.var), arg1);
4128 FREE_OP(opline->op1_type, opline->op1.var);
4129 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4130 }
4131
ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4132 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4133 {
4134 USE_OPLINE
4135 zval *function_name;
4136 zend_execute_data *call;
4137
4138 SAVE_OPLINE();
4139 function_name = EX_VAR(opline->op2.var);
4140
4141 try_function_name:
4142 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
4143 call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value);
4144 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) {
4145 call = zend_init_dynamic_call_object(Z_OBJ_P(function_name), opline->extended_value);
4146 } else if (EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY)) {
4147 call = zend_init_dynamic_call_array(Z_ARRVAL_P(function_name), opline->extended_value);
4148 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) {
4149 function_name = Z_REFVAL_P(function_name);
4150 goto try_function_name;
4151 } else {
4152 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
4153 function_name = ZVAL_UNDEFINED_OP2();
4154 if (UNEXPECTED(EG(exception) != NULL)) {
4155 HANDLE_EXCEPTION();
4156 }
4157 }
4158 zend_throw_error(NULL, "Value of type %s is not callable",
4159 zend_zval_type_name(function_name));
4160 call = NULL;
4161 }
4162
4163 if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
4164
4165 if (UNEXPECTED(EG(exception))) {
4166 if (call) {
4167 if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
4168 zend_string_release_ex(call->func->common.function_name, 0);
4169 zend_free_trampoline(call->func);
4170 }
4171 zend_vm_stack_free_call_frame(call);
4172 }
4173 HANDLE_EXCEPTION();
4174 }
4175 } else if (!call) {
4176 HANDLE_EXCEPTION();
4177 }
4178
4179 call->prev_execute_data = EX(call);
4180 EX(call) = call;
4181
4182 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4183 }
4184
ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4185 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4186 {
4187 USE_OPLINE
4188 zval *op1;
4189
4190 op1 = RT_CONSTANT(opline, opline->op1);
4191 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
4192 ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
4193 ZEND_VM_NEXT_OPCODE();
4194 }
4195
4196 ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(op1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
4197 }
4198
ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4199 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4200 {
4201 USE_OPLINE
4202 zval *val;
4203
4204 val = RT_CONSTANT(opline, opline->op1);
4205 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4206 ZVAL_FALSE(EX_VAR(opline->result.var));
4207 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4208 /* The result and op1 can be the same cv zval */
4209 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
4210 ZVAL_TRUE(EX_VAR(opline->result.var));
4211 if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
4212 SAVE_OPLINE();
4213 ZVAL_UNDEFINED_OP1();
4214 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4215 }
4216 } else {
4217 SAVE_OPLINE();
4218 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
4219
4220 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4221 }
4222 ZEND_VM_NEXT_OPCODE();
4223 }
4224
ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4225 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4226 {
4227 USE_OPLINE
4228 zval *z;
4229
4230 SAVE_OPLINE();
4231 z = RT_CONSTANT(opline, opline->op1);
4232
4233 if (Z_TYPE_P(z) == IS_STRING) {
4234 zend_string *str = Z_STR_P(z);
4235
4236 if (ZSTR_LEN(str) != 0) {
4237 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
4238 }
4239 } else {
4240 zend_string *str = zval_get_string_func(z);
4241
4242 if (ZSTR_LEN(str) != 0) {
4243 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
4244 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
4245 ZVAL_UNDEFINED_OP1();
4246 }
4247 zend_string_release_ex(str, 0);
4248 }
4249
4250 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4251 }
4252
ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4253 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4254 {
4255 USE_OPLINE
4256 zval *val;
4257 uint8_t op1_type;
4258
4259 val = RT_CONSTANT(opline, opline->op1);
4260
4261 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4262 ZEND_VM_NEXT_OPCODE();
4263 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4264 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4265 SAVE_OPLINE();
4266 ZVAL_UNDEFINED_OP1();
4267 if (UNEXPECTED(EG(exception))) {
4268 HANDLE_EXCEPTION();
4269 }
4270 }
4271 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4272 }
4273
4274 SAVE_OPLINE();
4275 op1_type = IS_CONST;
4276 if (i_zend_is_true(val)) {
4277 opline++;
4278 } else {
4279 opline = OP_JMP_ADDR(opline, opline->op2);
4280 }
4281 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
4282 zval_ptr_dtor_nogc(val);
4283 }
4284 ZEND_VM_JMP(opline);
4285 }
4286
ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4287 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4288 {
4289 USE_OPLINE
4290 zval *val;
4291 uint8_t op1_type;
4292
4293 val = RT_CONSTANT(opline, opline->op1);
4294
4295 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4296 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4297 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4298 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4299 SAVE_OPLINE();
4300 ZVAL_UNDEFINED_OP1();
4301 if (UNEXPECTED(EG(exception))) {
4302 HANDLE_EXCEPTION();
4303 }
4304 }
4305 ZEND_VM_NEXT_OPCODE();
4306 }
4307
4308 SAVE_OPLINE();
4309 op1_type = IS_CONST;
4310 if (i_zend_is_true(val)) {
4311 opline = OP_JMP_ADDR(opline, opline->op2);
4312 } else {
4313 opline++;
4314 }
4315 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
4316 zval_ptr_dtor_nogc(val);
4317 }
4318 ZEND_VM_JMP(opline);
4319 }
4320
ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4321 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4322 {
4323 USE_OPLINE
4324 zval *val;
4325 bool ret;
4326
4327 val = RT_CONSTANT(opline, opline->op1);
4328
4329 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4330 ZVAL_TRUE(EX_VAR(opline->result.var));
4331 ZEND_VM_NEXT_OPCODE();
4332 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4333 ZVAL_FALSE(EX_VAR(opline->result.var));
4334 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4335 SAVE_OPLINE();
4336 ZVAL_UNDEFINED_OP1();
4337 if (UNEXPECTED(EG(exception))) {
4338 HANDLE_EXCEPTION();
4339 }
4340 }
4341 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4342 }
4343
4344 SAVE_OPLINE();
4345 ret = i_zend_is_true(val);
4346
4347 if (ret) {
4348 ZVAL_TRUE(EX_VAR(opline->result.var));
4349 opline++;
4350 } else {
4351 ZVAL_FALSE(EX_VAR(opline->result.var));
4352 opline = OP_JMP_ADDR(opline, opline->op2);
4353 }
4354 ZEND_VM_JMP(opline);
4355 }
4356
ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4357 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4358 {
4359 USE_OPLINE
4360 zval *val;
4361 bool ret;
4362
4363 val = RT_CONSTANT(opline, opline->op1);
4364
4365 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4366 ZVAL_TRUE(EX_VAR(opline->result.var));
4367 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4368 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4369 ZVAL_FALSE(EX_VAR(opline->result.var));
4370 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
4371 SAVE_OPLINE();
4372 ZVAL_UNDEFINED_OP1();
4373 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4374 } else {
4375 ZEND_VM_NEXT_OPCODE();
4376 }
4377 }
4378
4379 SAVE_OPLINE();
4380 ret = i_zend_is_true(val);
4381
4382 if (ret) {
4383 ZVAL_TRUE(EX_VAR(opline->result.var));
4384 opline = OP_JMP_ADDR(opline, opline->op2);
4385 } else {
4386 ZVAL_FALSE(EX_VAR(opline->result.var));
4387 opline++;
4388 }
4389 ZEND_VM_JMP(opline);
4390 }
4391
ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4392 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4393 {
4394 USE_OPLINE
4395 zval *retval_ptr;
4396 zval *return_value;
4397
4398 retval_ptr = RT_CONSTANT(opline, opline->op1);
4399 return_value = EX(return_value);
4400
4401 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
4402 SAVE_OPLINE();
4403 retval_ptr = ZVAL_UNDEFINED_OP1();
4404 if (return_value) {
4405 ZVAL_NULL(return_value);
4406 }
4407 } else if (!return_value) {
4408 if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
4409 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
4410 SAVE_OPLINE();
4411 rc_dtor_func(Z_COUNTED_P(retval_ptr));
4412 }
4413 }
4414 } else {
4415 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
4416 ZVAL_COPY_VALUE(return_value, retval_ptr);
4417 if (IS_CONST == IS_CONST) {
4418 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
4419 Z_ADDREF_P(return_value);
4420 }
4421 }
4422 } else if (IS_CONST == IS_CV) {
4423 do {
4424 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4425 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
4426 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
4427 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4428 ZVAL_COPY_VALUE(return_value, retval_ptr);
4429 if (GC_MAY_LEAK(ref)) {
4430 SAVE_OPLINE();
4431 gc_possible_root(ref);
4432 }
4433 ZVAL_NULL(retval_ptr);
4434 break;
4435 } else {
4436 Z_ADDREF_P(retval_ptr);
4437 }
4438 } else {
4439 retval_ptr = Z_REFVAL_P(retval_ptr);
4440 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4441 Z_ADDREF_P(retval_ptr);
4442 }
4443 }
4444 }
4445 ZVAL_COPY_VALUE(return_value, retval_ptr);
4446 } while (0);
4447 } else /* if (IS_CONST == IS_VAR) */ {
4448 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4449 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4450
4451 retval_ptr = Z_REFVAL_P(retval_ptr);
4452 ZVAL_COPY_VALUE(return_value, retval_ptr);
4453 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4454 efree_size(ref, sizeof(zend_reference));
4455 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4456 Z_ADDREF_P(retval_ptr);
4457 }
4458 } else {
4459 ZVAL_COPY_VALUE(return_value, retval_ptr);
4460 }
4461 }
4462 }
4463
4464
4465
4466 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4467 }
4468
ZEND_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4469 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4470 {
4471 USE_OPLINE
4472 zval *retval_ptr;
4473 zval *return_value;
4474 zval observer_retval;
4475
4476 retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
4477 return_value = EX(return_value);
4478 if (!return_value) { return_value = &observer_retval; };
4479 if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
4480 SAVE_OPLINE();
4481 retval_ptr = ZVAL_UNDEFINED_OP1();
4482 if (return_value) {
4483 ZVAL_NULL(return_value);
4484 }
4485 } else if (!return_value) {
4486 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
4487 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
4488 SAVE_OPLINE();
4489 rc_dtor_func(Z_COUNTED_P(retval_ptr));
4490 }
4491 }
4492 } else {
4493 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
4494 ZVAL_COPY_VALUE(return_value, retval_ptr);
4495 if (opline->op1_type == IS_CONST) {
4496 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
4497 Z_ADDREF_P(return_value);
4498 }
4499 }
4500 } else if (opline->op1_type == IS_CV) {
4501 do {
4502 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4503 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
4504 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
4505 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4506 ZVAL_COPY_VALUE(return_value, retval_ptr);
4507 if (GC_MAY_LEAK(ref)) {
4508 SAVE_OPLINE();
4509 gc_possible_root(ref);
4510 }
4511 ZVAL_NULL(retval_ptr);
4512 break;
4513 } else {
4514 Z_ADDREF_P(retval_ptr);
4515 }
4516 } else {
4517 retval_ptr = Z_REFVAL_P(retval_ptr);
4518 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4519 Z_ADDREF_P(retval_ptr);
4520 }
4521 }
4522 }
4523 ZVAL_COPY_VALUE(return_value, retval_ptr);
4524 } while (0);
4525 } else /* if (opline->op1_type == IS_VAR) */ {
4526 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4527 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
4528
4529 retval_ptr = Z_REFVAL_P(retval_ptr);
4530 ZVAL_COPY_VALUE(return_value, retval_ptr);
4531 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4532 efree_size(ref, sizeof(zend_reference));
4533 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
4534 Z_ADDREF_P(retval_ptr);
4535 }
4536 } else {
4537 ZVAL_COPY_VALUE(return_value, retval_ptr);
4538 }
4539 }
4540 }
4541 SAVE_OPLINE();
4542 zend_observer_fcall_end(execute_data, return_value);
4543 if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
4544 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4545 }
4546
ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4547 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4548 {
4549 USE_OPLINE
4550 zval *retval_ptr;
4551 zval *return_value;
4552
4553 SAVE_OPLINE();
4554
4555 return_value = EX(return_value);
4556
4557 do {
4558 if ((IS_CONST & (IS_CONST|IS_TMP_VAR)) ||
4559 (IS_CONST == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
4560 /* Not supposed to happen, but we'll allow it */
4561 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4562
4563 retval_ptr = RT_CONSTANT(opline, opline->op1);
4564 if (!return_value) {
4565
4566 } else {
4567 if (IS_CONST == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4568 ZVAL_COPY_VALUE(return_value, retval_ptr);
4569 break;
4570 }
4571
4572 ZVAL_NEW_REF(return_value, retval_ptr);
4573 if (IS_CONST == IS_CONST) {
4574 Z_TRY_ADDREF_P(retval_ptr);
4575 }
4576 }
4577 break;
4578 }
4579
4580 retval_ptr = zend_get_bad_ptr();
4581
4582 if (IS_CONST == IS_VAR) {
4583 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
4584 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
4585 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4586 if (return_value) {
4587 ZVAL_NEW_REF(return_value, retval_ptr);
4588 } else {
4589
4590 }
4591 break;
4592 }
4593 }
4594
4595 if (return_value) {
4596 if (Z_ISREF_P(retval_ptr)) {
4597 Z_ADDREF_P(retval_ptr);
4598 } else {
4599 ZVAL_MAKE_REF_EX(retval_ptr, 2);
4600 }
4601 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
4602 }
4603
4604 } while (0);
4605
4606
4607 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4608 }
4609
ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4610 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4611 {
4612 USE_OPLINE
4613 zval *retval_ptr;
4614 zval *return_value;
4615 zval observer_retval;
4616
4617 SAVE_OPLINE();
4618
4619 return_value = EX(return_value);
4620 if (!return_value) { return_value = &observer_retval; };
4621 do {
4622 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR)) ||
4623 (opline->op1_type == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
4624 /* Not supposed to happen, but we'll allow it */
4625 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4626
4627 retval_ptr = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
4628 if (!return_value) {
4629 FREE_OP(opline->op1_type, opline->op1.var);
4630 } else {
4631 if (opline->op1_type == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
4632 ZVAL_COPY_VALUE(return_value, retval_ptr);
4633 break;
4634 }
4635
4636 ZVAL_NEW_REF(return_value, retval_ptr);
4637 if (opline->op1_type == IS_CONST) {
4638 Z_TRY_ADDREF_P(retval_ptr);
4639 }
4640 }
4641 break;
4642 }
4643
4644 retval_ptr = get_zval_ptr_ptr(opline->op1_type, opline->op1, BP_VAR_W);
4645
4646 if (opline->op1_type == IS_VAR) {
4647 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
4648 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
4649 zend_error(E_NOTICE, "Only variable references should be returned by reference");
4650 if (return_value) {
4651 ZVAL_NEW_REF(return_value, retval_ptr);
4652 } else {
4653 FREE_OP(opline->op1_type, opline->op1.var);
4654 }
4655 break;
4656 }
4657 }
4658
4659 if (return_value) {
4660 if (Z_ISREF_P(retval_ptr)) {
4661 Z_ADDREF_P(retval_ptr);
4662 } else {
4663 ZVAL_MAKE_REF_EX(retval_ptr, 2);
4664 }
4665 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
4666 }
4667
4668 FREE_OP(opline->op1_type, opline->op1.var);
4669 } while (0);
4670
4671 zend_observer_fcall_end(execute_data, return_value);
4672 if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
4673 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
4674 }
4675
ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4676 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4677 {
4678 USE_OPLINE
4679 zval *retval;
4680
4681 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
4682
4683 SAVE_OPLINE();
4684 retval = RT_CONSTANT(opline, opline->op1);
4685
4686 /* Copy return value into generator->retval */
4687 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
4688 ZVAL_COPY_VALUE(&generator->retval, retval);
4689 if (IS_CONST == IS_CONST) {
4690 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
4691 Z_ADDREF(generator->retval);
4692 }
4693 }
4694 } else if (IS_CONST == IS_CV) {
4695 ZVAL_COPY_DEREF(&generator->retval, retval);
4696 } else /* if (IS_CONST == IS_VAR) */ {
4697 if (UNEXPECTED(Z_ISREF_P(retval))) {
4698 zend_refcounted *ref = Z_COUNTED_P(retval);
4699
4700 retval = Z_REFVAL_P(retval);
4701 ZVAL_COPY_VALUE(&generator->retval, retval);
4702 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4703 efree_size(ref, sizeof(zend_reference));
4704 } else if (Z_OPT_REFCOUNTED_P(retval)) {
4705 Z_ADDREF_P(retval);
4706 }
4707 } else {
4708 ZVAL_COPY_VALUE(&generator->retval, retval);
4709 }
4710 }
4711
4712 EG(current_execute_data) = EX(prev_execute_data);
4713
4714 /* Close the generator to free up resources */
4715 zend_generator_close(generator, 1);
4716
4717 /* Pass execution back to handling code */
4718 ZEND_VM_RETURN();
4719 }
4720
ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4721 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4722 {
4723 USE_OPLINE
4724 zval *retval;
4725
4726 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
4727
4728 SAVE_OPLINE();
4729 retval = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
4730
4731 /* Copy return value into generator->retval */
4732 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
4733 ZVAL_COPY_VALUE(&generator->retval, retval);
4734 if (opline->op1_type == IS_CONST) {
4735 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
4736 Z_ADDREF(generator->retval);
4737 }
4738 }
4739 } else if (opline->op1_type == IS_CV) {
4740 ZVAL_COPY_DEREF(&generator->retval, retval);
4741 } else /* if (opline->op1_type == IS_VAR) */ {
4742 if (UNEXPECTED(Z_ISREF_P(retval))) {
4743 zend_refcounted *ref = Z_COUNTED_P(retval);
4744
4745 retval = Z_REFVAL_P(retval);
4746 ZVAL_COPY_VALUE(&generator->retval, retval);
4747 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
4748 efree_size(ref, sizeof(zend_reference));
4749 } else if (Z_OPT_REFCOUNTED_P(retval)) {
4750 Z_ADDREF_P(retval);
4751 }
4752 } else {
4753 ZVAL_COPY_VALUE(&generator->retval, retval);
4754 }
4755 }
4756
4757 zend_observer_fcall_end(generator->execute_data, &generator->retval);
4758
4759 EG(current_execute_data) = EX(prev_execute_data);
4760
4761 /* Close the generator to free up resources */
4762 zend_generator_close(generator, 1);
4763
4764 /* Pass execution back to handling code */
4765 ZEND_VM_RETURN();
4766 }
4767
ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4768 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4769 {
4770 USE_OPLINE
4771 zval *value;
4772
4773 SAVE_OPLINE();
4774 value = RT_CONSTANT(opline, opline->op1);
4775
4776 do {
4777 if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
4778 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
4779 value = Z_REFVAL_P(value);
4780 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
4781 break;
4782 }
4783 }
4784 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
4785 ZVAL_UNDEFINED_OP1();
4786 if (UNEXPECTED(EG(exception) != NULL)) {
4787 HANDLE_EXCEPTION();
4788 }
4789 }
4790 zend_throw_error(NULL, "Can only throw objects");
4791
4792 HANDLE_EXCEPTION();
4793 }
4794 } while (0);
4795
4796 zend_exception_save();
4797 Z_TRY_ADDREF_P(value);
4798 zend_throw_exception_object(value);
4799 zend_exception_restore();
4800
4801 HANDLE_EXCEPTION();
4802 }
4803
ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4804 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4805 {
4806 USE_OPLINE
4807 zend_class_entry *ce, *catch_ce;
4808 zend_object *exception;
4809
4810 SAVE_OPLINE();
4811 /* Check whether an exception has been thrown, if not, jump over code */
4812 zend_exception_restore();
4813 if (EG(exception) == NULL) {
4814 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4815 }
4816 catch_ce = CACHED_PTR(opline->extended_value & ~ZEND_LAST_CATCH);
4817 if (UNEXPECTED(catch_ce == NULL)) {
4818 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);
4819
4820 CACHE_PTR(opline->extended_value & ~ZEND_LAST_CATCH, catch_ce);
4821 }
4822 ce = EG(exception)->ce;
4823
4824 #ifdef HAVE_DTRACE
4825 if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
4826 DTRACE_EXCEPTION_CAUGHT((char *)ce->name);
4827 }
4828 #endif /* HAVE_DTRACE */
4829
4830 if (ce != catch_ce) {
4831 if (!catch_ce || !instanceof_function(ce, catch_ce)) {
4832 if (opline->extended_value & ZEND_LAST_CATCH) {
4833 zend_rethrow_exception(execute_data);
4834 HANDLE_EXCEPTION();
4835 }
4836 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
4837 }
4838 }
4839
4840 exception = EG(exception);
4841 EG(exception) = NULL;
4842 if (RETURN_VALUE_USED(opline)) {
4843 /* Always perform a strict assignment. There is a reasonable expectation that if you
4844 * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such,
4845 * we should not permit coercion to string here. */
4846 zval tmp;
4847 ZVAL_OBJ(&tmp, exception);
4848 zend_assign_to_variable(EX_VAR(opline->result.var), &tmp, IS_TMP_VAR, /* strict */ 1);
4849 } else {
4850 OBJ_RELEASE(exception);
4851 }
4852 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4853 }
4854
ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4855 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4856 {
4857 USE_OPLINE
4858 zval *arg, *param;
4859
4860 SAVE_OPLINE();
4861
4862 arg = RT_CONSTANT(opline, opline->op1);
4863 param = ZEND_CALL_VAR(EX(call), opline->result.var);
4864 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
4865 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
4866 Z_TRY_ADDREF_P(arg);
4867 ZVAL_NEW_REF(param, arg);
4868 } else {
4869 ZVAL_COPY(param, arg);
4870 }
4871
4872 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4873 }
4874
ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4875 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4876 {
4877 USE_OPLINE
4878 zval *val;
4879
4880 val = RT_CONSTANT(opline, opline->op1);
4881 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
4882 ZVAL_TRUE(EX_VAR(opline->result.var));
4883 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
4884 /* The result and op1 can be the same cv zval */
4885 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
4886 ZVAL_FALSE(EX_VAR(opline->result.var));
4887 if (IS_CONST == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
4888 SAVE_OPLINE();
4889 ZVAL_UNDEFINED_OP1();
4890 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4891 }
4892 } else {
4893 SAVE_OPLINE();
4894 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
4895
4896 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4897 }
4898 ZEND_VM_NEXT_OPCODE();
4899 }
4900
ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4901 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4902 {
4903 USE_OPLINE
4904 zval *obj;
4905 zend_object *zobj;
4906 zend_class_entry *ce, *scope;
4907 zend_function *clone;
4908 zend_object_clone_obj_t clone_call;
4909
4910 SAVE_OPLINE();
4911 obj = RT_CONSTANT(opline, opline->op1);
4912
4913 do {
4914 if (IS_CONST == IS_CONST ||
4915 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
4916 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
4917 obj = Z_REFVAL_P(obj);
4918 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
4919 break;
4920 }
4921 }
4922 ZVAL_UNDEF(EX_VAR(opline->result.var));
4923 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
4924 ZVAL_UNDEFINED_OP1();
4925 if (UNEXPECTED(EG(exception) != NULL)) {
4926 HANDLE_EXCEPTION();
4927 }
4928 }
4929 zend_throw_error(NULL, "__clone method called on non-object");
4930
4931 HANDLE_EXCEPTION();
4932 }
4933 } while (0);
4934
4935 zobj = Z_OBJ_P(obj);
4936 ce = zobj->ce;
4937 clone = ce->clone;
4938 clone_call = zobj->handlers->clone_obj;
4939 if (UNEXPECTED(clone_call == NULL)) {
4940 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
4941
4942 ZVAL_UNDEF(EX_VAR(opline->result.var));
4943 HANDLE_EXCEPTION();
4944 }
4945
4946 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
4947 scope = EX(func)->op_array.scope;
4948 if (clone->common.scope != scope) {
4949 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
4950 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
4951 zend_wrong_clone_call(clone, scope);
4952
4953 ZVAL_UNDEF(EX_VAR(opline->result.var));
4954 HANDLE_EXCEPTION();
4955 }
4956 }
4957 }
4958
4959 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
4960
4961 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4962 }
4963
ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)4964 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
4965 {
4966 USE_OPLINE
4967 zval *expr;
4968 zval *result = EX_VAR(opline->result.var);
4969 HashTable *ht;
4970
4971 SAVE_OPLINE();
4972 expr = RT_CONSTANT(opline, opline->op1);
4973
4974 switch (opline->extended_value) {
4975 case IS_LONG:
4976 ZVAL_LONG(result, zval_get_long(expr));
4977 break;
4978 case IS_DOUBLE:
4979 ZVAL_DOUBLE(result, zval_get_double(expr));
4980 break;
4981 case IS_STRING:
4982 ZVAL_STR(result, zval_get_string(expr));
4983 break;
4984 default:
4985 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
4986 if (IS_CONST & (IS_VAR|IS_CV)) {
4987 ZVAL_DEREF(expr);
4988 }
4989 /* If value is already of correct type, return it directly */
4990 if (Z_TYPE_P(expr) == opline->extended_value) {
4991 ZVAL_COPY_VALUE(result, expr);
4992 if (IS_CONST == IS_CONST) {
4993 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
4994 } else if (IS_CONST != IS_TMP_VAR) {
4995 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
4996 }
4997
4998 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
4999 }
5000
5001 if (opline->extended_value == IS_ARRAY) {
5002 if (IS_CONST == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
5003 if (Z_TYPE_P(expr) != IS_NULL) {
5004 ZVAL_ARR(result, zend_new_array(1));
5005 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
5006 if (IS_CONST == IS_CONST) {
5007 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
5008 } else {
5009 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
5010 }
5011 } else {
5012 ZVAL_EMPTY_ARRAY(result);
5013 }
5014 } else if (Z_OBJ_P(expr)->properties == NULL
5015 && Z_OBJ_HT_P(expr)->get_properties_for == NULL
5016 && Z_OBJ_HT_P(expr)->get_properties == zend_std_get_properties) {
5017 /* Optimized version without rebuilding properties HashTable */
5018 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
5019 } else {
5020 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
5021 if (obj_ht) {
5022 /* fast copy */
5023 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
5024 (Z_OBJCE_P(expr)->default_properties_count ||
5025 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
5026 GC_IS_RECURSIVE(obj_ht))));
5027 zend_release_properties(obj_ht);
5028 } else {
5029 ZVAL_EMPTY_ARRAY(result);
5030 }
5031 }
5032 } else {
5033 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
5034 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
5035 if (Z_TYPE_P(expr) == IS_ARRAY) {
5036 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
5037 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
5038 /* TODO: try not to duplicate immutable arrays as well ??? */
5039 ht = zend_array_dup(ht);
5040 }
5041 Z_OBJ_P(result)->properties = ht;
5042 } else if (Z_TYPE_P(expr) != IS_NULL) {
5043 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
5044 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
5045 if (IS_CONST == IS_CONST) {
5046 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
5047 } else {
5048 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
5049 }
5050 }
5051 }
5052 }
5053
5054 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5055 }
5056
ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5057 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5058 {
5059 USE_OPLINE
5060 zend_op_array *new_op_array;
5061 zval *inc_filename;
5062
5063 SAVE_OPLINE();
5064 inc_filename = RT_CONSTANT(opline, opline->op1);
5065 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
5066 if (UNEXPECTED(EG(exception) != NULL)) {
5067
5068 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
5069 destroy_op_array(new_op_array);
5070 efree_size(new_op_array, sizeof(zend_op_array));
5071 }
5072 UNDEF_RESULT();
5073 HANDLE_EXCEPTION();
5074 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
5075 if (RETURN_VALUE_USED(opline)) {
5076 ZVAL_TRUE(EX_VAR(opline->result.var));
5077 }
5078 } else if (UNEXPECTED(new_op_array == NULL)) {
5079 if (RETURN_VALUE_USED(opline)) {
5080 ZVAL_FALSE(EX_VAR(opline->result.var));
5081 }
5082 } else if (new_op_array->last == 1
5083 && new_op_array->opcodes[0].opcode == ZEND_RETURN
5084 && new_op_array->opcodes[0].op1_type == IS_CONST
5085 && EXPECTED(zend_execute_ex == execute_ex)) {
5086 if (RETURN_VALUE_USED(opline)) {
5087 const zend_op *op = new_op_array->opcodes;
5088
5089 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
5090 }
5091 zend_destroy_static_vars(new_op_array);
5092 destroy_op_array(new_op_array);
5093 efree_size(new_op_array, sizeof(zend_op_array));
5094 } else {
5095 zval *return_value = NULL;
5096 zend_execute_data *call;
5097 if (RETURN_VALUE_USED(opline)) {
5098 return_value = EX_VAR(opline->result.var);
5099 }
5100
5101 new_op_array->scope = EX(func)->op_array.scope;
5102
5103 call = zend_vm_stack_push_call_frame(
5104 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
5105 (zend_function*)new_op_array, 0,
5106 Z_PTR(EX(This)));
5107
5108 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
5109 call->symbol_table = EX(symbol_table);
5110 } else {
5111 call->symbol_table = zend_rebuild_symbol_table();
5112 }
5113
5114 call->prev_execute_data = execute_data;
5115 i_init_code_execute_data(call, new_op_array, return_value);
5116
5117 if (EXPECTED(zend_execute_ex == execute_ex)) {
5118
5119 ZEND_VM_ENTER();
5120 } else {
5121 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
5122 zend_execute_ex(call);
5123 zend_vm_stack_free_call_frame(call);
5124 }
5125
5126 zend_destroy_static_vars(new_op_array);
5127 destroy_op_array(new_op_array);
5128 efree_size(new_op_array, sizeof(zend_op_array));
5129 if (UNEXPECTED(EG(exception) != NULL)) {
5130 zend_rethrow_exception(execute_data);
5131
5132 UNDEF_RESULT();
5133 HANDLE_EXCEPTION();
5134 }
5135 }
5136
5137 ZEND_VM_NEXT_OPCODE();
5138 }
5139
ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5140 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5141 {
5142 USE_OPLINE
5143 zend_op_array *new_op_array;
5144 zval *inc_filename;
5145
5146 SAVE_OPLINE();
5147 inc_filename = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
5148 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
5149 if (UNEXPECTED(EG(exception) != NULL)) {
5150 FREE_OP(opline->op1_type, opline->op1.var);
5151 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
5152 destroy_op_array(new_op_array);
5153 efree_size(new_op_array, sizeof(zend_op_array));
5154 }
5155 UNDEF_RESULT();
5156 HANDLE_EXCEPTION();
5157 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
5158 if (RETURN_VALUE_USED(opline)) {
5159 ZVAL_TRUE(EX_VAR(opline->result.var));
5160 }
5161 } else if (UNEXPECTED(new_op_array == NULL)) {
5162 if (RETURN_VALUE_USED(opline)) {
5163 ZVAL_FALSE(EX_VAR(opline->result.var));
5164 }
5165 } else if (new_op_array->last == 1
5166 && new_op_array->opcodes[0].opcode == ZEND_RETURN
5167 && new_op_array->opcodes[0].op1_type == IS_CONST
5168 && EXPECTED(zend_execute_ex == execute_ex)) {
5169 if (RETURN_VALUE_USED(opline)) {
5170 const zend_op *op = new_op_array->opcodes;
5171
5172 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
5173 }
5174 zend_destroy_static_vars(new_op_array);
5175 destroy_op_array(new_op_array);
5176 efree_size(new_op_array, sizeof(zend_op_array));
5177 } else {
5178 zval *return_value = NULL;
5179 zend_execute_data *call;
5180 if (RETURN_VALUE_USED(opline)) {
5181 return_value = EX_VAR(opline->result.var);
5182 }
5183
5184 new_op_array->scope = EX(func)->op_array.scope;
5185
5186 call = zend_vm_stack_push_call_frame(
5187 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
5188 (zend_function*)new_op_array, 0,
5189 Z_PTR(EX(This)));
5190
5191 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
5192 call->symbol_table = EX(symbol_table);
5193 } else {
5194 call->symbol_table = zend_rebuild_symbol_table();
5195 }
5196
5197 call->prev_execute_data = execute_data;
5198 i_init_code_execute_data(call, new_op_array, return_value);
5199 zend_observer_fcall_begin(call);
5200 if (EXPECTED(zend_execute_ex == execute_ex)) {
5201 FREE_OP(opline->op1_type, opline->op1.var);
5202 ZEND_VM_ENTER();
5203 } else {
5204 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
5205 zend_execute_ex(call);
5206 zend_vm_stack_free_call_frame(call);
5207 }
5208
5209 zend_destroy_static_vars(new_op_array);
5210 destroy_op_array(new_op_array);
5211 efree_size(new_op_array, sizeof(zend_op_array));
5212 if (UNEXPECTED(EG(exception) != NULL)) {
5213 zend_rethrow_exception(execute_data);
5214 FREE_OP(opline->op1_type, opline->op1.var);
5215 UNDEF_RESULT();
5216 HANDLE_EXCEPTION();
5217 }
5218 }
5219 FREE_OP(opline->op1_type, opline->op1.var);
5220 ZEND_VM_NEXT_OPCODE();
5221 }
5222
ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5223 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5224 {
5225 USE_OPLINE
5226 zval *array_ptr, *result;
5227
5228 SAVE_OPLINE();
5229
5230 array_ptr = RT_CONSTANT(opline, opline->op1);
5231 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5232 result = EX_VAR(opline->result.var);
5233 ZVAL_COPY_VALUE(result, array_ptr);
5234 if (IS_CONST != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
5235 Z_ADDREF_P(array_ptr);
5236 }
5237 Z_FE_POS_P(result) = 0;
5238
5239 ZEND_VM_NEXT_OPCODE();
5240 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5241 zend_object *zobj = Z_OBJ_P(array_ptr);
5242 if (!zobj->ce->get_iterator) {
5243 HashTable *properties = zobj->properties;
5244 if (properties) {
5245 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
5246 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
5247 GC_DELREF(properties);
5248 }
5249 properties = zobj->properties = zend_array_dup(properties);
5250 }
5251 } else {
5252 properties = zobj->handlers->get_properties(zobj);
5253 }
5254
5255 result = EX_VAR(opline->result.var);
5256 ZVAL_COPY_VALUE(result, array_ptr);
5257 if (IS_CONST != IS_TMP_VAR) {
5258 Z_ADDREF_P(array_ptr);
5259 }
5260
5261 if (zend_hash_num_elements(properties) == 0) {
5262 Z_FE_ITER_P(result) = (uint32_t) -1;
5263
5264 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5265 }
5266
5267 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
5268
5269 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5270 } else {
5271 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
5272
5273 if (UNEXPECTED(EG(exception))) {
5274 HANDLE_EXCEPTION();
5275 } else if (is_empty) {
5276 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5277 } else {
5278 ZEND_VM_NEXT_OPCODE();
5279 }
5280 }
5281 } else {
5282 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
5283 ZVAL_UNDEF(EX_VAR(opline->result.var));
5284 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5285
5286 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5287 }
5288 }
5289
ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5290 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5291 {
5292 USE_OPLINE
5293 zval *array_ptr, *array_ref;
5294
5295 SAVE_OPLINE();
5296
5297 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5298 array_ref = array_ptr = zend_get_bad_ptr();
5299 if (Z_ISREF_P(array_ref)) {
5300 array_ptr = Z_REFVAL_P(array_ref);
5301 }
5302 } else {
5303 array_ref = array_ptr = RT_CONSTANT(opline, opline->op1);
5304 }
5305
5306 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
5307 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5308 if (array_ptr == array_ref) {
5309 ZVAL_NEW_REF(array_ref, array_ref);
5310 array_ptr = Z_REFVAL_P(array_ref);
5311 }
5312 Z_ADDREF_P(array_ref);
5313 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5314 } else {
5315 array_ref = EX_VAR(opline->result.var);
5316 ZVAL_NEW_REF(array_ref, array_ptr);
5317 array_ptr = Z_REFVAL_P(array_ref);
5318 }
5319 if (IS_CONST == IS_CONST) {
5320 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
5321 } else {
5322 SEPARATE_ARRAY(array_ptr);
5323 }
5324 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
5325
5326 ZEND_VM_NEXT_OPCODE();
5327 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
5328 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
5329 HashTable *properties;
5330 if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
5331 if (array_ptr == array_ref) {
5332 ZVAL_NEW_REF(array_ref, array_ref);
5333 array_ptr = Z_REFVAL_P(array_ref);
5334 }
5335 Z_ADDREF_P(array_ref);
5336 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
5337 } else {
5338 array_ptr = EX_VAR(opline->result.var);
5339 ZVAL_COPY_VALUE(array_ptr, array_ref);
5340 }
5341 if (Z_OBJ_P(array_ptr)->properties
5342 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
5343 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
5344 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
5345 }
5346 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
5347 }
5348
5349 properties = Z_OBJPROP_P(array_ptr);
5350 if (zend_hash_num_elements(properties) == 0) {
5351 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
5352
5353 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5354 }
5355
5356 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
5357
5358 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5359 } else {
5360 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
5361
5362 if (UNEXPECTED(EG(exception))) {
5363 HANDLE_EXCEPTION();
5364 } else if (is_empty) {
5365 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5366 } else {
5367 ZEND_VM_NEXT_OPCODE();
5368 }
5369 }
5370 } else {
5371 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
5372 ZVAL_UNDEF(EX_VAR(opline->result.var));
5373 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
5374
5375 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
5376 }
5377 }
5378
ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5379 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5380 {
5381 USE_OPLINE
5382 zval *value;
5383 zend_reference *ref = NULL;
5384 bool ret;
5385
5386 SAVE_OPLINE();
5387 value = RT_CONSTANT(opline, opline->op1);
5388
5389 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && Z_ISREF_P(value)) {
5390 if (IS_CONST == IS_VAR) {
5391 ref = Z_REF_P(value);
5392 }
5393 value = Z_REFVAL_P(value);
5394 }
5395
5396 ret = i_zend_is_true(value);
5397
5398 if (UNEXPECTED(EG(exception))) {
5399
5400 ZVAL_UNDEF(EX_VAR(opline->result.var));
5401 HANDLE_EXCEPTION();
5402 }
5403
5404 if (ret) {
5405 zval *result = EX_VAR(opline->result.var);
5406
5407 ZVAL_COPY_VALUE(result, value);
5408 if (IS_CONST == IS_CONST) {
5409 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5410 } else if (IS_CONST == IS_CV) {
5411 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5412 } else if (IS_CONST == IS_VAR && ref) {
5413 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5414 efree_size(ref, sizeof(zend_reference));
5415 } else if (Z_OPT_REFCOUNTED_P(result)) {
5416 Z_ADDREF_P(result);
5417 }
5418 }
5419 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5420 }
5421
5422 ZEND_VM_NEXT_OPCODE();
5423 }
5424
ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5425 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5426 {
5427 USE_OPLINE
5428 zval *value;
5429 zend_reference *ref = NULL;
5430
5431 SAVE_OPLINE();
5432 value = RT_CONSTANT(opline, opline->op1);
5433
5434 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
5435 if (IS_CONST & IS_VAR) {
5436 ref = Z_REF_P(value);
5437 }
5438 value = Z_REFVAL_P(value);
5439 }
5440
5441 if (Z_TYPE_P(value) > IS_NULL) {
5442 zval *result = EX_VAR(opline->result.var);
5443 ZVAL_COPY_VALUE(result, value);
5444 if (IS_CONST == IS_CONST) {
5445 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
5446 } else if (IS_CONST == IS_CV) {
5447 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
5448 } else if ((IS_CONST & IS_VAR) && ref) {
5449 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5450 efree_size(ref, sizeof(zend_reference));
5451 } else if (Z_OPT_REFCOUNTED_P(result)) {
5452 Z_ADDREF_P(result);
5453 }
5454 }
5455 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5456 }
5457
5458 if ((IS_CONST & IS_VAR) && ref) {
5459 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
5460 efree_size(ref, sizeof(zend_reference));
5461 }
5462 }
5463 ZEND_VM_NEXT_OPCODE();
5464 }
5465
ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5466 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5467 {
5468 USE_OPLINE
5469 zval *val, *result;
5470
5471 val = RT_CONSTANT(opline, opline->op1);
5472
5473 if (Z_TYPE_P(val) > IS_NULL) {
5474 do {
5475 if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
5476 val = Z_REFVAL_P(val);
5477 if (Z_TYPE_P(val) <= IS_NULL) {
5478
5479 break;
5480 }
5481 }
5482 ZEND_VM_NEXT_OPCODE();
5483 } while (0);
5484 }
5485
5486 result = EX_VAR(opline->result.var);
5487 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
5488 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
5489 ZVAL_NULL(result);
5490 if (IS_CONST == IS_CV
5491 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
5492 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
5493 ) {
5494 SAVE_OPLINE();
5495 ZVAL_UNDEFINED_OP1();
5496 if (UNEXPECTED(EG(exception) != NULL)) {
5497 HANDLE_EXCEPTION();
5498 }
5499 }
5500 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
5501 ZVAL_FALSE(result);
5502 } else {
5503 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
5504 ZVAL_TRUE(result);
5505 }
5506
5507 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
5508 }
5509
ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5510 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5511 {
5512 USE_OPLINE
5513 zval *value;
5514 zval *result = EX_VAR(opline->result.var);
5515
5516 value = RT_CONSTANT(opline, opline->op1);
5517 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5518 SAVE_OPLINE();
5519 ZVAL_UNDEFINED_OP1();
5520 ZVAL_NULL(result);
5521 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5522 }
5523
5524 if (IS_CONST == IS_CV) {
5525 ZVAL_COPY_DEREF(result, value);
5526 } else if (IS_CONST == IS_VAR) {
5527 if (UNEXPECTED(Z_ISREF_P(value))) {
5528 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
5529 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
5530 efree_size(Z_REF_P(value), sizeof(zend_reference));
5531 } else if (Z_OPT_REFCOUNTED_P(result)) {
5532 Z_ADDREF_P(result);
5533 }
5534 } else {
5535 ZVAL_COPY_VALUE(result, value);
5536 }
5537 } else {
5538 ZVAL_COPY_VALUE(result, value);
5539 if (IS_CONST == IS_CONST) {
5540 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
5541 Z_ADDREF_P(result);
5542 }
5543 }
5544 }
5545 ZEND_VM_NEXT_OPCODE();
5546 }
5547
ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5548 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5549 {
5550 USE_OPLINE
5551
5552 SAVE_OPLINE();
5553 do_bind_class(RT_CONSTANT(opline, opline->op1), (opline->op2_type == IS_CONST) ? Z_STR_P(RT_CONSTANT(opline, opline->op2)) : NULL);
5554 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5555 }
5556
ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5557 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5558 {
5559 USE_OPLINE
5560 zend_function *func;
5561 zval *object;
5562 zend_class_entry *called_scope;
5563
5564 func = (zend_function *) EX(func)->op_array.dynamic_func_defs[opline->op2.num];
5565 if (Z_TYPE(EX(This)) == IS_OBJECT) {
5566 called_scope = Z_OBJCE(EX(This));
5567 if (UNEXPECTED((func->common.fn_flags & ZEND_ACC_STATIC) ||
5568 (EX(func)->common.fn_flags & ZEND_ACC_STATIC))) {
5569 object = NULL;
5570 } else {
5571 object = &EX(This);
5572 }
5573 } else {
5574 called_scope = Z_CE(EX(This));
5575 object = NULL;
5576 }
5577 SAVE_OPLINE();
5578 zend_create_closure(EX_VAR(opline->result.var), func,
5579 EX(func)->op_array.scope, called_scope, object);
5580
5581 ZEND_VM_NEXT_OPCODE();
5582 }
5583
ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5584 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5585 {
5586 USE_OPLINE
5587 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
5588 zval *val;
5589
5590 SAVE_OPLINE();
5591 val = RT_CONSTANT(opline, opline->op1);
5592
5593 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
5594 zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
5595
5596 UNDEF_RESULT();
5597 HANDLE_EXCEPTION();
5598 }
5599
5600 yield_from_try_again:
5601 if (Z_TYPE_P(val) == IS_ARRAY) {
5602 ZVAL_COPY_VALUE(&generator->values, val);
5603 if (Z_OPT_REFCOUNTED_P(val)) {
5604 Z_ADDREF_P(val);
5605 }
5606 Z_FE_POS(generator->values) = 0;
5607
5608 } else if (IS_CONST != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
5609 zend_class_entry *ce = Z_OBJCE_P(val);
5610 if (ce == zend_ce_generator) {
5611 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
5612
5613 Z_ADDREF_P(val);
5614
5615 if (UNEXPECTED(new_gen->execute_data == NULL)) {
5616 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
5617 zval_ptr_dtor(val);
5618 UNDEF_RESULT();
5619 HANDLE_EXCEPTION();
5620 } else if (Z_ISUNDEF(new_gen->retval)) {
5621 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
5622 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
5623 zval_ptr_dtor(val);
5624 UNDEF_RESULT();
5625 HANDLE_EXCEPTION();
5626 } else {
5627 zend_generator_yield_from(generator, new_gen);
5628 }
5629 } else {
5630 if (RETURN_VALUE_USED(opline)) {
5631 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
5632 }
5633 ZEND_VM_NEXT_OPCODE();
5634 }
5635 } else {
5636 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
5637
5638 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
5639 if (!EG(exception)) {
5640 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
5641 }
5642 UNDEF_RESULT();
5643 HANDLE_EXCEPTION();
5644 }
5645
5646 iter->index = 0;
5647 if (iter->funcs->rewind) {
5648 iter->funcs->rewind(iter);
5649 if (UNEXPECTED(EG(exception) != NULL)) {
5650 OBJ_RELEASE(&iter->std);
5651 UNDEF_RESULT();
5652 HANDLE_EXCEPTION();
5653 }
5654 }
5655
5656 ZVAL_OBJ(&generator->values, &iter->std);
5657 }
5658 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
5659 val = Z_REFVAL_P(val);
5660 goto yield_from_try_again;
5661 } else {
5662 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
5663
5664 UNDEF_RESULT();
5665 HANDLE_EXCEPTION();
5666 }
5667
5668 /* This is the default return value
5669 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
5670 if (RETURN_VALUE_USED(opline)) {
5671 ZVAL_NULL(EX_VAR(opline->result.var));
5672 }
5673
5674 /* This generator has no send target (though the generator we delegate to might have one) */
5675 generator->send_target = NULL;
5676
5677 /* We increment to the next op, so we are at the correct position when the
5678 * generator is resumed. */
5679 ZEND_VM_INC_OPCODE();
5680
5681 /* The GOTO VM uses a local opline variable. We need to set the opline
5682 * variable in execute_data so we don't resume at an old position. */
5683 SAVE_OPLINE();
5684
5685 ZEND_VM_RETURN();
5686 }
5687
ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5688 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5689 {
5690 USE_OPLINE
5691 zval *value;
5692
5693 value = RT_CONSTANT(opline, opline->op1);
5694 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
5695 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
5696 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
5697 zval_ptr_dtor_str(value);
5698 }
5699 ZEND_VM_NEXT_OPCODE();
5700 } else {
5701 bool strict;
5702
5703 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
5704 value = Z_REFVAL_P(value);
5705 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
5706 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
5707
5708 ZEND_VM_NEXT_OPCODE();
5709 }
5710 }
5711
5712 SAVE_OPLINE();
5713 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5714 value = ZVAL_UNDEFINED_OP1();
5715 }
5716 strict = EX_USES_STRICT_TYPES();
5717 do {
5718 if (EXPECTED(!strict)) {
5719 zend_string *str;
5720 zval tmp;
5721
5722 if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
5723 zend_error(E_DEPRECATED,
5724 "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
5725 ZVAL_LONG(EX_VAR(opline->result.var), 0);
5726 if (UNEXPECTED(EG(exception))) {
5727 HANDLE_EXCEPTION();
5728 }
5729 break;
5730 }
5731
5732 ZVAL_COPY(&tmp, value);
5733 if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
5734 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
5735 zval_ptr_dtor(&tmp);
5736 break;
5737 }
5738 zval_ptr_dtor(&tmp);
5739 }
5740 if (!EG(exception)) {
5741 zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
5742 }
5743 ZVAL_UNDEF(EX_VAR(opline->result.var));
5744 } while (0);
5745 }
5746
5747 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
5748 }
5749
ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5750 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5751 {
5752 USE_OPLINE
5753 zval *value;
5754 int result = 0;
5755
5756 value = RT_CONSTANT(opline, opline->op1);
5757 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
5758 type_check_resource:
5759 if (opline->extended_value != MAY_BE_RESOURCE
5760 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
5761 result = 1;
5762 }
5763 } else if ((IS_CONST & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
5764 value = Z_REFVAL_P(value);
5765 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
5766 goto type_check_resource;
5767 }
5768 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
5769 result = ((1 << IS_NULL) & opline->extended_value) != 0;
5770 SAVE_OPLINE();
5771 ZVAL_UNDEFINED_OP1();
5772 if (UNEXPECTED(EG(exception))) {
5773 ZVAL_UNDEF(EX_VAR(opline->result.var));
5774 HANDLE_EXCEPTION();
5775 }
5776 }
5777 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
5778 SAVE_OPLINE();
5779
5780 ZEND_VM_SMART_BRANCH(result, 1);
5781 } else {
5782 ZEND_VM_SMART_BRANCH(result, 0);
5783 }
5784 }
5785
ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5786 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5787 {
5788 USE_OPLINE
5789 zend_constant *c;
5790
5791 c = CACHED_PTR(opline->extended_value);
5792 if (EXPECTED(c != NULL)) {
5793 if (!IS_SPECIAL_CACHE_VAL(c)) {
5794 defined_true:
5795 ZEND_VM_SMART_BRANCH_TRUE();
5796 } else if (EXPECTED(zend_hash_num_elements(EG(zend_constants)) == DECODE_SPECIAL_CACHE_NUM(c))) {
5797 defined_false:
5798 ZEND_VM_SMART_BRANCH_FALSE();
5799 }
5800 }
5801 if (zend_quick_check_constant(RT_CONSTANT(opline, opline->op1) OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
5802 CACHE_PTR(opline->extended_value, ENCODE_SPECIAL_CACHE_NUM(zend_hash_num_elements(EG(zend_constants))));
5803 goto defined_false;
5804 } else {
5805 goto defined_true;
5806 }
5807 }
5808
ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5809 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5810 {
5811 USE_OPLINE
5812 zend_jmp_fl_result result = (uintptr_t)CACHED_PTR(opline->extended_value);
5813 try_again:
5814 if (EXPECTED(result == ZEND_JMP_FL_HIT)) {
5815 OPLINE = OP_JMP_ADDR(opline, opline->op2);
5816 ZEND_VM_CONTINUE();
5817 } else if (EXPECTED(result == ZEND_JMP_FL_MISS)) {
5818 ZEND_VM_NEXT_OPCODE();
5819 } else {
5820 ZEND_ASSERT(result == ZEND_JMP_FL_UNPRIMED);
5821 /* func_name refers to the function in the local namespace, e.g. foo\substr. */
5822 zval *func_name = (zval *)RT_CONSTANT(opline, opline->op1);
5823 /* If it cannot be found locally, we must be referring to the global function. */
5824 zval *func = zend_hash_find_known_hash(EG(function_table), Z_STR_P(func_name));
5825 /* ZEND_JMP_FL_MISS = 1, ZEND_JMP_FL_HIT = 2 */
5826 result = (func == NULL) + 1;
5827 CACHE_PTR(opline->extended_value, (void *)result);
5828 goto try_again;
5829 }
5830 }
5831
ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5832 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5833 {
5834 USE_OPLINE
5835 zval *value;
5836
5837 value = RT_CONSTANT(opline, opline->op1);
5838 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
5839 ZEND_VM_NEXT_OPCODE();
5840 }
5841
ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5842 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5843 {
5844 USE_OPLINE
5845 zval *value;
5846
5847 value = RT_CONSTANT(opline, opline->op1);
5848 ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
5849 ZEND_VM_NEXT_OPCODE();
5850 }
5851
ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5852 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5853 {
5854 USE_OPLINE
5855 zval *value;
5856
5857 value = RT_CONSTANT(opline, opline->op1);
5858 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
5859 ZEND_VM_NEXT_OPCODE();
5860 }
5861
ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5862 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5863 {
5864 USE_OPLINE
5865 zval *value, *arg;
5866
5867 value = RT_CONSTANT(opline, opline->op1);
5868 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
5869 ZVAL_COPY_VALUE(arg, value);
5870 ZEND_VM_NEXT_OPCODE();
5871 }
5872
ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5873 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5874 {
5875 USE_OPLINE
5876 zval *value, *arg;
5877 uint32_t arg_num = opline->op2.num;
5878
5879 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
5880 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
5881 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
5882 }
5883 value = RT_CONSTANT(opline, opline->op1);
5884 ZVAL_COPY_VALUE(arg, value);
5885 ZEND_VM_NEXT_OPCODE();
5886 }
5887
ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5888 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5889 {
5890 USE_OPLINE
5891 zval *op1, *op2, *result;
5892 double d1, d2;
5893
5894 op1 = RT_CONSTANT(opline, opline->op1);
5895 op2 = RT_CONSTANT(opline, opline->op2);
5896 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
5897 /* pass */
5898 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
5899 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
5900 result = EX_VAR(opline->result.var);
5901 fast_long_add_function(result, op1, op2);
5902 ZEND_VM_NEXT_OPCODE();
5903 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
5904 d1 = (double)Z_LVAL_P(op1);
5905 d2 = Z_DVAL_P(op2);
5906 goto add_double;
5907 }
5908 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
5909 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
5910 d1 = Z_DVAL_P(op1);
5911 d2 = Z_DVAL_P(op2);
5912 add_double:
5913 result = EX_VAR(opline->result.var);
5914 ZVAL_DOUBLE(result, d1 + d2);
5915 ZEND_VM_NEXT_OPCODE();
5916 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
5917 d1 = Z_DVAL_P(op1);
5918 d2 = (double)Z_LVAL_P(op2);
5919 goto add_double;
5920 }
5921 }
5922
5923 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
5924 }
5925
ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5926 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5927 {
5928 USE_OPLINE
5929 zval *op1, *op2, *result;
5930 double d1, d2;
5931
5932 op1 = RT_CONSTANT(opline, opline->op1);
5933 op2 = RT_CONSTANT(opline, opline->op2);
5934 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
5935 /* pass */
5936 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
5937 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
5938 result = EX_VAR(opline->result.var);
5939 fast_long_sub_function(result, op1, op2);
5940 ZEND_VM_NEXT_OPCODE();
5941 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
5942 d1 = (double)Z_LVAL_P(op1);
5943 d2 = Z_DVAL_P(op2);
5944 goto sub_double;
5945 }
5946 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
5947 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
5948 d1 = Z_DVAL_P(op1);
5949 d2 = Z_DVAL_P(op2);
5950 sub_double:
5951 result = EX_VAR(opline->result.var);
5952 ZVAL_DOUBLE(result, d1 - d2);
5953 ZEND_VM_NEXT_OPCODE();
5954 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
5955 d1 = Z_DVAL_P(op1);
5956 d2 = (double)Z_LVAL_P(op2);
5957 goto sub_double;
5958 }
5959 }
5960
5961 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
5962 }
5963
ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)5964 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
5965 {
5966 USE_OPLINE
5967 zval *op1, *op2, *result;
5968 double d1, d2;
5969
5970 op1 = RT_CONSTANT(opline, opline->op1);
5971 op2 = RT_CONSTANT(opline, opline->op2);
5972 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
5973 /* pass */
5974 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
5975 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
5976 zend_long overflow;
5977
5978 result = EX_VAR(opline->result.var);
5979 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
5980 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
5981 ZEND_VM_NEXT_OPCODE();
5982 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
5983 d1 = (double)Z_LVAL_P(op1);
5984 d2 = Z_DVAL_P(op2);
5985 goto mul_double;
5986 }
5987 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
5988 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
5989 d1 = Z_DVAL_P(op1);
5990 d2 = Z_DVAL_P(op2);
5991 mul_double:
5992 result = EX_VAR(opline->result.var);
5993 ZVAL_DOUBLE(result, d1 * d2);
5994 ZEND_VM_NEXT_OPCODE();
5995 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
5996 d1 = Z_DVAL_P(op1);
5997 d2 = (double)Z_LVAL_P(op2);
5998 goto mul_double;
5999 }
6000 }
6001
6002 ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6003 }
6004
ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6005 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6006 {
6007 USE_OPLINE
6008 zval *op1, *op2;
6009
6010 SAVE_OPLINE();
6011 op1 = RT_CONSTANT(opline, opline->op1);
6012 op2 = RT_CONSTANT(opline, opline->op2);
6013 div_function(EX_VAR(opline->result.var), op1, op2);
6014
6015
6016 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6017 }
6018
ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6019 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6020 {
6021 USE_OPLINE
6022 zval *op1, *op2, *result;
6023
6024 op1 = RT_CONSTANT(opline, opline->op1);
6025 op2 = RT_CONSTANT(opline, opline->op2);
6026 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6027 /* pass */
6028 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6029 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6030 result = EX_VAR(opline->result.var);
6031 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
6032 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6033 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
6034 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
6035 ZVAL_LONG(result, 0);
6036 } else {
6037 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
6038 }
6039 ZEND_VM_NEXT_OPCODE();
6040 }
6041 }
6042
6043 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6044 }
6045
ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6046 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6047 {
6048 USE_OPLINE
6049 zval *op1, *op2;
6050
6051 op1 = RT_CONSTANT(opline, opline->op1);
6052 op2 = RT_CONSTANT(opline, opline->op2);
6053 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6054 /* pass */
6055 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6056 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
6057 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
6058 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
6059 ZVAL_LONG(EX_VAR(opline->result.var),
6060 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
6061 ZEND_VM_NEXT_OPCODE();
6062 }
6063
6064 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6065 }
6066
ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6067 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6068 {
6069 USE_OPLINE
6070 zval *op1, *op2;
6071
6072 op1 = RT_CONSTANT(opline, opline->op1);
6073 op2 = RT_CONSTANT(opline, opline->op2);
6074 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6075 /* pass */
6076 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6077 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
6078 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
6079 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
6080 ZEND_VM_NEXT_OPCODE();
6081 }
6082
6083 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6084 }
6085
ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6086 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6087 {
6088 USE_OPLINE
6089 zval *op1, *op2;
6090
6091 SAVE_OPLINE();
6092 op1 = RT_CONSTANT(opline, opline->op1);
6093 op2 = RT_CONSTANT(opline, opline->op2);
6094 pow_function(EX_VAR(opline->result.var), op1, op2);
6095
6096
6097 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6098 }
6099
ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6100 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6101 {
6102 USE_OPLINE
6103 zval *op1, *op2;
6104 bool result;
6105
6106 SAVE_OPLINE();
6107 op1 = RT_CONSTANT(opline, opline->op1);
6108 op2 = RT_CONSTANT(opline, opline->op2);
6109 result = fast_is_identical_function(op1, op2);
6110
6111
6112 ZEND_VM_SMART_BRANCH(result, 1);
6113 }
6114
ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6115 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6116 {
6117 USE_OPLINE
6118 zval *op1, *op2;
6119 bool result;
6120
6121 SAVE_OPLINE();
6122 op1 = RT_CONSTANT(opline, opline->op1);
6123 op2 = RT_CONSTANT(opline, opline->op2);
6124 result = fast_is_not_identical_function(op1, op2);
6125
6126
6127 ZEND_VM_SMART_BRANCH(result, 1);
6128 }
6129
ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6130 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6131 {
6132 USE_OPLINE
6133 zval *op1, *op2;
6134 double d1, d2;
6135
6136 op1 = RT_CONSTANT(opline, opline->op1);
6137 op2 = RT_CONSTANT(opline, opline->op2);
6138 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6139 /* pass */
6140 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
6141 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6142 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
6143 is_equal_true:
6144 ZEND_VM_SMART_BRANCH_TRUE();
6145 } else {
6146 is_equal_false:
6147 ZEND_VM_SMART_BRANCH_FALSE();
6148 }
6149 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6150 d1 = (double)Z_LVAL_P(op1);
6151 d2 = Z_DVAL_P(op2);
6152 goto is_equal_double;
6153 }
6154 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
6155 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6156 d1 = Z_DVAL_P(op1);
6157 d2 = Z_DVAL_P(op2);
6158 is_equal_double:
6159 if (d1 == d2) {
6160 goto is_equal_true;
6161 } else {
6162 goto is_equal_false;
6163 }
6164 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6165 d1 = Z_DVAL_P(op1);
6166 d2 = (double)Z_LVAL_P(op2);
6167 goto is_equal_double;
6168 }
6169 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6170 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6171 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
6172 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6173 zval_ptr_dtor_str(op1);
6174 }
6175 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6176 zval_ptr_dtor_str(op2);
6177 }
6178 if (result) {
6179 goto is_equal_true;
6180 } else {
6181 goto is_equal_false;
6182 }
6183 }
6184 }
6185 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6186 }
6187
ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6188 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6189 {
6190 USE_OPLINE
6191 zval *op1, *op2;
6192 double d1, d2;
6193
6194 op1 = RT_CONSTANT(opline, opline->op1);
6195 op2 = RT_CONSTANT(opline, opline->op2);
6196 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6197 /* pass */
6198 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
6199 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6200 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
6201 is_not_equal_true:
6202 ZEND_VM_SMART_BRANCH_TRUE();
6203 } else {
6204 is_not_equal_false:
6205 ZEND_VM_SMART_BRANCH_FALSE();
6206 }
6207 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6208 d1 = (double)Z_LVAL_P(op1);
6209 d2 = Z_DVAL_P(op2);
6210 goto is_not_equal_double;
6211 }
6212 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
6213 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
6214 d1 = Z_DVAL_P(op1);
6215 d2 = Z_DVAL_P(op2);
6216 is_not_equal_double:
6217 if (d1 != d2) {
6218 goto is_not_equal_true;
6219 } else {
6220 goto is_not_equal_false;
6221 }
6222 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
6223 d1 = Z_DVAL_P(op1);
6224 d2 = (double)Z_LVAL_P(op2);
6225 goto is_not_equal_double;
6226 }
6227 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6228 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6229 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
6230 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6231 zval_ptr_dtor_str(op1);
6232 }
6233 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6234 zval_ptr_dtor_str(op2);
6235 }
6236 if (!result) {
6237 goto is_not_equal_true;
6238 } else {
6239 goto is_not_equal_false;
6240 }
6241 }
6242 }
6243 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6244 }
6245
ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6246 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6247 {
6248 USE_OPLINE
6249 zval *op1, *op2;
6250 double d1, d2;
6251
6252 op1 = RT_CONSTANT(opline, opline->op1);
6253 op2 = RT_CONSTANT(opline, opline->op2);
6254 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6255 /* pass */
6256 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6257 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6258 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
6259 is_smaller_true:
6260 ZEND_VM_SMART_BRANCH_TRUE();
6261 } else {
6262 is_smaller_false:
6263 ZEND_VM_SMART_BRANCH_FALSE();
6264 }
6265 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6266 d1 = (double)Z_LVAL_P(op1);
6267 d2 = Z_DVAL_P(op2);
6268 goto is_smaller_double;
6269 }
6270 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6271 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6272 d1 = Z_DVAL_P(op1);
6273 d2 = Z_DVAL_P(op2);
6274 is_smaller_double:
6275 if (d1 < d2) {
6276 goto is_smaller_true;
6277 } else {
6278 goto is_smaller_false;
6279 }
6280 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6281 d1 = Z_DVAL_P(op1);
6282 d2 = (double)Z_LVAL_P(op2);
6283 goto is_smaller_double;
6284 }
6285 }
6286 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6287 }
6288
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6289 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6290 {
6291 USE_OPLINE
6292 zval *op1, *op2;
6293 double d1, d2;
6294
6295 op1 = RT_CONSTANT(opline, opline->op1);
6296 op2 = RT_CONSTANT(opline, opline->op2);
6297 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6298 /* pass */
6299 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
6300 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6301 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
6302 is_smaller_or_equal_true:
6303 ZEND_VM_SMART_BRANCH_TRUE();
6304 ZVAL_TRUE(EX_VAR(opline->result.var));
6305 ZEND_VM_NEXT_OPCODE();
6306 } else {
6307 is_smaller_or_equal_false:
6308 ZEND_VM_SMART_BRANCH_FALSE();
6309 ZVAL_FALSE(EX_VAR(opline->result.var));
6310 ZEND_VM_NEXT_OPCODE();
6311 }
6312 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6313 d1 = (double)Z_LVAL_P(op1);
6314 d2 = Z_DVAL_P(op2);
6315 goto is_smaller_or_equal_double;
6316 }
6317 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
6318 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
6319 d1 = Z_DVAL_P(op1);
6320 d2 = Z_DVAL_P(op2);
6321 is_smaller_or_equal_double:
6322 if (d1 <= d2) {
6323 goto is_smaller_or_equal_true;
6324 } else {
6325 goto is_smaller_or_equal_false;
6326 }
6327 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6328 d1 = Z_DVAL_P(op1);
6329 d2 = (double)Z_LVAL_P(op2);
6330 goto is_smaller_or_equal_double;
6331 }
6332 }
6333 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6334 }
6335
ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6336 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6337 {
6338 USE_OPLINE
6339 zval *op1, *op2;
6340
6341 SAVE_OPLINE();
6342 op1 = RT_CONSTANT(opline, opline->op1);
6343 op2 = RT_CONSTANT(opline, opline->op2);
6344 compare_function(EX_VAR(opline->result.var), op1, op2);
6345
6346
6347 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6348 }
6349
ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6350 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6351 {
6352 USE_OPLINE
6353 zval *op1, *op2;
6354
6355 op1 = RT_CONSTANT(opline, opline->op1);
6356 op2 = RT_CONSTANT(opline, opline->op2);
6357 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6358 /* pass */
6359 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6360 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6361 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
6362 ZEND_VM_NEXT_OPCODE();
6363 }
6364
6365 ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6366 }
6367
ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6368 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6369 {
6370 USE_OPLINE
6371 zval *op1, *op2;
6372
6373 op1 = RT_CONSTANT(opline, opline->op1);
6374 op2 = RT_CONSTANT(opline, opline->op2);
6375 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6376 /* pass */
6377 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6378 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6379 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
6380 ZEND_VM_NEXT_OPCODE();
6381 }
6382
6383 ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6384 }
6385
ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6386 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6387 {
6388 USE_OPLINE
6389 zval *op1, *op2;
6390
6391 op1 = RT_CONSTANT(opline, opline->op1);
6392 op2 = RT_CONSTANT(opline, opline->op2);
6393 if (1 && IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
6394 /* pass */
6395 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
6396 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
6397 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
6398 ZEND_VM_NEXT_OPCODE();
6399 }
6400
6401 ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
6402 }
6403
ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6404 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6405 {
6406 USE_OPLINE
6407 zval *op1, *op2;
6408
6409 SAVE_OPLINE();
6410 op1 = RT_CONSTANT(opline, opline->op1);
6411 op2 = RT_CONSTANT(opline, opline->op2);
6412 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
6413
6414
6415 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6416 }
6417
ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6418 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6419 {
6420 USE_OPLINE
6421 zval *container, *dim, *value;
6422
6423 SAVE_OPLINE();
6424 container = RT_CONSTANT(opline, opline->op1);
6425 dim = RT_CONSTANT(opline, opline->op2);
6426 if (IS_CONST != IS_CONST) {
6427 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6428 fetch_dim_r_array:
6429 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
6430 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
6431 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
6432 container = Z_REFVAL_P(container);
6433 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
6434 goto fetch_dim_r_array;
6435 } else {
6436 goto fetch_dim_r_slow;
6437 }
6438 } else {
6439 fetch_dim_r_slow:
6440 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
6441 dim++;
6442 }
6443 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
6444 }
6445 } else {
6446 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6447 }
6448
6449
6450 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6451 }
6452
ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6453 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6454 {
6455 USE_OPLINE
6456 zval *container;
6457
6458 SAVE_OPLINE();
6459 container = RT_CONSTANT(opline, opline->op1);
6460 zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6461
6462
6463 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6464 }
6465
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6466 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6467 {
6468 #if 0
6469 USE_OPLINE
6470 #endif
6471
6472 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
6473 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
6474 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6475 }
6476 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6477 } else {
6478 if (IS_CONST == IS_UNUSED) {
6479 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6480 }
6481 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6482 }
6483 }
6484
ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6485 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6486 {
6487 USE_OPLINE
6488 zval *container;
6489 void **cache_slot = NULL;
6490
6491 SAVE_OPLINE();
6492 container = RT_CONSTANT(opline, opline->op1);
6493
6494 if (IS_CONST == IS_CONST ||
6495 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
6496 do {
6497 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6498 container = Z_REFVAL_P(container);
6499 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
6500 break;
6501 }
6502 }
6503 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
6504 ZVAL_UNDEFINED_OP1();
6505 }
6506 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
6507 ZVAL_NULL(EX_VAR(opline->result.var));
6508 goto fetch_obj_r_finish;
6509 } while (0);
6510 }
6511
6512 /* here we are sure we are dealing with an object */
6513 do {
6514 zend_object *zobj = Z_OBJ_P(container);
6515 zend_string *name, *tmp_name;
6516 zval *retval;
6517
6518 if (IS_CONST == IS_CONST) {
6519 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
6520
6521 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
6522 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
6523
6524 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
6525 retval = OBJ_PROP(zobj, prop_offset);
6526 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
6527 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6528 goto fetch_obj_r_copy;
6529 } else {
6530 fetch_obj_r_fast_copy:
6531 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6532 ZEND_VM_NEXT_OPCODE();
6533 }
6534 }
6535 } else if (EXPECTED(zobj->properties != NULL)) {
6536 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6537 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
6538 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
6539
6540 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
6541 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
6542
6543 if (EXPECTED(p->key == name) ||
6544 (EXPECTED(p->h == ZSTR_H(name)) &&
6545 EXPECTED(p->key != NULL) &&
6546 EXPECTED(zend_string_equal_content(p->key, name)))) {
6547 retval = &p->val;
6548 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6549 goto fetch_obj_r_copy;
6550 } else {
6551 goto fetch_obj_r_fast_copy;
6552 }
6553 }
6554 }
6555 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
6556 }
6557 retval = zend_hash_find_known_hash(zobj->properties, name);
6558 if (EXPECTED(retval)) {
6559 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
6560 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
6561 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6562 goto fetch_obj_r_copy;
6563 } else {
6564 goto fetch_obj_r_fast_copy;
6565 }
6566 }
6567 }
6568 }
6569 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6570 } else {
6571 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
6572 if (UNEXPECTED(!name)) {
6573 ZVAL_UNDEF(EX_VAR(opline->result.var));
6574 break;
6575 }
6576 }
6577
6578 #if ZEND_DEBUG
6579 /* For non-standard object handlers, verify a declared property type in debug builds.
6580 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
6581 zend_property_info *prop_info = NULL;
6582 if (zobj->handlers->read_property != zend_std_read_property) {
6583 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
6584 }
6585 #endif
6586 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
6587 #if ZEND_DEBUG
6588 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
6589 && ZEND_TYPE_IS_SET(prop_info->type)) {
6590 ZVAL_OPT_DEREF(retval);
6591 zend_verify_property_type(prop_info, retval, /* strict */ true);
6592 }
6593 #endif
6594
6595 if (IS_CONST != IS_CONST) {
6596 zend_tmp_string_release(tmp_name);
6597 }
6598
6599 if (retval != EX_VAR(opline->result.var)) {
6600 fetch_obj_r_copy:
6601 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6602 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
6603 zend_unwrap_reference(retval);
6604 }
6605 } while (0);
6606
6607 fetch_obj_r_finish:
6608
6609
6610 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6611 }
6612
ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6613 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6614 {
6615 USE_OPLINE
6616 zval *container;
6617 void **cache_slot = NULL;
6618
6619 SAVE_OPLINE();
6620 container = RT_CONSTANT(opline, opline->op1);
6621
6622 if (IS_CONST == IS_CONST ||
6623 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
6624 do {
6625 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
6626 container = Z_REFVAL_P(container);
6627 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
6628 break;
6629 }
6630 }
6631 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
6632 ZVAL_UNDEFINED_OP2();
6633 }
6634 ZVAL_NULL(EX_VAR(opline->result.var));
6635 goto fetch_obj_is_finish;
6636 } while (0);
6637 }
6638
6639 /* here we are sure we are dealing with an object */
6640 do {
6641 zend_object *zobj = Z_OBJ_P(container);
6642 zend_string *name, *tmp_name;
6643 zval *retval;
6644
6645 if (IS_CONST == IS_CONST) {
6646 cache_slot = CACHE_ADDR(opline->extended_value);
6647
6648 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
6649 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
6650
6651 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
6652 retval = OBJ_PROP(zobj, prop_offset);
6653 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
6654 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6655 goto fetch_obj_is_copy;
6656 } else {
6657 fetch_obj_is_fast_copy:
6658 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6659 ZEND_VM_NEXT_OPCODE();
6660 }
6661 }
6662 } else if (EXPECTED(zobj->properties != NULL)) {
6663 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6664 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
6665 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
6666
6667 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
6668 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
6669
6670 if (EXPECTED(p->key == name) ||
6671 (EXPECTED(p->h == ZSTR_H(name)) &&
6672 EXPECTED(p->key != NULL) &&
6673 EXPECTED(zend_string_equal_content(p->key, name)))) {
6674 retval = &p->val;
6675 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6676 goto fetch_obj_is_copy;
6677 } else {
6678 goto fetch_obj_is_fast_copy;
6679 }
6680 }
6681 }
6682 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
6683 }
6684 retval = zend_hash_find_known_hash(zobj->properties, name);
6685 if (EXPECTED(retval)) {
6686 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
6687 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
6688 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
6689 goto fetch_obj_is_copy;
6690 } else {
6691 goto fetch_obj_is_fast_copy;
6692 }
6693 }
6694 }
6695 }
6696 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
6697 } else {
6698 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
6699 if (UNEXPECTED(!name)) {
6700 ZVAL_UNDEF(EX_VAR(opline->result.var));
6701 break;
6702 }
6703 }
6704
6705 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
6706
6707 if (IS_CONST != IS_CONST) {
6708 zend_tmp_string_release(tmp_name);
6709 }
6710
6711 if (retval != EX_VAR(opline->result.var)) {
6712 fetch_obj_is_copy:
6713 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
6714 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
6715 zend_unwrap_reference(retval);
6716 }
6717 } while (0);
6718
6719 fetch_obj_is_finish:
6720
6721
6722 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6723 }
6724
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6725 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6726 {
6727 #if 0
6728 USE_OPLINE
6729 #endif
6730
6731 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
6732 /* Behave like FETCH_OBJ_W */
6733 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
6734 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6735 }
6736 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6737 } else {
6738 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
6739 }
6740 }
6741
ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6742 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6743 {
6744 USE_OPLINE
6745 zval *container;
6746
6747 SAVE_OPLINE();
6748 container = RT_CONSTANT(opline, opline->op1);
6749 zend_fetch_dimension_address_LIST_r(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
6750
6751 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6752 }
6753
ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6754 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6755 {
6756 USE_OPLINE
6757 zval *op1, *op2;
6758 zend_string *op1_str, *op2_str, *str;
6759
6760
6761 op1 = RT_CONSTANT(opline, opline->op1);
6762 op2 = RT_CONSTANT(opline, opline->op2);
6763 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
6764 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
6765 zend_string *op1_str = Z_STR_P(op1);
6766 zend_string *op2_str = Z_STR_P(op2);
6767 zend_string *str;
6768 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
6769
6770 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
6771 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
6772 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
6773 } else {
6774 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
6775 }
6776 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6777 zend_string_release_ex(op1_str, 0);
6778 }
6779 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
6780 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
6781 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
6782 } else {
6783 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
6784 }
6785 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6786 zend_string_release_ex(op2_str, 0);
6787 }
6788 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
6789 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
6790 size_t len = ZSTR_LEN(op1_str);
6791
6792 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
6793 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
6794 GC_ADD_FLAGS(str, flags);
6795 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
6796 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6797 zend_string_release_ex(op2_str, 0);
6798 }
6799 } else {
6800 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
6801 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
6802 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
6803 GC_ADD_FLAGS(str, flags);
6804 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
6805 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6806 zend_string_release_ex(op1_str, 0);
6807 }
6808 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
6809 zend_string_release_ex(op2_str, 0);
6810 }
6811 }
6812 ZEND_VM_NEXT_OPCODE();
6813 }
6814
6815 SAVE_OPLINE();
6816 if (IS_CONST == IS_CONST) {
6817 op1_str = Z_STR_P(op1);
6818 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
6819 op1_str = zend_string_copy(Z_STR_P(op1));
6820 } else {
6821 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
6822 ZVAL_UNDEFINED_OP1();
6823 }
6824 op1_str = zval_get_string_func(op1);
6825 }
6826 if (IS_CONST == IS_CONST) {
6827 op2_str = Z_STR_P(op2);
6828 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
6829 op2_str = zend_string_copy(Z_STR_P(op2));
6830 } else {
6831 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
6832 ZVAL_UNDEFINED_OP2();
6833 }
6834 op2_str = zval_get_string_func(op2);
6835 }
6836 do {
6837 if (IS_CONST != IS_CONST) {
6838 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
6839 if (IS_CONST == IS_CONST) {
6840 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
6841 GC_ADDREF(op2_str);
6842 }
6843 }
6844 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
6845 zend_string_release_ex(op1_str, 0);
6846 break;
6847 }
6848 }
6849 if (IS_CONST != IS_CONST) {
6850 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
6851 if (IS_CONST == IS_CONST) {
6852 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
6853 GC_ADDREF(op1_str);
6854 }
6855 }
6856 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
6857 zend_string_release_ex(op2_str, 0);
6858 break;
6859 }
6860 }
6861 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
6862 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
6863 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
6864
6865 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
6866 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
6867 if (IS_CONST != IS_CONST) {
6868 zend_string_release_ex(op1_str, 0);
6869 }
6870 if (IS_CONST != IS_CONST) {
6871 zend_string_release_ex(op2_str, 0);
6872 }
6873 } while (0);
6874
6875
6876 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
6877 }
6878
ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)6879 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
6880 {
6881 USE_OPLINE
6882 zval *function_name;
6883 zval *object;
6884 zend_function *fbc;
6885 zend_class_entry *called_scope;
6886 zend_object *obj;
6887 zend_execute_data *call;
6888 uint32_t call_info;
6889
6890 SAVE_OPLINE();
6891
6892 object = RT_CONSTANT(opline, opline->op1);
6893
6894 if (IS_CONST != IS_CONST) {
6895 function_name = RT_CONSTANT(opline, opline->op2);
6896 }
6897
6898 if (IS_CONST != IS_CONST &&
6899 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
6900 do {
6901 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
6902 function_name = Z_REFVAL_P(function_name);
6903 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
6904 break;
6905 }
6906 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
6907 ZVAL_UNDEFINED_OP2();
6908 if (UNEXPECTED(EG(exception) != NULL)) {
6909
6910 HANDLE_EXCEPTION();
6911 }
6912 }
6913 zend_throw_error(NULL, "Method name must be a string");
6914
6915
6916 HANDLE_EXCEPTION();
6917 } while (0);
6918 }
6919
6920 if (IS_CONST == IS_UNUSED) {
6921 obj = Z_OBJ_P(object);
6922 } else {
6923 do {
6924 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
6925 obj = Z_OBJ_P(object);
6926 } else {
6927 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
6928 zend_reference *ref = Z_REF_P(object);
6929
6930 object = &ref->val;
6931 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
6932 obj = Z_OBJ_P(object);
6933 if (IS_CONST & IS_VAR) {
6934 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
6935 efree_size(ref, sizeof(zend_reference));
6936 } else {
6937 Z_ADDREF_P(object);
6938 }
6939 }
6940 break;
6941 }
6942 }
6943 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
6944 object = ZVAL_UNDEFINED_OP1();
6945 if (UNEXPECTED(EG(exception) != NULL)) {
6946 if (IS_CONST != IS_CONST) {
6947
6948 }
6949 HANDLE_EXCEPTION();
6950 }
6951 }
6952 if (IS_CONST == IS_CONST) {
6953 function_name = RT_CONSTANT(opline, opline->op2);
6954 }
6955 zend_invalid_method_call(object, function_name);
6956
6957
6958 HANDLE_EXCEPTION();
6959 }
6960 } while (0);
6961 }
6962
6963 called_scope = obj->ce;
6964
6965 if (IS_CONST == IS_CONST &&
6966 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
6967 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
6968 } else {
6969 zend_object *orig_obj = obj;
6970
6971 if (IS_CONST == IS_CONST) {
6972 function_name = RT_CONSTANT(opline, opline->op2);
6973 }
6974
6975 /* First, locate the function. */
6976 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
6977 if (UNEXPECTED(fbc == NULL)) {
6978 if (EXPECTED(!EG(exception))) {
6979 zend_undefined_method(obj->ce, Z_STR_P(function_name));
6980 }
6981
6982 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
6983 zend_objects_store_del(orig_obj);
6984 }
6985 HANDLE_EXCEPTION();
6986 }
6987 if (IS_CONST == IS_CONST &&
6988 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
6989 EXPECTED(obj == orig_obj)) {
6990 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
6991 }
6992 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
6993 GC_ADDREF(obj); /* For $this pointer */
6994 if (GC_DELREF(orig_obj) == 0) {
6995 zend_objects_store_del(orig_obj);
6996 }
6997 }
6998 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
6999 init_func_run_time_cache(&fbc->op_array);
7000 }
7001 }
7002
7003 if (IS_CONST != IS_CONST) {
7004
7005 }
7006
7007 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
7008 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
7009 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
7010 zend_objects_store_del(obj);
7011 if (UNEXPECTED(EG(exception))) {
7012 HANDLE_EXCEPTION();
7013 }
7014 }
7015 /* call static method */
7016 obj = (zend_object*)called_scope;
7017 call_info = ZEND_CALL_NESTED_FUNCTION;
7018 } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
7019 if (IS_CONST == IS_CV) {
7020 GC_ADDREF(obj); /* For $this pointer */
7021 }
7022 /* CV may be changed indirectly (e.g. when it's a reference) */
7023 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
7024 }
7025
7026 call = zend_vm_stack_push_call_frame(call_info,
7027 fbc, opline->extended_value, obj);
7028 call->prev_execute_data = EX(call);
7029 EX(call) = call;
7030
7031 ZEND_VM_NEXT_OPCODE();
7032 }
7033
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7034 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7035 {
7036 USE_OPLINE
7037 zval *function_name;
7038 zend_class_entry *ce;
7039 uint32_t call_info;
7040 zend_function *fbc;
7041 zend_execute_data *call;
7042
7043 SAVE_OPLINE();
7044
7045 if (IS_CONST == IS_CONST) {
7046 /* no function found. try a static method in class */
7047 ce = CACHED_PTR(opline->result.num);
7048 if (UNEXPECTED(ce == NULL)) {
7049 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);
7050 if (UNEXPECTED(ce == NULL)) {
7051
7052 HANDLE_EXCEPTION();
7053 }
7054 if (IS_CONST != IS_CONST) {
7055 CACHE_PTR(opline->result.num, ce);
7056 }
7057 }
7058 } else if (IS_CONST == IS_UNUSED) {
7059 ce = zend_fetch_class(NULL, opline->op1.num);
7060 if (UNEXPECTED(ce == NULL)) {
7061
7062 HANDLE_EXCEPTION();
7063 }
7064 } else {
7065 ce = Z_CE_P(EX_VAR(opline->op1.var));
7066 }
7067
7068 if (IS_CONST == IS_CONST &&
7069 IS_CONST == IS_CONST &&
7070 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
7071 /* nothing to do */
7072 } else if (IS_CONST != IS_CONST &&
7073 IS_CONST == IS_CONST &&
7074 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
7075 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
7076 } else if (IS_CONST != IS_UNUSED) {
7077 function_name = RT_CONSTANT(opline, opline->op2);
7078 if (IS_CONST != IS_CONST) {
7079 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
7080 do {
7081 if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
7082 function_name = Z_REFVAL_P(function_name);
7083 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
7084 break;
7085 }
7086 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
7087 ZVAL_UNDEFINED_OP2();
7088 if (UNEXPECTED(EG(exception) != NULL)) {
7089 HANDLE_EXCEPTION();
7090 }
7091 }
7092 zend_throw_error(NULL, "Method name must be a string");
7093
7094 HANDLE_EXCEPTION();
7095 } while (0);
7096 }
7097 }
7098
7099 if (ce->get_static_method) {
7100 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
7101 } else {
7102 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
7103 }
7104 if (UNEXPECTED(fbc == NULL)) {
7105 if (EXPECTED(!EG(exception))) {
7106 zend_undefined_method(ce, Z_STR_P(function_name));
7107 }
7108
7109 HANDLE_EXCEPTION();
7110 }
7111 if (IS_CONST == IS_CONST &&
7112 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
7113 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
7114 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
7115 }
7116 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7117 init_func_run_time_cache(&fbc->op_array);
7118 }
7119 if (IS_CONST != IS_CONST) {
7120
7121 }
7122 } else {
7123 if (UNEXPECTED(ce->constructor == NULL)) {
7124 zend_throw_error(NULL, "Cannot call constructor");
7125 HANDLE_EXCEPTION();
7126 }
7127 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
7128 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
7129 HANDLE_EXCEPTION();
7130 }
7131 fbc = ce->constructor;
7132 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
7133 init_func_run_time_cache(&fbc->op_array);
7134 }
7135 }
7136
7137 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
7138 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
7139 ce = (zend_class_entry*)Z_OBJ(EX(This));
7140 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
7141 } else {
7142 zend_non_static_method_call(fbc);
7143 HANDLE_EXCEPTION();
7144 }
7145 } else {
7146 /* previous opcode is ZEND_FETCH_CLASS */
7147 if (IS_CONST == IS_UNUSED
7148 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
7149 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
7150 if (Z_TYPE(EX(This)) == IS_OBJECT) {
7151 ce = Z_OBJCE(EX(This));
7152 } else {
7153 ce = Z_CE(EX(This));
7154 }
7155 }
7156 call_info = ZEND_CALL_NESTED_FUNCTION;
7157 }
7158
7159 call = zend_vm_stack_push_call_frame(call_info,
7160 fbc, opline->extended_value, ce);
7161 call->prev_execute_data = EX(call);
7162 EX(call) = call;
7163
7164 ZEND_VM_NEXT_OPCODE();
7165 }
7166
ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7167 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7168 {
7169 USE_OPLINE
7170 zval *function_name;
7171 zend_fcall_info_cache fcc;
7172 char *error = NULL;
7173 zend_function *func;
7174 void *object_or_called_scope;
7175 zend_execute_data *call;
7176 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
7177
7178 SAVE_OPLINE();
7179 function_name = RT_CONSTANT(opline, opline->op2);
7180 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
7181 ZEND_ASSERT(!error);
7182 func = fcc.function_handler;
7183 object_or_called_scope = fcc.called_scope;
7184 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
7185 /* Delay closure destruction until its invocation */
7186 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
7187 call_info |= ZEND_CALL_CLOSURE;
7188 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
7189 call_info |= ZEND_CALL_FAKE_CLOSURE;
7190 }
7191 if (fcc.object) {
7192 object_or_called_scope = fcc.object;
7193 call_info |= ZEND_CALL_HAS_THIS;
7194 }
7195 } else if (fcc.object) {
7196 GC_ADDREF(fcc.object); /* For $this pointer */
7197 object_or_called_scope = fcc.object;
7198 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
7199 }
7200
7201 if ((IS_CONST & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
7202 if (call_info & ZEND_CALL_CLOSURE) {
7203 zend_object_release(ZEND_CLOSURE_OBJECT(func));
7204 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
7205 zend_object_release(fcc.object);
7206 }
7207 HANDLE_EXCEPTION();
7208 }
7209
7210 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
7211 init_func_run_time_cache(&func->op_array);
7212 }
7213 } else {
7214 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
7215 efree(error);
7216
7217 HANDLE_EXCEPTION();
7218 }
7219
7220 call = zend_vm_stack_push_call_frame(call_info,
7221 func, opline->extended_value, object_or_called_scope);
7222 call->prev_execute_data = EX(call);
7223 EX(call) = call;
7224
7225 ZEND_VM_NEXT_OPCODE();
7226 }
7227
ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7228 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7229 {
7230 USE_OPLINE
7231 zval *value, *arg;
7232
7233 if (IS_CONST == IS_CONST) {
7234 SAVE_OPLINE();
7235 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7236 uint32_t arg_num;
7237 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7238 if (UNEXPECTED(!arg)) {
7239
7240 HANDLE_EXCEPTION();
7241 }
7242 } else {
7243 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7244 }
7245
7246 value = RT_CONSTANT(opline, opline->op1);
7247 ZVAL_COPY_VALUE(arg, value);
7248 if (IS_CONST == IS_CONST) {
7249 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7250 Z_ADDREF_P(arg);
7251 }
7252 }
7253 ZEND_VM_NEXT_OPCODE();
7254 }
7255
ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7256 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7257 {
7258 USE_OPLINE
7259 zval *value, *arg;
7260 uint32_t arg_num;
7261
7262 if (IS_CONST == IS_CONST) {
7263 SAVE_OPLINE();
7264 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
7265 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
7266 if (UNEXPECTED(!arg)) {
7267
7268 HANDLE_EXCEPTION();
7269 }
7270 } else {
7271 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
7272 arg_num = opline->op2.num;
7273 }
7274
7275 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
7276 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7277 goto send_val_by_ref;
7278 }
7279 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
7280 send_val_by_ref:
7281 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
7282 }
7283 value = RT_CONSTANT(opline, opline->op1);
7284 ZVAL_COPY_VALUE(arg, value);
7285 if (IS_CONST == IS_CONST) {
7286 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
7287 Z_ADDREF_P(arg);
7288 }
7289 }
7290 ZEND_VM_NEXT_OPCODE();
7291 }
7292
ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7293 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7294 {
7295 zend_class_entry *ce, *scope;
7296 zend_class_constant *c;
7297 zval *value, *zv, *constant_zv;
7298 zend_string *constant_name;
7299 USE_OPLINE
7300
7301 SAVE_OPLINE();
7302
7303 do {
7304 if (IS_CONST == IS_CONST && IS_CONST == IS_CONST) {
7305 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
7306 value = CACHED_PTR(opline->extended_value + sizeof(void*));
7307 break;
7308 }
7309 }
7310 if (IS_CONST == IS_CONST) {
7311 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
7312 ce = CACHED_PTR(opline->extended_value);
7313 } else {
7314 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);
7315 if (UNEXPECTED(ce == NULL)) {
7316 ZVAL_UNDEF(EX_VAR(opline->result.var));
7317
7318 HANDLE_EXCEPTION();
7319 }
7320 CACHE_PTR(opline->extended_value, ce);
7321 }
7322 } else if (IS_CONST == IS_UNUSED) {
7323 ce = zend_fetch_class(NULL, opline->op1.num);
7324 if (UNEXPECTED(ce == NULL)) {
7325 ZVAL_UNDEF(EX_VAR(opline->result.var));
7326
7327 HANDLE_EXCEPTION();
7328 }
7329 } else {
7330 ce = Z_CE_P(EX_VAR(opline->op1.var));
7331 }
7332 if (IS_CONST != IS_CONST
7333 && IS_CONST == IS_CONST
7334 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
7335 value = CACHED_PTR(opline->extended_value + sizeof(void*));
7336 break;
7337 }
7338
7339 constant_zv = RT_CONSTANT(opline, opline->op2);
7340 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
7341 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
7342 ZVAL_UNDEF(EX_VAR(opline->result.var));
7343
7344 HANDLE_EXCEPTION();
7345 }
7346 constant_name = Z_STR_P(constant_zv);
7347 /* Magic 'class' for constant OP2 is caught at compile-time */
7348 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
7349 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
7350
7351 ZEND_VM_NEXT_OPCODE();
7352 }
7353 zv = IS_CONST == IS_CONST
7354 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
7355 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
7356
7357 if (EXPECTED(zv != NULL)) {
7358 c = Z_PTR_P(zv);
7359 scope = EX(func)->op_array.scope;
7360 if (!zend_verify_const_access(c, scope)) {
7361 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));
7362 ZVAL_UNDEF(EX_VAR(opline->result.var));
7363
7364 HANDLE_EXCEPTION();
7365 }
7366
7367 if (ce->ce_flags & ZEND_ACC_TRAIT) {
7368 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7369 ZVAL_UNDEF(EX_VAR(opline->result.var));
7370
7371 HANDLE_EXCEPTION();
7372 }
7373
7374 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
7375 if (UNEXPECTED(is_constant_deprecated)) {
7376 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7377
7378 if (EG(exception)) {
7379 ZVAL_UNDEF(EX_VAR(opline->result.var));
7380
7381 HANDLE_EXCEPTION();
7382 }
7383 }
7384
7385 value = &c->value;
7386 // Enums require loading of all class constants to build the backed enum table
7387 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)) {
7388 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
7389 ZVAL_UNDEF(EX_VAR(opline->result.var));
7390
7391 HANDLE_EXCEPTION();
7392 }
7393 }
7394 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
7395 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
7396 ZVAL_UNDEF(EX_VAR(opline->result.var));
7397
7398 HANDLE_EXCEPTION();
7399 }
7400 }
7401 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
7402 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
7403 }
7404 } else {
7405 zend_throw_error(NULL, "Undefined constant %s::%s",
7406 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
7407 ZVAL_UNDEF(EX_VAR(opline->result.var));
7408
7409 HANDLE_EXCEPTION();
7410 }
7411 } while (0);
7412
7413 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
7414
7415 ZEND_VM_NEXT_OPCODE();
7416 }
7417
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7418 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7419 {
7420 USE_OPLINE
7421 zval *expr_ptr, new_expr;
7422
7423 SAVE_OPLINE();
7424 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
7425 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
7426 expr_ptr = zend_get_bad_ptr();
7427 if (Z_ISREF_P(expr_ptr)) {
7428 Z_ADDREF_P(expr_ptr);
7429 } else {
7430 ZVAL_MAKE_REF_EX(expr_ptr, 2);
7431 }
7432
7433 } else {
7434 expr_ptr = RT_CONSTANT(opline, opline->op1);
7435 if (IS_CONST == IS_TMP_VAR) {
7436 /* pass */
7437 } else if (IS_CONST == IS_CONST) {
7438 Z_TRY_ADDREF_P(expr_ptr);
7439 } else if (IS_CONST == IS_CV) {
7440 ZVAL_DEREF(expr_ptr);
7441 Z_TRY_ADDREF_P(expr_ptr);
7442 } else /* if (IS_CONST == IS_VAR) */ {
7443 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
7444 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
7445
7446 expr_ptr = Z_REFVAL_P(expr_ptr);
7447 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
7448 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
7449 expr_ptr = &new_expr;
7450 efree_size(ref, sizeof(zend_reference));
7451 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
7452 Z_ADDREF_P(expr_ptr);
7453 }
7454 }
7455 }
7456 }
7457
7458 if (IS_CONST != IS_UNUSED) {
7459 zval *offset = RT_CONSTANT(opline, opline->op2);
7460 zend_string *str;
7461 zend_ulong hval;
7462
7463 add_again:
7464 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7465 str = Z_STR_P(offset);
7466 if (IS_CONST != IS_CONST) {
7467 if (ZEND_HANDLE_NUMERIC(str, hval)) {
7468 goto num_index;
7469 }
7470 }
7471 str_index:
7472 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
7473 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7474 hval = Z_LVAL_P(offset);
7475 num_index:
7476 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
7477 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
7478 offset = Z_REFVAL_P(offset);
7479 goto add_again;
7480 } else if (Z_TYPE_P(offset) == IS_NULL) {
7481 str = ZSTR_EMPTY_ALLOC();
7482 goto str_index;
7483 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
7484 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
7485 goto num_index;
7486 } else if (Z_TYPE_P(offset) == IS_FALSE) {
7487 hval = 0;
7488 goto num_index;
7489 } else if (Z_TYPE_P(offset) == IS_TRUE) {
7490 hval = 1;
7491 goto num_index;
7492 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
7493 zend_use_resource_as_offset(offset);
7494 hval = Z_RES_HANDLE_P(offset);
7495 goto num_index;
7496 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
7497 ZVAL_UNDEFINED_OP2();
7498 str = ZSTR_EMPTY_ALLOC();
7499 goto str_index;
7500 } else {
7501 zend_illegal_array_offset_access(offset);
7502 zval_ptr_dtor_nogc(expr_ptr);
7503 }
7504
7505 } else {
7506 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
7507 zend_cannot_add_element();
7508 zval_ptr_dtor_nogc(expr_ptr);
7509 }
7510 }
7511 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7512 }
7513
ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7514 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7515 {
7516 zval *array;
7517 uint32_t size;
7518 USE_OPLINE
7519
7520 array = EX_VAR(opline->result.var);
7521 if (IS_CONST != IS_UNUSED) {
7522 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
7523 ZVAL_ARR(array, zend_new_array(size));
7524 /* Explicitly initialize array as not-packed if flag is set */
7525 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
7526 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
7527 }
7528 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7529 } else {
7530 ZVAL_ARR(array, zend_new_array(0));
7531 ZEND_VM_NEXT_OPCODE();
7532 }
7533 }
7534
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7535 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7536 {
7537 USE_OPLINE
7538 zval *container;
7539 bool result;
7540 zend_ulong hval;
7541 zval *offset;
7542
7543 SAVE_OPLINE();
7544 container = RT_CONSTANT(opline, opline->op1);
7545 offset = RT_CONSTANT(opline, opline->op2);
7546
7547 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7548 HashTable *ht;
7549 zval *value;
7550 zend_string *str;
7551
7552 isset_dim_obj_array:
7553 ht = Z_ARRVAL_P(container);
7554 isset_again:
7555 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
7556 str = Z_STR_P(offset);
7557 if (IS_CONST != IS_CONST) {
7558 if (ZEND_HANDLE_NUMERIC(str, hval)) {
7559 goto num_index_prop;
7560 }
7561 }
7562 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
7563 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
7564 hval = Z_LVAL_P(offset);
7565 num_index_prop:
7566 value = zend_hash_index_find(ht, hval);
7567 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
7568 offset = Z_REFVAL_P(offset);
7569 goto isset_again;
7570 } else {
7571 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
7572 if (UNEXPECTED(EG(exception))) {
7573 result = 0;
7574 goto isset_dim_obj_exit;
7575 }
7576 }
7577
7578 if (!(opline->extended_value & ZEND_ISEMPTY)) {
7579 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
7580 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
7581 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
7582
7583 if (IS_CONST & (IS_CONST|IS_CV)) {
7584 /* avoid exception check */
7585
7586 ZEND_VM_SMART_BRANCH(result, 0);
7587 }
7588 } else {
7589 result = (value == NULL || !i_zend_is_true(value));
7590 }
7591 goto isset_dim_obj_exit;
7592 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
7593 container = Z_REFVAL_P(container);
7594 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
7595 goto isset_dim_obj_array;
7596 }
7597 }
7598
7599 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
7600 offset++;
7601 }
7602 if (!(opline->extended_value & ZEND_ISEMPTY)) {
7603 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
7604 } else {
7605 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
7606 }
7607
7608 isset_dim_obj_exit:
7609
7610
7611 ZEND_VM_SMART_BRANCH(result, 1);
7612 }
7613
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7614 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7615 {
7616 USE_OPLINE
7617 zval *container;
7618 int result;
7619 zval *offset;
7620 zend_string *name, *tmp_name;
7621
7622 SAVE_OPLINE();
7623 container = RT_CONSTANT(opline, opline->op1);
7624 offset = RT_CONSTANT(opline, opline->op2);
7625
7626 if (IS_CONST == IS_CONST ||
7627 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
7628 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
7629 container = Z_REFVAL_P(container);
7630 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
7631 result = (opline->extended_value & ZEND_ISEMPTY);
7632 goto isset_object_finish;
7633 }
7634 } else {
7635 result = (opline->extended_value & ZEND_ISEMPTY);
7636 goto isset_object_finish;
7637 }
7638 }
7639
7640 if (IS_CONST == IS_CONST) {
7641 name = Z_STR_P(offset);
7642 } else {
7643 name = zval_try_get_tmp_string(offset, &tmp_name);
7644 if (UNEXPECTED(!name)) {
7645 result = 0;
7646 goto isset_object_finish;
7647 }
7648 }
7649
7650 result =
7651 (opline->extended_value & ZEND_ISEMPTY) ^
7652 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));
7653
7654 if (IS_CONST != IS_CONST) {
7655 zend_tmp_string_release(tmp_name);
7656 }
7657
7658 isset_object_finish:
7659
7660
7661 ZEND_VM_SMART_BRANCH(result, 1);
7662 }
7663
ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7664 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7665 {
7666 USE_OPLINE
7667
7668 zval *key, *subject;
7669 HashTable *ht;
7670 bool result;
7671
7672 SAVE_OPLINE();
7673
7674 key = RT_CONSTANT(opline, opline->op1);
7675 subject = RT_CONSTANT(opline, opline->op2);
7676
7677 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7678 array_key_exists_array:
7679 ht = Z_ARRVAL_P(subject);
7680 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
7681 } else {
7682 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
7683 subject = Z_REFVAL_P(subject);
7684 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
7685 goto array_key_exists_array;
7686 }
7687 }
7688 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
7689 result = 0;
7690 }
7691
7692
7693 ZEND_VM_SMART_BRANCH(result, 1);
7694 }
7695
7696 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7697 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7698 {
7699 USE_OPLINE
7700
7701 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
7702 if (ce == NULL) {
7703 zval *lcname = RT_CONSTANT(opline, opline->op1);
7704 zval *zv = zend_hash_find_known_hash(EG(class_table), Z_STR_P(lcname + 1));
7705 if (zv) {
7706 SAVE_OPLINE();
7707 ce = zend_bind_class_in_slot(zv, lcname, Z_STR_P(RT_CONSTANT(opline, opline->op2)));
7708 if (!ce) {
7709 HANDLE_EXCEPTION();
7710 }
7711 }
7712 CACHE_PTR(opline->extended_value, ce);
7713 }
7714 ZEND_VM_NEXT_OPCODE();
7715 }
7716
ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7717 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7718 {
7719 USE_OPLINE
7720 zval *name;
7721 zval *val;
7722 zend_constant c;
7723
7724 SAVE_OPLINE();
7725 name = RT_CONSTANT(opline, opline->op1);
7726 val = RT_CONSTANT(opline, opline->op2);
7727
7728 ZVAL_COPY(&c.value, val);
7729 if (Z_OPT_CONSTANT(c.value)) {
7730 if (UNEXPECTED(zval_update_constant_ex(&c.value, EX(func)->op_array.scope) != SUCCESS)) {
7731 zval_ptr_dtor_nogc(&c.value);
7732
7733
7734 HANDLE_EXCEPTION();
7735 }
7736 }
7737 /* non persistent, case sensitive */
7738 ZEND_CONSTANT_SET_FLAGS(&c, 0, PHP_USER_CONSTANT);
7739 c.name = zend_string_copy(Z_STR_P(name));
7740
7741 if (zend_register_constant(&c) == FAILURE) {
7742 }
7743
7744
7745 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
7746 }
7747
ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7748 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7749 {
7750 USE_OPLINE
7751
7752 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
7753
7754 SAVE_OPLINE();
7755 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
7756 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
7757 }
7758
7759 /* Destroy the previously yielded value */
7760 zval_ptr_dtor(&generator->value);
7761
7762 /* Destroy the previously yielded key */
7763 zval_ptr_dtor(&generator->key);
7764
7765 /* Set the new yielded value */
7766 if (IS_CONST != IS_UNUSED) {
7767 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
7768 /* Constants and temporary variables aren't yieldable by reference,
7769 * but we still allow them with a notice. */
7770 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
7771 zval *value;
7772
7773 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
7774
7775 value = RT_CONSTANT(opline, opline->op1);
7776 ZVAL_COPY_VALUE(&generator->value, value);
7777 if (IS_CONST == IS_CONST) {
7778 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
7779 Z_ADDREF(generator->value);
7780 }
7781 }
7782 } else {
7783 zval *value_ptr = zend_get_bad_ptr();
7784
7785 /* If a function call result is yielded and the function did
7786 * not return by reference we throw a notice. */
7787 do {
7788 if (IS_CONST == IS_VAR) {
7789 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
7790 if (opline->extended_value == ZEND_RETURNS_FUNCTION
7791 && !Z_ISREF_P(value_ptr)) {
7792 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
7793 ZVAL_COPY(&generator->value, value_ptr);
7794 break;
7795 }
7796 }
7797 if (Z_ISREF_P(value_ptr)) {
7798 Z_ADDREF_P(value_ptr);
7799 } else {
7800 ZVAL_MAKE_REF_EX(value_ptr, 2);
7801 }
7802 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
7803 } while (0);
7804
7805 }
7806 } else {
7807 zval *value = RT_CONSTANT(opline, opline->op1);
7808
7809 /* Consts, temporary variables and references need copying */
7810 if (IS_CONST == IS_CONST) {
7811 ZVAL_COPY_VALUE(&generator->value, value);
7812 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
7813 Z_ADDREF(generator->value);
7814 }
7815 } else if (IS_CONST == IS_TMP_VAR) {
7816 ZVAL_COPY_VALUE(&generator->value, value);
7817 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
7818 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
7819
7820 } else {
7821 ZVAL_COPY_VALUE(&generator->value, value);
7822 if (IS_CONST == IS_CV) {
7823 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
7824 }
7825 }
7826 }
7827 } else {
7828 /* If no value was specified yield null */
7829 ZVAL_NULL(&generator->value);
7830 }
7831
7832 /* Set the new yielded key */
7833 if (IS_CONST != IS_UNUSED) {
7834 zval *key = RT_CONSTANT(opline, opline->op2);
7835 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
7836 key = Z_REFVAL_P(key);
7837 }
7838 ZVAL_COPY(&generator->key, key);
7839
7840 if (Z_TYPE(generator->key) == IS_LONG
7841 && Z_LVAL(generator->key) > generator->largest_used_integer_key
7842 ) {
7843 generator->largest_used_integer_key = Z_LVAL(generator->key);
7844 }
7845 } else {
7846 /* If no key was specified we use auto-increment keys */
7847 generator->largest_used_integer_key++;
7848 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
7849 }
7850
7851 if (RETURN_VALUE_USED(opline)) {
7852 /* If the return value of yield is used set the send
7853 * target and initialize it to NULL */
7854 generator->send_target = EX_VAR(opline->result.var);
7855 ZVAL_NULL(generator->send_target);
7856 } else {
7857 generator->send_target = NULL;
7858 }
7859
7860 /* We increment to the next op, so we are at the correct position when the
7861 * generator is resumed. */
7862 ZEND_VM_INC_OPCODE();
7863
7864 /* The GOTO VM uses a local opline variable. We need to set the opline
7865 * variable in execute_data so we don't resume at an old position. */
7866 SAVE_OPLINE();
7867
7868 ZEND_VM_RETURN();
7869 }
7870
ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7871 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7872 {
7873 USE_OPLINE
7874 zval *op, *jump_zv;
7875 HashTable *jumptable;
7876
7877 op = RT_CONSTANT(opline, opline->op1);
7878
7879 if (Z_TYPE_P(op) != IS_LONG) {
7880 ZVAL_DEREF(op);
7881 if (Z_TYPE_P(op) != IS_LONG) {
7882 /* Wrong type, fall back to ZEND_CASE chain */
7883 ZEND_VM_NEXT_OPCODE();
7884 }
7885 }
7886
7887 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
7888 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
7889 if (jump_zv != NULL) {
7890 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
7891 ZEND_VM_CONTINUE();
7892 } else {
7893 /* default */
7894 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
7895 ZEND_VM_CONTINUE();
7896 }
7897 }
7898
ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7899 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7900 {
7901 USE_OPLINE
7902 zval *op, *jump_zv;
7903 HashTable *jumptable;
7904
7905 op = RT_CONSTANT(opline, opline->op1);
7906
7907 if (Z_TYPE_P(op) != IS_STRING) {
7908 if (IS_CONST == IS_CONST) {
7909 /* Wrong type, fall back to ZEND_CASE chain */
7910 ZEND_VM_NEXT_OPCODE();
7911 } else {
7912 ZVAL_DEREF(op);
7913 if (Z_TYPE_P(op) != IS_STRING) {
7914 /* Wrong type, fall back to ZEND_CASE chain */
7915 ZEND_VM_NEXT_OPCODE();
7916 }
7917 }
7918 }
7919
7920 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
7921 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
7922 if (jump_zv != NULL) {
7923 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
7924 ZEND_VM_CONTINUE();
7925 } else {
7926 /* default */
7927 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
7928 ZEND_VM_CONTINUE();
7929 }
7930 }
7931
ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7932 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7933 {
7934 USE_OPLINE
7935 zval *op, *jump_zv;
7936 HashTable *jumptable;
7937
7938 op = RT_CONSTANT(opline, opline->op1);
7939 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
7940
7941 match_try_again:
7942 if (Z_TYPE_P(op) == IS_LONG) {
7943 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
7944 } else if (Z_TYPE_P(op) == IS_STRING) {
7945 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST);
7946 } else if (Z_TYPE_P(op) == IS_REFERENCE) {
7947 op = Z_REFVAL_P(op);
7948 goto match_try_again;
7949 } else {
7950 if (UNEXPECTED((IS_CONST & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
7951 SAVE_OPLINE();
7952 op = ZVAL_UNDEFINED_OP1();
7953 if (UNEXPECTED(EG(exception))) {
7954 HANDLE_EXCEPTION();
7955 }
7956 goto match_try_again;
7957 }
7958
7959 goto default_branch;
7960 }
7961
7962 if (jump_zv != NULL) {
7963 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
7964 ZEND_VM_CONTINUE();
7965 } else {
7966 default_branch:
7967 /* default */
7968 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
7969 ZEND_VM_CONTINUE();
7970 }
7971 }
7972
ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)7973 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
7974 {
7975 USE_OPLINE
7976 zval *op1;
7977 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
7978 zval *result;
7979
7980 op1 = RT_CONSTANT(opline, opline->op1);
7981 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
7982 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CONST == IS_CONST);
7983 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
7984 zval_ptr_dtor_str(op1);
7985 }
7986 ZEND_VM_SMART_BRANCH(result, 0);
7987 }
7988
7989 if (opline->extended_value) {
7990 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
7991 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
7992 ZEND_VM_SMART_BRANCH(result, 0);
7993 }
7994 SAVE_OPLINE();
7995 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
7996 op1 = Z_REFVAL_P(op1);
7997 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
7998 result = zend_hash_find(ht, Z_STR_P(op1));
7999
8000 ZEND_VM_SMART_BRANCH(result, 0);
8001 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
8002 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
8003
8004 ZEND_VM_SMART_BRANCH(result, 0);
8005 }
8006 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8007 ZVAL_UNDEFINED_OP1();
8008 }
8009 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
8010 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8011 SAVE_OPLINE();
8012 ZVAL_UNDEFINED_OP1();
8013 if (UNEXPECTED(EG(exception) != NULL)) {
8014 HANDLE_EXCEPTION();
8015 }
8016 }
8017 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
8018 ZEND_VM_SMART_BRANCH(result, 0);
8019 } else {
8020 zend_string *key;
8021 zval key_tmp;
8022
8023 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
8024 op1 = Z_REFVAL_P(op1);
8025 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
8026 result = zend_hash_find(ht, Z_STR_P(op1));
8027
8028 ZEND_VM_SMART_BRANCH(result, 0);
8029 }
8030 }
8031
8032 SAVE_OPLINE();
8033 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
8034 ZVAL_STR(&key_tmp, key);
8035 if (zend_compare(op1, &key_tmp) == 0) {
8036
8037 ZEND_VM_SMART_BRANCH(1, 1);
8038 }
8039 } ZEND_HASH_FOREACH_END();
8040 }
8041
8042 ZEND_VM_SMART_BRANCH(0, 1);
8043 }
8044
ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8045 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8046 {
8047 USE_OPLINE
8048 zval *op1, *op2, *result;
8049 double d1, d2;
8050
8051 op1 = RT_CONSTANT(opline, opline->op1);
8052 op2 = EX_VAR(opline->op2.var);
8053 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8054 /* pass */
8055 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8056 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8057 result = EX_VAR(opline->result.var);
8058 fast_long_add_function(result, op1, op2);
8059 ZEND_VM_NEXT_OPCODE();
8060 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8061 d1 = (double)Z_LVAL_P(op1);
8062 d2 = Z_DVAL_P(op2);
8063 goto add_double;
8064 }
8065 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8066 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8067 d1 = Z_DVAL_P(op1);
8068 d2 = Z_DVAL_P(op2);
8069 add_double:
8070 result = EX_VAR(opline->result.var);
8071 ZVAL_DOUBLE(result, d1 + d2);
8072 ZEND_VM_NEXT_OPCODE();
8073 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8074 d1 = Z_DVAL_P(op1);
8075 d2 = (double)Z_LVAL_P(op2);
8076 goto add_double;
8077 }
8078 }
8079
8080 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8081 }
8082
ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8083 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8084 {
8085 USE_OPLINE
8086 zval *op1, *op2, *result;
8087 double d1, d2;
8088
8089 op1 = RT_CONSTANT(opline, opline->op1);
8090 op2 = EX_VAR(opline->op2.var);
8091 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8092 /* pass */
8093 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8094 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8095 result = EX_VAR(opline->result.var);
8096 fast_long_sub_function(result, op1, op2);
8097 ZEND_VM_NEXT_OPCODE();
8098 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8099 d1 = (double)Z_LVAL_P(op1);
8100 d2 = Z_DVAL_P(op2);
8101 goto sub_double;
8102 }
8103 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8104 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8105 d1 = Z_DVAL_P(op1);
8106 d2 = Z_DVAL_P(op2);
8107 sub_double:
8108 result = EX_VAR(opline->result.var);
8109 ZVAL_DOUBLE(result, d1 - d2);
8110 ZEND_VM_NEXT_OPCODE();
8111 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8112 d1 = Z_DVAL_P(op1);
8113 d2 = (double)Z_LVAL_P(op2);
8114 goto sub_double;
8115 }
8116 }
8117
8118 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8119 }
8120
ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8121 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8122 {
8123 USE_OPLINE
8124 zval *op1, *op2, *result;
8125
8126 op1 = RT_CONSTANT(opline, opline->op1);
8127 op2 = EX_VAR(opline->op2.var);
8128 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8129 /* pass */
8130 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8131 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8132 result = EX_VAR(opline->result.var);
8133 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
8134 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
8135 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
8136 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
8137 ZVAL_LONG(result, 0);
8138 } else {
8139 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
8140 }
8141 ZEND_VM_NEXT_OPCODE();
8142 }
8143 }
8144
8145 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8146 }
8147
ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8148 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8149 {
8150 USE_OPLINE
8151 zval *op1, *op2;
8152
8153 op1 = RT_CONSTANT(opline, opline->op1);
8154 op2 = EX_VAR(opline->op2.var);
8155 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8156 /* pass */
8157 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8158 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8159 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8160 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
8161 ZVAL_LONG(EX_VAR(opline->result.var),
8162 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
8163 ZEND_VM_NEXT_OPCODE();
8164 }
8165
8166 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8167 }
8168
ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8169 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8170 {
8171 USE_OPLINE
8172 zval *op1, *op2;
8173
8174 op1 = RT_CONSTANT(opline, opline->op1);
8175 op2 = EX_VAR(opline->op2.var);
8176 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8177 /* pass */
8178 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
8179 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
8180 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
8181 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
8182 ZEND_VM_NEXT_OPCODE();
8183 }
8184
8185 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8186 }
8187
ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8188 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8189 {
8190 USE_OPLINE
8191 zval *op1, *op2;
8192 double d1, d2;
8193
8194 op1 = RT_CONSTANT(opline, opline->op1);
8195 op2 = EX_VAR(opline->op2.var);
8196 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8197 /* pass */
8198 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8199 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8200 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8201 is_smaller_true:
8202 ZEND_VM_SMART_BRANCH_TRUE_NONE();
8203 } else {
8204 is_smaller_false:
8205 ZEND_VM_SMART_BRANCH_FALSE_NONE();
8206 }
8207 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8208 d1 = (double)Z_LVAL_P(op1);
8209 d2 = Z_DVAL_P(op2);
8210 goto is_smaller_double;
8211 }
8212 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8213 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8214 d1 = Z_DVAL_P(op1);
8215 d2 = Z_DVAL_P(op2);
8216 is_smaller_double:
8217 if (d1 < d2) {
8218 goto is_smaller_true;
8219 } else {
8220 goto is_smaller_false;
8221 }
8222 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8223 d1 = Z_DVAL_P(op1);
8224 d2 = (double)Z_LVAL_P(op2);
8225 goto is_smaller_double;
8226 }
8227 }
8228 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8229 }
8230
ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8231 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8232 {
8233 USE_OPLINE
8234 zval *op1, *op2;
8235 double d1, d2;
8236
8237 op1 = RT_CONSTANT(opline, opline->op1);
8238 op2 = EX_VAR(opline->op2.var);
8239 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8240 /* pass */
8241 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8242 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8243 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8244 is_smaller_true:
8245 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8246 } else {
8247 is_smaller_false:
8248 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8249 }
8250 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8251 d1 = (double)Z_LVAL_P(op1);
8252 d2 = Z_DVAL_P(op2);
8253 goto is_smaller_double;
8254 }
8255 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8256 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8257 d1 = Z_DVAL_P(op1);
8258 d2 = Z_DVAL_P(op2);
8259 is_smaller_double:
8260 if (d1 < d2) {
8261 goto is_smaller_true;
8262 } else {
8263 goto is_smaller_false;
8264 }
8265 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8266 d1 = Z_DVAL_P(op1);
8267 d2 = (double)Z_LVAL_P(op2);
8268 goto is_smaller_double;
8269 }
8270 }
8271 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8272 }
8273
ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8274 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8275 {
8276 USE_OPLINE
8277 zval *op1, *op2;
8278 double d1, d2;
8279
8280 op1 = RT_CONSTANT(opline, opline->op1);
8281 op2 = EX_VAR(opline->op2.var);
8282 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8283 /* pass */
8284 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8285 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8286 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
8287 is_smaller_true:
8288 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8289 } else {
8290 is_smaller_false:
8291 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8292 }
8293 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8294 d1 = (double)Z_LVAL_P(op1);
8295 d2 = Z_DVAL_P(op2);
8296 goto is_smaller_double;
8297 }
8298 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8299 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8300 d1 = Z_DVAL_P(op1);
8301 d2 = Z_DVAL_P(op2);
8302 is_smaller_double:
8303 if (d1 < d2) {
8304 goto is_smaller_true;
8305 } else {
8306 goto is_smaller_false;
8307 }
8308 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8309 d1 = Z_DVAL_P(op1);
8310 d2 = (double)Z_LVAL_P(op2);
8311 goto is_smaller_double;
8312 }
8313 }
8314 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8315 }
8316
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8317 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8318 {
8319 USE_OPLINE
8320 zval *op1, *op2;
8321 double d1, d2;
8322
8323 op1 = RT_CONSTANT(opline, opline->op1);
8324 op2 = EX_VAR(opline->op2.var);
8325 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8326 /* pass */
8327 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8328 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8329 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8330 is_smaller_or_equal_true:
8331 ZEND_VM_SMART_BRANCH_TRUE_NONE();
8332 ZVAL_TRUE(EX_VAR(opline->result.var));
8333 ZEND_VM_NEXT_OPCODE();
8334 } else {
8335 is_smaller_or_equal_false:
8336 ZEND_VM_SMART_BRANCH_FALSE_NONE();
8337 ZVAL_FALSE(EX_VAR(opline->result.var));
8338 ZEND_VM_NEXT_OPCODE();
8339 }
8340 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8341 d1 = (double)Z_LVAL_P(op1);
8342 d2 = Z_DVAL_P(op2);
8343 goto is_smaller_or_equal_double;
8344 }
8345 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8346 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8347 d1 = Z_DVAL_P(op1);
8348 d2 = Z_DVAL_P(op2);
8349 is_smaller_or_equal_double:
8350 if (d1 <= d2) {
8351 goto is_smaller_or_equal_true;
8352 } else {
8353 goto is_smaller_or_equal_false;
8354 }
8355 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8356 d1 = Z_DVAL_P(op1);
8357 d2 = (double)Z_LVAL_P(op2);
8358 goto is_smaller_or_equal_double;
8359 }
8360 }
8361 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8362 }
8363
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8364 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8365 {
8366 USE_OPLINE
8367 zval *op1, *op2;
8368 double d1, d2;
8369
8370 op1 = RT_CONSTANT(opline, opline->op1);
8371 op2 = EX_VAR(opline->op2.var);
8372 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8373 /* pass */
8374 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8375 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8376 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8377 is_smaller_or_equal_true:
8378 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
8379 ZVAL_TRUE(EX_VAR(opline->result.var));
8380 ZEND_VM_NEXT_OPCODE();
8381 } else {
8382 is_smaller_or_equal_false:
8383 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
8384 ZVAL_FALSE(EX_VAR(opline->result.var));
8385 ZEND_VM_NEXT_OPCODE();
8386 }
8387 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8388 d1 = (double)Z_LVAL_P(op1);
8389 d2 = Z_DVAL_P(op2);
8390 goto is_smaller_or_equal_double;
8391 }
8392 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8393 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8394 d1 = Z_DVAL_P(op1);
8395 d2 = Z_DVAL_P(op2);
8396 is_smaller_or_equal_double:
8397 if (d1 <= d2) {
8398 goto is_smaller_or_equal_true;
8399 } else {
8400 goto is_smaller_or_equal_false;
8401 }
8402 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8403 d1 = Z_DVAL_P(op1);
8404 d2 = (double)Z_LVAL_P(op2);
8405 goto is_smaller_or_equal_double;
8406 }
8407 }
8408 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8409 }
8410
ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8411 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8412 {
8413 USE_OPLINE
8414 zval *op1, *op2;
8415 double d1, d2;
8416
8417 op1 = RT_CONSTANT(opline, opline->op1);
8418 op2 = EX_VAR(opline->op2.var);
8419 if (1 && IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8420 /* pass */
8421 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
8422 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8423 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
8424 is_smaller_or_equal_true:
8425 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
8426 ZVAL_TRUE(EX_VAR(opline->result.var));
8427 ZEND_VM_NEXT_OPCODE();
8428 } else {
8429 is_smaller_or_equal_false:
8430 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
8431 ZVAL_FALSE(EX_VAR(opline->result.var));
8432 ZEND_VM_NEXT_OPCODE();
8433 }
8434 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8435 d1 = (double)Z_LVAL_P(op1);
8436 d2 = Z_DVAL_P(op2);
8437 goto is_smaller_or_equal_double;
8438 }
8439 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
8440 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
8441 d1 = Z_DVAL_P(op1);
8442 d2 = Z_DVAL_P(op2);
8443 is_smaller_or_equal_double:
8444 if (d1 <= d2) {
8445 goto is_smaller_or_equal_true;
8446 } else {
8447 goto is_smaller_or_equal_false;
8448 }
8449 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
8450 d1 = Z_DVAL_P(op1);
8451 d2 = (double)Z_LVAL_P(op2);
8452 goto is_smaller_or_equal_double;
8453 }
8454 }
8455 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
8456 }
8457
ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8458 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8459 {
8460 zend_class_entry *ce, *scope;
8461 zend_class_constant *c;
8462 zval *value, *zv, *constant_zv;
8463 zend_string *constant_name;
8464 USE_OPLINE
8465
8466 SAVE_OPLINE();
8467
8468 do {
8469 if (IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
8470 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
8471 value = CACHED_PTR(opline->extended_value + sizeof(void*));
8472 break;
8473 }
8474 }
8475 if (IS_CONST == IS_CONST) {
8476 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
8477 ce = CACHED_PTR(opline->extended_value);
8478 } else {
8479 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);
8480 if (UNEXPECTED(ce == NULL)) {
8481 ZVAL_UNDEF(EX_VAR(opline->result.var));
8482 FREE_OP(opline->op2_type, opline->op2.var);
8483 HANDLE_EXCEPTION();
8484 }
8485 CACHE_PTR(opline->extended_value, ce);
8486 }
8487 } else if (IS_CONST == IS_UNUSED) {
8488 ce = zend_fetch_class(NULL, opline->op1.num);
8489 if (UNEXPECTED(ce == NULL)) {
8490 ZVAL_UNDEF(EX_VAR(opline->result.var));
8491 FREE_OP(opline->op2_type, opline->op2.var);
8492 HANDLE_EXCEPTION();
8493 }
8494 } else {
8495 ce = Z_CE_P(EX_VAR(opline->op1.var));
8496 }
8497 if (IS_CONST != IS_CONST
8498 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8499 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
8500 value = CACHED_PTR(opline->extended_value + sizeof(void*));
8501 break;
8502 }
8503
8504 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
8505 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
8506 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
8507 ZVAL_UNDEF(EX_VAR(opline->result.var));
8508 FREE_OP(opline->op2_type, opline->op2.var);
8509 HANDLE_EXCEPTION();
8510 }
8511 constant_name = Z_STR_P(constant_zv);
8512 /* Magic 'class' for constant OP2 is caught at compile-time */
8513 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
8514 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
8515 FREE_OP(opline->op2_type, opline->op2.var);
8516 ZEND_VM_NEXT_OPCODE();
8517 }
8518 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
8519 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
8520 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
8521
8522 if (EXPECTED(zv != NULL)) {
8523 c = Z_PTR_P(zv);
8524 scope = EX(func)->op_array.scope;
8525 if (!zend_verify_const_access(c, scope)) {
8526 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));
8527 ZVAL_UNDEF(EX_VAR(opline->result.var));
8528 FREE_OP(opline->op2_type, opline->op2.var);
8529 HANDLE_EXCEPTION();
8530 }
8531
8532 if (ce->ce_flags & ZEND_ACC_TRAIT) {
8533 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8534 ZVAL_UNDEF(EX_VAR(opline->result.var));
8535 FREE_OP(opline->op2_type, opline->op2.var);
8536 HANDLE_EXCEPTION();
8537 }
8538
8539 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
8540 if (UNEXPECTED(is_constant_deprecated)) {
8541 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8542
8543 if (EG(exception)) {
8544 ZVAL_UNDEF(EX_VAR(opline->result.var));
8545 FREE_OP(opline->op2_type, opline->op2.var);
8546 HANDLE_EXCEPTION();
8547 }
8548 }
8549
8550 value = &c->value;
8551 // Enums require loading of all class constants to build the backed enum table
8552 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)) {
8553 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
8554 ZVAL_UNDEF(EX_VAR(opline->result.var));
8555 FREE_OP(opline->op2_type, opline->op2.var);
8556 HANDLE_EXCEPTION();
8557 }
8558 }
8559 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
8560 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
8561 ZVAL_UNDEF(EX_VAR(opline->result.var));
8562 FREE_OP(opline->op2_type, opline->op2.var);
8563 HANDLE_EXCEPTION();
8564 }
8565 }
8566 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
8567 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
8568 }
8569 } else {
8570 zend_throw_error(NULL, "Undefined constant %s::%s",
8571 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
8572 ZVAL_UNDEF(EX_VAR(opline->result.var));
8573 FREE_OP(opline->op2_type, opline->op2.var);
8574 HANDLE_EXCEPTION();
8575 }
8576 } while (0);
8577
8578 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
8579
8580 FREE_OP(opline->op2_type, opline->op2.var);
8581 ZEND_VM_NEXT_OPCODE();
8582 }
8583
ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8584 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8585 {
8586 USE_OPLINE
8587 zval *op1, *op2, *result;
8588
8589 op1 = RT_CONSTANT(opline, opline->op1);
8590 op2 = EX_VAR(opline->op2.var);
8591 result = EX_VAR(opline->result.var);
8592 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
8593 ZEND_VM_NEXT_OPCODE();
8594 }
8595
ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8596 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8597 {
8598 USE_OPLINE
8599 zval *op1, *op2, *result;
8600
8601 op1 = RT_CONSTANT(opline, opline->op1);
8602 op2 = EX_VAR(opline->op2.var);
8603 result = EX_VAR(opline->result.var);
8604 fast_long_sub_function(result, op1, op2);
8605 ZEND_VM_NEXT_OPCODE();
8606 }
8607
ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8608 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8609 {
8610 USE_OPLINE
8611 zval *op1, *op2, *result;
8612
8613 op1 = RT_CONSTANT(opline, opline->op1);
8614 op2 = EX_VAR(opline->op2.var);
8615 result = EX_VAR(opline->result.var);
8616 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
8617 ZEND_VM_NEXT_OPCODE();
8618 }
8619
ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8620 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8621 {
8622 USE_OPLINE
8623 zval *op1, *op2;
8624 bool result;
8625
8626 op1 = RT_CONSTANT(opline, opline->op1);
8627 op2 = EX_VAR(opline->op2.var);
8628 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8629 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8630 }
8631
ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8632 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8633 {
8634 USE_OPLINE
8635 zval *op1, *op2;
8636 bool result;
8637
8638 op1 = RT_CONSTANT(opline, opline->op1);
8639 op2 = EX_VAR(opline->op2.var);
8640 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8641 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8642 }
8643
ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8644 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8645 {
8646 USE_OPLINE
8647 zval *op1, *op2;
8648 bool result;
8649
8650 op1 = RT_CONSTANT(opline, opline->op1);
8651 op2 = EX_VAR(opline->op2.var);
8652 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
8653 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8654 }
8655
ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8656 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8657 {
8658 USE_OPLINE
8659 zval *op1, *op2;
8660 bool result;
8661
8662 op1 = RT_CONSTANT(opline, opline->op1);
8663 op2 = EX_VAR(opline->op2.var);
8664 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8665 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8666 }
8667
ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8668 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8669 {
8670 USE_OPLINE
8671 zval *op1, *op2;
8672 bool result;
8673
8674 op1 = RT_CONSTANT(opline, opline->op1);
8675 op2 = EX_VAR(opline->op2.var);
8676 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8677 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8678 }
8679
ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8680 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8681 {
8682 USE_OPLINE
8683 zval *op1, *op2;
8684 bool result;
8685
8686 op1 = RT_CONSTANT(opline, opline->op1);
8687 op2 = EX_VAR(opline->op2.var);
8688 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
8689 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8690 }
8691
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8692 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8693 {
8694 USE_OPLINE
8695 zval *op1, *op2;
8696 bool result;
8697
8698 op1 = RT_CONSTANT(opline, opline->op1);
8699 op2 = EX_VAR(opline->op2.var);
8700 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8701 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8702 }
8703
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8704 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)
8705 {
8706 USE_OPLINE
8707 zval *op1, *op2;
8708 bool result;
8709
8710 op1 = RT_CONSTANT(opline, opline->op1);
8711 op2 = EX_VAR(opline->op2.var);
8712 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8713 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8714 }
8715
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8716 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)
8717 {
8718 USE_OPLINE
8719 zval *op1, *op2;
8720 bool result;
8721
8722 op1 = RT_CONSTANT(opline, opline->op1);
8723 op2 = EX_VAR(opline->op2.var);
8724 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
8725 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8726 }
8727
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8728 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8729 {
8730 USE_OPLINE
8731 zval *op1, *op2;
8732 bool result;
8733
8734 op1 = RT_CONSTANT(opline, opline->op1);
8735 op2 = EX_VAR(opline->op2.var);
8736 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
8737 ZEND_VM_SMART_BRANCH_NONE(result, 0);
8738 }
8739
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8740 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)
8741 {
8742 USE_OPLINE
8743 zval *op1, *op2;
8744 bool result;
8745
8746 op1 = RT_CONSTANT(opline, opline->op1);
8747 op2 = EX_VAR(opline->op2.var);
8748 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
8749 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
8750 }
8751
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8752 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)
8753 {
8754 USE_OPLINE
8755 zval *op1, *op2;
8756 bool result;
8757
8758 op1 = RT_CONSTANT(opline, opline->op1);
8759 op2 = EX_VAR(opline->op2.var);
8760 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
8761 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
8762 }
8763
ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8764 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8765 {
8766 USE_OPLINE
8767 zval *container, *dim, *value;
8768 zend_long offset;
8769 HashTable *ht;
8770
8771 container = RT_CONSTANT(opline, opline->op1);
8772 dim = EX_VAR(opline->op2.var);
8773 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
8774 fetch_dim_r_index_array:
8775 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
8776 offset = Z_LVAL_P(dim);
8777 } else {
8778 SAVE_OPLINE();
8779 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
8780
8781 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8782 }
8783 ht = Z_ARRVAL_P(container);
8784 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
8785 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
8786 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
8787 SAVE_OPLINE();
8788
8789 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8790 } else {
8791 ZEND_VM_NEXT_OPCODE();
8792 }
8793 } else if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
8794 container = Z_REFVAL_P(container);
8795 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
8796 goto fetch_dim_r_index_array;
8797 } else {
8798 goto fetch_dim_r_index_slow;
8799 }
8800 } else {
8801 fetch_dim_r_index_slow:
8802 SAVE_OPLINE();
8803 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
8804 dim++;
8805 }
8806 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
8807
8808 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8809 }
8810
8811 fetch_dim_r_index_undef:
8812 ZVAL_NULL(EX_VAR(opline->result.var));
8813 SAVE_OPLINE();
8814 zend_undefined_offset(offset);
8815
8816 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8817 }
8818
ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8819 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8820 {
8821 USE_OPLINE
8822 zval *op1, *op2;
8823
8824 SAVE_OPLINE();
8825 op1 = RT_CONSTANT(opline, opline->op1);
8826 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
8827 div_function(EX_VAR(opline->result.var), op1, op2);
8828
8829 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
8830 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8831 }
8832
ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8833 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8834 {
8835 USE_OPLINE
8836 zval *op1, *op2;
8837
8838 SAVE_OPLINE();
8839 op1 = RT_CONSTANT(opline, opline->op1);
8840 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
8841 pow_function(EX_VAR(opline->result.var), op1, op2);
8842
8843 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
8844 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8845 }
8846
ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8847 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8848 {
8849 USE_OPLINE
8850 zval *op1, *op2;
8851
8852 op1 = RT_CONSTANT(opline, opline->op1);
8853 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
8854
8855 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
8856 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
8857 zend_string *op1_str = Z_STR_P(op1);
8858 zend_string *op2_str = Z_STR_P(op2);
8859 zend_string *str;
8860 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
8861
8862 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
8863 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
8864 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
8865 } else {
8866 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
8867 }
8868 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
8869 zend_string_release_ex(op1_str, 0);
8870 }
8871 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
8872 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
8873 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
8874 } else {
8875 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
8876 }
8877 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
8878 zend_string_release_ex(op2_str, 0);
8879 }
8880 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
8881 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
8882 size_t len = ZSTR_LEN(op1_str);
8883
8884 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
8885 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
8886 }
8887 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
8888 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
8889 GC_ADD_FLAGS(str, flags);
8890 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
8891 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
8892 zend_string_release_ex(op2_str, 0);
8893 }
8894 } else {
8895 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
8896 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
8897 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
8898 GC_ADD_FLAGS(str, flags);
8899 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
8900 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
8901 zend_string_release_ex(op1_str, 0);
8902 }
8903 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
8904 zend_string_release_ex(op2_str, 0);
8905 }
8906 }
8907 ZEND_VM_NEXT_OPCODE();
8908 } else {
8909 SAVE_OPLINE();
8910
8911 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
8912 op1 = ZVAL_UNDEFINED_OP1();
8913 }
8914 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
8915 op2 = ZVAL_UNDEFINED_OP2();
8916 }
8917 concat_function(EX_VAR(opline->result.var), op1, op2);
8918
8919 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
8920 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8921 }
8922 }
8923
ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8924 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8925 {
8926 USE_OPLINE
8927 zval *op1, *op2;
8928
8929 SAVE_OPLINE();
8930 op1 = RT_CONSTANT(opline, opline->op1);
8931 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
8932 compare_function(EX_VAR(opline->result.var), op1, op2);
8933
8934 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
8935 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8936 }
8937
ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8938 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8939 {
8940 USE_OPLINE
8941 zval *container, *dim, *value;
8942
8943 SAVE_OPLINE();
8944 container = RT_CONSTANT(opline, opline->op1);
8945 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
8946 if (IS_CONST != IS_CONST) {
8947 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
8948 fetch_dim_r_array:
8949 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
8950 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
8951 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
8952 container = Z_REFVAL_P(container);
8953 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
8954 goto fetch_dim_r_array;
8955 } else {
8956 goto fetch_dim_r_slow;
8957 }
8958 } else {
8959 fetch_dim_r_slow:
8960 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
8961 dim++;
8962 }
8963 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
8964 }
8965 } else {
8966 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
8967 }
8968 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
8969
8970 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8971 }
8972
ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8973 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8974 {
8975 USE_OPLINE
8976 zval *container;
8977
8978 SAVE_OPLINE();
8979 container = RT_CONSTANT(opline, opline->op1);
8980 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);
8981 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
8982
8983 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
8984 }
8985
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)8986 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
8987 {
8988 #if 0
8989 USE_OPLINE
8990 #endif
8991
8992 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
8993 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
8994 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
8995 }
8996 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
8997 } else {
8998 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
8999 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9000 }
9001 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9002 }
9003 }
9004
ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9005 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9006 {
9007 USE_OPLINE
9008 zval *container;
9009 void **cache_slot = NULL;
9010
9011 SAVE_OPLINE();
9012 container = RT_CONSTANT(opline, opline->op1);
9013
9014 if (IS_CONST == IS_CONST ||
9015 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9016 do {
9017 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9018 container = Z_REFVAL_P(container);
9019 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9020 break;
9021 }
9022 }
9023 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
9024 ZVAL_UNDEFINED_OP1();
9025 }
9026 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9027 ZVAL_NULL(EX_VAR(opline->result.var));
9028 goto fetch_obj_r_finish;
9029 } while (0);
9030 }
9031
9032 /* here we are sure we are dealing with an object */
9033 do {
9034 zend_object *zobj = Z_OBJ_P(container);
9035 zend_string *name, *tmp_name;
9036 zval *retval;
9037
9038 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9039 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
9040
9041 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9042 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9043
9044 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9045 retval = OBJ_PROP(zobj, prop_offset);
9046 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
9047 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9048 goto fetch_obj_r_copy;
9049 } else {
9050 fetch_obj_r_fast_copy:
9051 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9052 ZEND_VM_NEXT_OPCODE();
9053 }
9054 }
9055 } else if (EXPECTED(zobj->properties != NULL)) {
9056 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9057 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9058 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9059
9060 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9061 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9062
9063 if (EXPECTED(p->key == name) ||
9064 (EXPECTED(p->h == ZSTR_H(name)) &&
9065 EXPECTED(p->key != NULL) &&
9066 EXPECTED(zend_string_equal_content(p->key, name)))) {
9067 retval = &p->val;
9068 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9069 goto fetch_obj_r_copy;
9070 } else {
9071 goto fetch_obj_r_fast_copy;
9072 }
9073 }
9074 }
9075 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9076 }
9077 retval = zend_hash_find_known_hash(zobj->properties, name);
9078 if (EXPECTED(retval)) {
9079 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9080 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9081 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9082 goto fetch_obj_r_copy;
9083 } else {
9084 goto fetch_obj_r_fast_copy;
9085 }
9086 }
9087 }
9088 }
9089 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9090 } else {
9091 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9092 if (UNEXPECTED(!name)) {
9093 ZVAL_UNDEF(EX_VAR(opline->result.var));
9094 break;
9095 }
9096 }
9097
9098 #if ZEND_DEBUG
9099 /* For non-standard object handlers, verify a declared property type in debug builds.
9100 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
9101 zend_property_info *prop_info = NULL;
9102 if (zobj->handlers->read_property != zend_std_read_property) {
9103 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
9104 }
9105 #endif
9106 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
9107 #if ZEND_DEBUG
9108 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
9109 && ZEND_TYPE_IS_SET(prop_info->type)) {
9110 ZVAL_OPT_DEREF(retval);
9111 zend_verify_property_type(prop_info, retval, /* strict */ true);
9112 }
9113 #endif
9114
9115 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9116 zend_tmp_string_release(tmp_name);
9117 }
9118
9119 if (retval != EX_VAR(opline->result.var)) {
9120 fetch_obj_r_copy:
9121 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9122 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9123 zend_unwrap_reference(retval);
9124 }
9125 } while (0);
9126
9127 fetch_obj_r_finish:
9128 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9129
9130 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9131 }
9132
ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9133 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9134 {
9135 USE_OPLINE
9136 zval *container;
9137 void **cache_slot = NULL;
9138
9139 SAVE_OPLINE();
9140 container = RT_CONSTANT(opline, opline->op1);
9141
9142 if (IS_CONST == IS_CONST ||
9143 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9144 do {
9145 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9146 container = Z_REFVAL_P(container);
9147 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
9148 break;
9149 }
9150 }
9151 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
9152 ZVAL_UNDEFINED_OP2();
9153 }
9154 ZVAL_NULL(EX_VAR(opline->result.var));
9155 goto fetch_obj_is_finish;
9156 } while (0);
9157 }
9158
9159 /* here we are sure we are dealing with an object */
9160 do {
9161 zend_object *zobj = Z_OBJ_P(container);
9162 zend_string *name, *tmp_name;
9163 zval *retval;
9164
9165 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9166 cache_slot = CACHE_ADDR(opline->extended_value);
9167
9168 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
9169 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
9170
9171 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
9172 retval = OBJ_PROP(zobj, prop_offset);
9173 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
9174 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9175 goto fetch_obj_is_copy;
9176 } else {
9177 fetch_obj_is_fast_copy:
9178 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9179 ZEND_VM_NEXT_OPCODE();
9180 }
9181 }
9182 } else if (EXPECTED(zobj->properties != NULL)) {
9183 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9184 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
9185 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
9186
9187 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
9188 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
9189
9190 if (EXPECTED(p->key == name) ||
9191 (EXPECTED(p->h == ZSTR_H(name)) &&
9192 EXPECTED(p->key != NULL) &&
9193 EXPECTED(zend_string_equal_content(p->key, name)))) {
9194 retval = &p->val;
9195 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9196 goto fetch_obj_is_copy;
9197 } else {
9198 goto fetch_obj_is_fast_copy;
9199 }
9200 }
9201 }
9202 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
9203 }
9204 retval = zend_hash_find_known_hash(zobj->properties, name);
9205 if (EXPECTED(retval)) {
9206 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
9207 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
9208 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
9209 goto fetch_obj_is_copy;
9210 } else {
9211 goto fetch_obj_is_fast_copy;
9212 }
9213 }
9214 }
9215 }
9216 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
9217 } else {
9218 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
9219 if (UNEXPECTED(!name)) {
9220 ZVAL_UNDEF(EX_VAR(opline->result.var));
9221 break;
9222 }
9223 }
9224
9225 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
9226
9227 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9228 zend_tmp_string_release(tmp_name);
9229 }
9230
9231 if (retval != EX_VAR(opline->result.var)) {
9232 fetch_obj_is_copy:
9233 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
9234 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
9235 zend_unwrap_reference(retval);
9236 }
9237 } while (0);
9238
9239 fetch_obj_is_finish:
9240 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9241
9242 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9243 }
9244
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9245 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9246 {
9247 #if 0
9248 USE_OPLINE
9249 #endif
9250
9251 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
9252 /* Behave like FETCH_OBJ_W */
9253 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
9254 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9255 }
9256 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9257 } else {
9258 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9259 }
9260 }
9261
ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9262 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9263 {
9264 USE_OPLINE
9265 zval *container;
9266
9267 SAVE_OPLINE();
9268 container = RT_CONSTANT(opline, opline->op1);
9269 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);
9270 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9271 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9272 }
9273
ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9274 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9275 {
9276 USE_OPLINE
9277 zval *op1, *op2;
9278 zend_string *op1_str, *op2_str, *str;
9279
9280
9281 op1 = RT_CONSTANT(opline, opline->op1);
9282 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9283 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
9284 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
9285 zend_string *op1_str = Z_STR_P(op1);
9286 zend_string *op2_str = Z_STR_P(op2);
9287 zend_string *str;
9288 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
9289
9290 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9291 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
9292 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
9293 } else {
9294 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9295 }
9296 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9297 zend_string_release_ex(op1_str, 0);
9298 }
9299 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9300 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
9301 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
9302 } else {
9303 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9304 }
9305 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9306 zend_string_release_ex(op2_str, 0);
9307 }
9308 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
9309 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
9310 size_t len = ZSTR_LEN(op1_str);
9311
9312 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
9313 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9314 GC_ADD_FLAGS(str, flags);
9315 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9316 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9317 zend_string_release_ex(op2_str, 0);
9318 }
9319 } else {
9320 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9321 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9322 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9323 GC_ADD_FLAGS(str, flags);
9324 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9325 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
9326 zend_string_release_ex(op1_str, 0);
9327 }
9328 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
9329 zend_string_release_ex(op2_str, 0);
9330 }
9331 }
9332 ZEND_VM_NEXT_OPCODE();
9333 }
9334
9335 SAVE_OPLINE();
9336 if (IS_CONST == IS_CONST) {
9337 op1_str = Z_STR_P(op1);
9338 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
9339 op1_str = zend_string_copy(Z_STR_P(op1));
9340 } else {
9341 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
9342 ZVAL_UNDEFINED_OP1();
9343 }
9344 op1_str = zval_get_string_func(op1);
9345 }
9346 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9347 op2_str = Z_STR_P(op2);
9348 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
9349 op2_str = zend_string_copy(Z_STR_P(op2));
9350 } else {
9351 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
9352 ZVAL_UNDEFINED_OP2();
9353 }
9354 op2_str = zval_get_string_func(op2);
9355 }
9356 do {
9357 if (IS_CONST != IS_CONST) {
9358 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
9359 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9360 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
9361 GC_ADDREF(op2_str);
9362 }
9363 }
9364 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
9365 zend_string_release_ex(op1_str, 0);
9366 break;
9367 }
9368 }
9369 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9370 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
9371 if (IS_CONST == IS_CONST) {
9372 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
9373 GC_ADDREF(op1_str);
9374 }
9375 }
9376 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
9377 zend_string_release_ex(op2_str, 0);
9378 break;
9379 }
9380 }
9381 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
9382 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
9383 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
9384
9385 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
9386 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
9387 if (IS_CONST != IS_CONST) {
9388 zend_string_release_ex(op1_str, 0);
9389 }
9390 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9391 zend_string_release_ex(op2_str, 0);
9392 }
9393 } while (0);
9394
9395 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9396 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9397 }
9398
ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9399 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9400 {
9401 USE_OPLINE
9402 zval *function_name;
9403 zval *object;
9404 zend_function *fbc;
9405 zend_class_entry *called_scope;
9406 zend_object *obj;
9407 zend_execute_data *call;
9408 uint32_t call_info;
9409
9410 SAVE_OPLINE();
9411
9412 object = RT_CONSTANT(opline, opline->op1);
9413
9414 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9415 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9416 }
9417
9418 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
9419 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9420 do {
9421 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
9422 function_name = Z_REFVAL_P(function_name);
9423 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
9424 break;
9425 }
9426 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
9427 ZVAL_UNDEFINED_OP2();
9428 if (UNEXPECTED(EG(exception) != NULL)) {
9429
9430 HANDLE_EXCEPTION();
9431 }
9432 }
9433 zend_throw_error(NULL, "Method name must be a string");
9434 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9435
9436 HANDLE_EXCEPTION();
9437 } while (0);
9438 }
9439
9440 if (IS_CONST == IS_UNUSED) {
9441 obj = Z_OBJ_P(object);
9442 } else {
9443 do {
9444 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9445 obj = Z_OBJ_P(object);
9446 } else {
9447 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
9448 zend_reference *ref = Z_REF_P(object);
9449
9450 object = &ref->val;
9451 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
9452 obj = Z_OBJ_P(object);
9453 if (IS_CONST & IS_VAR) {
9454 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
9455 efree_size(ref, sizeof(zend_reference));
9456 } else {
9457 Z_ADDREF_P(object);
9458 }
9459 }
9460 break;
9461 }
9462 }
9463 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
9464 object = ZVAL_UNDEFINED_OP1();
9465 if (UNEXPECTED(EG(exception) != NULL)) {
9466 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9467 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9468 }
9469 HANDLE_EXCEPTION();
9470 }
9471 }
9472 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9473 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9474 }
9475 zend_invalid_method_call(object, function_name);
9476 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9477
9478 HANDLE_EXCEPTION();
9479 }
9480 } while (0);
9481 }
9482
9483 called_scope = obj->ce;
9484
9485 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9486 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
9487 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9488 } else {
9489 zend_object *orig_obj = obj;
9490
9491 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9492 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9493 }
9494
9495 /* First, locate the function. */
9496 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));
9497 if (UNEXPECTED(fbc == NULL)) {
9498 if (EXPECTED(!EG(exception))) {
9499 zend_undefined_method(obj->ce, Z_STR_P(function_name));
9500 }
9501 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9502 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
9503 zend_objects_store_del(orig_obj);
9504 }
9505 HANDLE_EXCEPTION();
9506 }
9507 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9508 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
9509 EXPECTED(obj == orig_obj)) {
9510 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
9511 }
9512 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
9513 GC_ADDREF(obj); /* For $this pointer */
9514 if (GC_DELREF(orig_obj) == 0) {
9515 zend_objects_store_del(orig_obj);
9516 }
9517 }
9518 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9519 init_func_run_time_cache(&fbc->op_array);
9520 }
9521 }
9522
9523 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9524 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9525 }
9526
9527 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9528 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
9529 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
9530 zend_objects_store_del(obj);
9531 if (UNEXPECTED(EG(exception))) {
9532 HANDLE_EXCEPTION();
9533 }
9534 }
9535 /* call static method */
9536 obj = (zend_object*)called_scope;
9537 call_info = ZEND_CALL_NESTED_FUNCTION;
9538 } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
9539 if (IS_CONST == IS_CV) {
9540 GC_ADDREF(obj); /* For $this pointer */
9541 }
9542 /* CV may be changed indirectly (e.g. when it's a reference) */
9543 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
9544 }
9545
9546 call = zend_vm_stack_push_call_frame(call_info,
9547 fbc, opline->extended_value, obj);
9548 call->prev_execute_data = EX(call);
9549 EX(call) = call;
9550
9551 ZEND_VM_NEXT_OPCODE();
9552 }
9553
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9554 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9555 {
9556 USE_OPLINE
9557 zval *function_name;
9558 zend_class_entry *ce;
9559 uint32_t call_info;
9560 zend_function *fbc;
9561 zend_execute_data *call;
9562
9563 SAVE_OPLINE();
9564
9565 if (IS_CONST == IS_CONST) {
9566 /* no function found. try a static method in class */
9567 ce = CACHED_PTR(opline->result.num);
9568 if (UNEXPECTED(ce == NULL)) {
9569 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);
9570 if (UNEXPECTED(ce == NULL)) {
9571 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9572 HANDLE_EXCEPTION();
9573 }
9574 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9575 CACHE_PTR(opline->result.num, ce);
9576 }
9577 }
9578 } else if (IS_CONST == IS_UNUSED) {
9579 ce = zend_fetch_class(NULL, opline->op1.num);
9580 if (UNEXPECTED(ce == NULL)) {
9581 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9582 HANDLE_EXCEPTION();
9583 }
9584 } else {
9585 ce = Z_CE_P(EX_VAR(opline->op1.var));
9586 }
9587
9588 if (IS_CONST == IS_CONST &&
9589 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9590 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
9591 /* nothing to do */
9592 } else if (IS_CONST != IS_CONST &&
9593 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
9594 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
9595 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
9596 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
9597 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9598 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9599 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
9600 do {
9601 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
9602 function_name = Z_REFVAL_P(function_name);
9603 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
9604 break;
9605 }
9606 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
9607 ZVAL_UNDEFINED_OP2();
9608 if (UNEXPECTED(EG(exception) != NULL)) {
9609 HANDLE_EXCEPTION();
9610 }
9611 }
9612 zend_throw_error(NULL, "Method name must be a string");
9613 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9614 HANDLE_EXCEPTION();
9615 } while (0);
9616 }
9617 }
9618
9619 if (ce->get_static_method) {
9620 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
9621 } else {
9622 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));
9623 }
9624 if (UNEXPECTED(fbc == NULL)) {
9625 if (EXPECTED(!EG(exception))) {
9626 zend_undefined_method(ce, Z_STR_P(function_name));
9627 }
9628 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9629 HANDLE_EXCEPTION();
9630 }
9631 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
9632 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
9633 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
9634 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
9635 }
9636 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9637 init_func_run_time_cache(&fbc->op_array);
9638 }
9639 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9640 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9641 }
9642 } else {
9643 if (UNEXPECTED(ce->constructor == NULL)) {
9644 zend_throw_error(NULL, "Cannot call constructor");
9645 HANDLE_EXCEPTION();
9646 }
9647 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
9648 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
9649 HANDLE_EXCEPTION();
9650 }
9651 fbc = ce->constructor;
9652 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
9653 init_func_run_time_cache(&fbc->op_array);
9654 }
9655 }
9656
9657 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
9658 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
9659 ce = (zend_class_entry*)Z_OBJ(EX(This));
9660 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
9661 } else {
9662 zend_non_static_method_call(fbc);
9663 HANDLE_EXCEPTION();
9664 }
9665 } else {
9666 /* previous opcode is ZEND_FETCH_CLASS */
9667 if (IS_CONST == IS_UNUSED
9668 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
9669 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
9670 if (Z_TYPE(EX(This)) == IS_OBJECT) {
9671 ce = Z_OBJCE(EX(This));
9672 } else {
9673 ce = Z_CE(EX(This));
9674 }
9675 }
9676 call_info = ZEND_CALL_NESTED_FUNCTION;
9677 }
9678
9679 call = zend_vm_stack_push_call_frame(call_info,
9680 fbc, opline->extended_value, ce);
9681 call->prev_execute_data = EX(call);
9682 EX(call) = call;
9683
9684 ZEND_VM_NEXT_OPCODE();
9685 }
9686
ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9687 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9688 {
9689 USE_OPLINE
9690 zval *function_name;
9691 zend_fcall_info_cache fcc;
9692 char *error = NULL;
9693 zend_function *func;
9694 void *object_or_called_scope;
9695 zend_execute_data *call;
9696 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
9697
9698 SAVE_OPLINE();
9699 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9700 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
9701 ZEND_ASSERT(!error);
9702 func = fcc.function_handler;
9703 object_or_called_scope = fcc.called_scope;
9704 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
9705 /* Delay closure destruction until its invocation */
9706 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
9707 call_info |= ZEND_CALL_CLOSURE;
9708 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
9709 call_info |= ZEND_CALL_FAKE_CLOSURE;
9710 }
9711 if (fcc.object) {
9712 object_or_called_scope = fcc.object;
9713 call_info |= ZEND_CALL_HAS_THIS;
9714 }
9715 } else if (fcc.object) {
9716 GC_ADDREF(fcc.object); /* For $this pointer */
9717 object_or_called_scope = fcc.object;
9718 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
9719 }
9720
9721 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9722 if (((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
9723 if (call_info & ZEND_CALL_CLOSURE) {
9724 zend_object_release(ZEND_CLOSURE_OBJECT(func));
9725 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
9726 zend_object_release(fcc.object);
9727 }
9728 HANDLE_EXCEPTION();
9729 }
9730
9731 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
9732 init_func_run_time_cache(&func->op_array);
9733 }
9734 } else {
9735 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
9736 efree(error);
9737 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9738 HANDLE_EXCEPTION();
9739 }
9740
9741 call = zend_vm_stack_push_call_frame(call_info,
9742 func, opline->extended_value, object_or_called_scope);
9743 call->prev_execute_data = EX(call);
9744 EX(call) = call;
9745
9746 ZEND_VM_NEXT_OPCODE();
9747 }
9748
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9749 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9750 {
9751 USE_OPLINE
9752 zval *expr_ptr, new_expr;
9753
9754 SAVE_OPLINE();
9755 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
9756 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
9757 expr_ptr = zend_get_bad_ptr();
9758 if (Z_ISREF_P(expr_ptr)) {
9759 Z_ADDREF_P(expr_ptr);
9760 } else {
9761 ZVAL_MAKE_REF_EX(expr_ptr, 2);
9762 }
9763
9764 } else {
9765 expr_ptr = RT_CONSTANT(opline, opline->op1);
9766 if (IS_CONST == IS_TMP_VAR) {
9767 /* pass */
9768 } else if (IS_CONST == IS_CONST) {
9769 Z_TRY_ADDREF_P(expr_ptr);
9770 } else if (IS_CONST == IS_CV) {
9771 ZVAL_DEREF(expr_ptr);
9772 Z_TRY_ADDREF_P(expr_ptr);
9773 } else /* if (IS_CONST == IS_VAR) */ {
9774 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
9775 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
9776
9777 expr_ptr = Z_REFVAL_P(expr_ptr);
9778 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
9779 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
9780 expr_ptr = &new_expr;
9781 efree_size(ref, sizeof(zend_reference));
9782 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
9783 Z_ADDREF_P(expr_ptr);
9784 }
9785 }
9786 }
9787 }
9788
9789 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
9790 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9791 zend_string *str;
9792 zend_ulong hval;
9793
9794 add_again:
9795 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
9796 str = Z_STR_P(offset);
9797 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9798 if (ZEND_HANDLE_NUMERIC(str, hval)) {
9799 goto num_index;
9800 }
9801 }
9802 str_index:
9803 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
9804 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
9805 hval = Z_LVAL_P(offset);
9806 num_index:
9807 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
9808 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
9809 offset = Z_REFVAL_P(offset);
9810 goto add_again;
9811 } else if (Z_TYPE_P(offset) == IS_NULL) {
9812 str = ZSTR_EMPTY_ALLOC();
9813 goto str_index;
9814 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
9815 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
9816 goto num_index;
9817 } else if (Z_TYPE_P(offset) == IS_FALSE) {
9818 hval = 0;
9819 goto num_index;
9820 } else if (Z_TYPE_P(offset) == IS_TRUE) {
9821 hval = 1;
9822 goto num_index;
9823 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
9824 zend_use_resource_as_offset(offset);
9825 hval = Z_RES_HANDLE_P(offset);
9826 goto num_index;
9827 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
9828 ZVAL_UNDEFINED_OP2();
9829 str = ZSTR_EMPTY_ALLOC();
9830 goto str_index;
9831 } else {
9832 zend_illegal_array_offset_access(offset);
9833 zval_ptr_dtor_nogc(expr_ptr);
9834 }
9835 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9836 } else {
9837 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
9838 zend_cannot_add_element();
9839 zval_ptr_dtor_nogc(expr_ptr);
9840 }
9841 }
9842 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
9843 }
9844
ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9845 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9846 {
9847 zval *array;
9848 uint32_t size;
9849 USE_OPLINE
9850
9851 array = EX_VAR(opline->result.var);
9852 if (IS_CONST != IS_UNUSED) {
9853 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
9854 ZVAL_ARR(array, zend_new_array(size));
9855 /* Explicitly initialize array as not-packed if flag is set */
9856 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
9857 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
9858 }
9859 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
9860 } else {
9861 ZVAL_ARR(array, zend_new_array(0));
9862 ZEND_VM_NEXT_OPCODE();
9863 }
9864 }
9865
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9866 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9867 {
9868 USE_OPLINE
9869 zval *container;
9870 bool result;
9871 zend_ulong hval;
9872 zval *offset;
9873
9874 SAVE_OPLINE();
9875 container = RT_CONSTANT(opline, opline->op1);
9876 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9877
9878 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9879 HashTable *ht;
9880 zval *value;
9881 zend_string *str;
9882
9883 isset_dim_obj_array:
9884 ht = Z_ARRVAL_P(container);
9885 isset_again:
9886 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
9887 str = Z_STR_P(offset);
9888 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9889 if (ZEND_HANDLE_NUMERIC(str, hval)) {
9890 goto num_index_prop;
9891 }
9892 }
9893 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
9894 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
9895 hval = Z_LVAL_P(offset);
9896 num_index_prop:
9897 value = zend_hash_index_find(ht, hval);
9898 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
9899 offset = Z_REFVAL_P(offset);
9900 goto isset_again;
9901 } else {
9902 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
9903 if (UNEXPECTED(EG(exception))) {
9904 result = 0;
9905 goto isset_dim_obj_exit;
9906 }
9907 }
9908
9909 if (!(opline->extended_value & ZEND_ISEMPTY)) {
9910 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
9911 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
9912 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
9913
9914 if (IS_CONST & (IS_CONST|IS_CV)) {
9915 /* avoid exception check */
9916 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9917 ZEND_VM_SMART_BRANCH(result, 0);
9918 }
9919 } else {
9920 result = (value == NULL || !i_zend_is_true(value));
9921 }
9922 goto isset_dim_obj_exit;
9923 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
9924 container = Z_REFVAL_P(container);
9925 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
9926 goto isset_dim_obj_array;
9927 }
9928 }
9929
9930 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
9931 offset++;
9932 }
9933 if (!(opline->extended_value & ZEND_ISEMPTY)) {
9934 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
9935 } else {
9936 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
9937 }
9938
9939 isset_dim_obj_exit:
9940 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9941
9942 ZEND_VM_SMART_BRANCH(result, 1);
9943 }
9944
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9945 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9946 {
9947 USE_OPLINE
9948 zval *container;
9949 int result;
9950 zval *offset;
9951 zend_string *name, *tmp_name;
9952
9953 SAVE_OPLINE();
9954 container = RT_CONSTANT(opline, opline->op1);
9955 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
9956
9957 if (IS_CONST == IS_CONST ||
9958 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
9959 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
9960 container = Z_REFVAL_P(container);
9961 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
9962 result = (opline->extended_value & ZEND_ISEMPTY);
9963 goto isset_object_finish;
9964 }
9965 } else {
9966 result = (opline->extended_value & ZEND_ISEMPTY);
9967 goto isset_object_finish;
9968 }
9969 }
9970
9971 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
9972 name = Z_STR_P(offset);
9973 } else {
9974 name = zval_try_get_tmp_string(offset, &tmp_name);
9975 if (UNEXPECTED(!name)) {
9976 result = 0;
9977 goto isset_object_finish;
9978 }
9979 }
9980
9981 result =
9982 (opline->extended_value & ZEND_ISEMPTY) ^
9983 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));
9984
9985 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
9986 zend_tmp_string_release(tmp_name);
9987 }
9988
9989 isset_object_finish:
9990 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
9991
9992 ZEND_VM_SMART_BRANCH(result, 1);
9993 }
9994
ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)9995 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
9996 {
9997 USE_OPLINE
9998
9999 zval *key, *subject;
10000 HashTable *ht;
10001 bool result;
10002
10003 SAVE_OPLINE();
10004
10005 key = RT_CONSTANT(opline, opline->op1);
10006 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10007
10008 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10009 array_key_exists_array:
10010 ht = Z_ARRVAL_P(subject);
10011 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
10012 } else {
10013 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
10014 subject = Z_REFVAL_P(subject);
10015 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
10016 goto array_key_exists_array;
10017 }
10018 }
10019 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
10020 result = 0;
10021 }
10022
10023 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10024
10025 ZEND_VM_SMART_BRANCH(result, 1);
10026 }
10027
10028 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10029 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10030 {
10031 USE_OPLINE
10032
10033 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
10034
10035 SAVE_OPLINE();
10036 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
10037 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10038 }
10039
10040 /* Destroy the previously yielded value */
10041 zval_ptr_dtor(&generator->value);
10042
10043 /* Destroy the previously yielded key */
10044 zval_ptr_dtor(&generator->key);
10045
10046 /* Set the new yielded value */
10047 if (IS_CONST != IS_UNUSED) {
10048 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10049 /* Constants and temporary variables aren't yieldable by reference,
10050 * but we still allow them with a notice. */
10051 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
10052 zval *value;
10053
10054 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10055
10056 value = RT_CONSTANT(opline, opline->op1);
10057 ZVAL_COPY_VALUE(&generator->value, value);
10058 if (IS_CONST == IS_CONST) {
10059 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10060 Z_ADDREF(generator->value);
10061 }
10062 }
10063 } else {
10064 zval *value_ptr = zend_get_bad_ptr();
10065
10066 /* If a function call result is yielded and the function did
10067 * not return by reference we throw a notice. */
10068 do {
10069 if (IS_CONST == IS_VAR) {
10070 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
10071 if (opline->extended_value == ZEND_RETURNS_FUNCTION
10072 && !Z_ISREF_P(value_ptr)) {
10073 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10074 ZVAL_COPY(&generator->value, value_ptr);
10075 break;
10076 }
10077 }
10078 if (Z_ISREF_P(value_ptr)) {
10079 Z_ADDREF_P(value_ptr);
10080 } else {
10081 ZVAL_MAKE_REF_EX(value_ptr, 2);
10082 }
10083 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
10084 } while (0);
10085
10086 }
10087 } else {
10088 zval *value = RT_CONSTANT(opline, opline->op1);
10089
10090 /* Consts, temporary variables and references need copying */
10091 if (IS_CONST == IS_CONST) {
10092 ZVAL_COPY_VALUE(&generator->value, value);
10093 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10094 Z_ADDREF(generator->value);
10095 }
10096 } else if (IS_CONST == IS_TMP_VAR) {
10097 ZVAL_COPY_VALUE(&generator->value, value);
10098 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
10099 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
10100
10101 } else {
10102 ZVAL_COPY_VALUE(&generator->value, value);
10103 if (IS_CONST == IS_CV) {
10104 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
10105 }
10106 }
10107 }
10108 } else {
10109 /* If no value was specified yield null */
10110 ZVAL_NULL(&generator->value);
10111 }
10112
10113 /* Set the new yielded key */
10114 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
10115 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
10116 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
10117 key = Z_REFVAL_P(key);
10118 }
10119 ZVAL_COPY(&generator->key, key);
10120 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
10121
10122 if (Z_TYPE(generator->key) == IS_LONG
10123 && Z_LVAL(generator->key) > generator->largest_used_integer_key
10124 ) {
10125 generator->largest_used_integer_key = Z_LVAL(generator->key);
10126 }
10127 } else {
10128 /* If no key was specified we use auto-increment keys */
10129 generator->largest_used_integer_key++;
10130 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
10131 }
10132
10133 if (RETURN_VALUE_USED(opline)) {
10134 /* If the return value of yield is used set the send
10135 * target and initialize it to NULL */
10136 generator->send_target = EX_VAR(opline->result.var);
10137 ZVAL_NULL(generator->send_target);
10138 } else {
10139 generator->send_target = NULL;
10140 }
10141
10142 /* We increment to the next op, so we are at the correct position when the
10143 * generator is resumed. */
10144 ZEND_VM_INC_OPCODE();
10145
10146 /* The GOTO VM uses a local opline variable. We need to set the opline
10147 * variable in execute_data so we don't resume at an old position. */
10148 SAVE_OPLINE();
10149
10150 ZEND_VM_RETURN();
10151 }
10152
zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)10153 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)
10154 {
10155 USE_OPLINE
10156 zval *varname;
10157 zval *retval;
10158 zend_string *name, *tmp_name;
10159 HashTable *target_symbol_table;
10160
10161 SAVE_OPLINE();
10162 varname = RT_CONSTANT(opline, opline->op1);
10163
10164 if (IS_CONST == IS_CONST) {
10165 name = Z_STR_P(varname);
10166 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
10167 name = Z_STR_P(varname);
10168 tmp_name = NULL;
10169 } else {
10170 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
10171 ZVAL_UNDEFINED_OP1();
10172 }
10173 name = zval_try_get_tmp_string(varname, &tmp_name);
10174 if (UNEXPECTED(!name)) {
10175 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10176
10177 }
10178 ZVAL_UNDEF(EX_VAR(opline->result.var));
10179 HANDLE_EXCEPTION();
10180 }
10181 }
10182
10183 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
10184 retval = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
10185 if (retval == NULL) {
10186 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10187 fetch_this:
10188 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
10189 if (IS_CONST != IS_CONST) {
10190 zend_tmp_string_release(tmp_name);
10191 }
10192 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10193 }
10194 if (type == BP_VAR_W) {
10195 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
10196 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10197 retval = &EG(uninitialized_zval);
10198 } else {
10199 if (IS_CONST == IS_CV) {
10200 /* Keep name alive in case an error handler tries to free it. */
10201 zend_string_addref(name);
10202 }
10203 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10204 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10205 if (type == BP_VAR_RW && !EG(exception)) {
10206 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
10207 } else {
10208 retval = &EG(uninitialized_zval);
10209 }
10210 if (IS_CONST == IS_CV) {
10211 zend_string_release(name);
10212 }
10213 }
10214 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
10215 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
10216 retval = Z_INDIRECT_P(retval);
10217 if (Z_TYPE_P(retval) == IS_UNDEF) {
10218 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
10219 goto fetch_this;
10220 }
10221 if (type == BP_VAR_W) {
10222 ZVAL_NULL(retval);
10223 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
10224 retval = &EG(uninitialized_zval);
10225 } else {
10226 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
10227 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
10228 if (type == BP_VAR_RW && !EG(exception)) {
10229 ZVAL_NULL(retval);
10230 } else {
10231 retval = &EG(uninitialized_zval);
10232 }
10233 }
10234 }
10235 }
10236
10237 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
10238
10239 }
10240
10241 if (IS_CONST != IS_CONST) {
10242 zend_tmp_string_release(tmp_name);
10243 }
10244
10245 ZEND_ASSERT(retval != NULL);
10246 if (type == BP_VAR_R || type == BP_VAR_IS) {
10247 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
10248 } else {
10249 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
10250 }
10251 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10252 }
10253
ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10254 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10255 {
10256 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10257 }
10258
ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10259 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10260 {
10261 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10262 }
10263
ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10264 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10265 {
10266 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10267 }
10268
ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10269 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10270 {
10271 int fetch_type =
10272 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
10273 BP_VAR_W : BP_VAR_R;
10274 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10275 }
10276
ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10277 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10278 {
10279 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10280 }
10281
ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10282 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10283 {
10284 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10285 }
10286
10287 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10288 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10289 {
10290 #if 0
10291 USE_OPLINE
10292 #endif
10293
10294 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
10295 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
10296 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10297 }
10298 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10299 } else {
10300 if (IS_UNUSED == IS_UNUSED) {
10301 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10302 }
10303 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10304 }
10305 }
10306
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10307 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10308 {
10309 USE_OPLINE
10310 zval *function_name;
10311 zend_class_entry *ce;
10312 uint32_t call_info;
10313 zend_function *fbc;
10314 zend_execute_data *call;
10315
10316 SAVE_OPLINE();
10317
10318 if (IS_CONST == IS_CONST) {
10319 /* no function found. try a static method in class */
10320 ce = CACHED_PTR(opline->result.num);
10321 if (UNEXPECTED(ce == NULL)) {
10322 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);
10323 if (UNEXPECTED(ce == NULL)) {
10324
10325 HANDLE_EXCEPTION();
10326 }
10327 if (IS_UNUSED != IS_CONST) {
10328 CACHE_PTR(opline->result.num, ce);
10329 }
10330 }
10331 } else if (IS_CONST == IS_UNUSED) {
10332 ce = zend_fetch_class(NULL, opline->op1.num);
10333 if (UNEXPECTED(ce == NULL)) {
10334
10335 HANDLE_EXCEPTION();
10336 }
10337 } else {
10338 ce = Z_CE_P(EX_VAR(opline->op1.var));
10339 }
10340
10341 if (IS_CONST == IS_CONST &&
10342 IS_UNUSED == IS_CONST &&
10343 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
10344 /* nothing to do */
10345 } else if (IS_CONST != IS_CONST &&
10346 IS_UNUSED == IS_CONST &&
10347 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
10348 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
10349 } else if (IS_UNUSED != IS_UNUSED) {
10350 function_name = NULL;
10351 if (IS_UNUSED != IS_CONST) {
10352 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
10353 do {
10354 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
10355 function_name = Z_REFVAL_P(function_name);
10356 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
10357 break;
10358 }
10359 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
10360 ZVAL_UNDEFINED_OP2();
10361 if (UNEXPECTED(EG(exception) != NULL)) {
10362 HANDLE_EXCEPTION();
10363 }
10364 }
10365 zend_throw_error(NULL, "Method name must be a string");
10366
10367 HANDLE_EXCEPTION();
10368 } while (0);
10369 }
10370 }
10371
10372 if (ce->get_static_method) {
10373 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
10374 } else {
10375 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
10376 }
10377 if (UNEXPECTED(fbc == NULL)) {
10378 if (EXPECTED(!EG(exception))) {
10379 zend_undefined_method(ce, Z_STR_P(function_name));
10380 }
10381
10382 HANDLE_EXCEPTION();
10383 }
10384 if (IS_UNUSED == IS_CONST &&
10385 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
10386 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
10387 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
10388 }
10389 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10390 init_func_run_time_cache(&fbc->op_array);
10391 }
10392 if (IS_UNUSED != IS_CONST) {
10393
10394 }
10395 } else {
10396 if (UNEXPECTED(ce->constructor == NULL)) {
10397 zend_throw_error(NULL, "Cannot call constructor");
10398 HANDLE_EXCEPTION();
10399 }
10400 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
10401 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
10402 HANDLE_EXCEPTION();
10403 }
10404 fbc = ce->constructor;
10405 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
10406 init_func_run_time_cache(&fbc->op_array);
10407 }
10408 }
10409
10410 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
10411 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
10412 ce = (zend_class_entry*)Z_OBJ(EX(This));
10413 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
10414 } else {
10415 zend_non_static_method_call(fbc);
10416 HANDLE_EXCEPTION();
10417 }
10418 } else {
10419 /* previous opcode is ZEND_FETCH_CLASS */
10420 if (IS_CONST == IS_UNUSED
10421 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
10422 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
10423 if (Z_TYPE(EX(This)) == IS_OBJECT) {
10424 ce = Z_OBJCE(EX(This));
10425 } else {
10426 ce = Z_CE(EX(This));
10427 }
10428 }
10429 call_info = ZEND_CALL_NESTED_FUNCTION;
10430 }
10431
10432 call = zend_vm_stack_push_call_frame(call_info,
10433 fbc, opline->extended_value, ce);
10434 call->prev_execute_data = EX(call);
10435 EX(call) = call;
10436
10437 ZEND_VM_NEXT_OPCODE();
10438 }
10439
ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10440 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10441 {
10442 if (IS_CONST == IS_UNUSED) {
10443 SAVE_OPLINE();
10444 zend_verify_missing_return_type(EX(func));
10445 HANDLE_EXCEPTION();
10446 } else {
10447 /* prevents "undefined variable opline" errors */
10448 #if 0 || (IS_CONST != IS_UNUSED)
10449 USE_OPLINE
10450 zval *retval_ref, *retval_ptr;
10451 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
10452 retval_ref = retval_ptr = RT_CONSTANT(opline, opline->op1);
10453
10454 if (IS_CONST == IS_CONST) {
10455 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
10456 retval_ref = retval_ptr = EX_VAR(opline->result.var);
10457 } else if (IS_CONST == IS_VAR) {
10458 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
10459 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
10460 }
10461 ZVAL_DEREF(retval_ptr);
10462 } else if (IS_CONST == IS_CV) {
10463 ZVAL_DEREF(retval_ptr);
10464 }
10465
10466 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
10467 ZEND_VM_NEXT_OPCODE();
10468 }
10469
10470 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
10471 SAVE_OPLINE();
10472 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
10473 if (UNEXPECTED(EG(exception))) {
10474 HANDLE_EXCEPTION();
10475 }
10476 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
10477 ZEND_VM_NEXT_OPCODE();
10478 }
10479 }
10480
10481 zend_reference *ref = NULL;
10482 void *cache_slot = CACHE_ADDR(opline->op2.num);
10483 if (UNEXPECTED(retval_ref != retval_ptr)) {
10484 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10485 ref = Z_REF_P(retval_ref);
10486 } else {
10487 /* A cast might happen - unwrap the reference if this is a by-value return */
10488 if (Z_REFCOUNT_P(retval_ref) == 1) {
10489 ZVAL_UNREF(retval_ref);
10490 } else {
10491 Z_DELREF_P(retval_ref);
10492 ZVAL_COPY(retval_ref, retval_ptr);
10493 }
10494 retval_ptr = retval_ref;
10495 }
10496 }
10497
10498 SAVE_OPLINE();
10499 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
10500 zend_verify_return_error(EX(func), retval_ptr);
10501 HANDLE_EXCEPTION();
10502 }
10503 ZEND_VM_NEXT_OPCODE();
10504 #endif
10505 }
10506 }
10507
ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10508 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10509 {
10510 USE_OPLINE
10511 zval *value, *arg;
10512
10513 if (IS_UNUSED == IS_CONST) {
10514 SAVE_OPLINE();
10515 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10516 uint32_t arg_num;
10517 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10518 if (UNEXPECTED(!arg)) {
10519
10520 HANDLE_EXCEPTION();
10521 }
10522 } else {
10523 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10524 }
10525
10526 value = RT_CONSTANT(opline, opline->op1);
10527 ZVAL_COPY_VALUE(arg, value);
10528 if (IS_CONST == IS_CONST) {
10529 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10530 Z_ADDREF_P(arg);
10531 }
10532 }
10533 ZEND_VM_NEXT_OPCODE();
10534 }
10535
ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10536 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10537 {
10538 USE_OPLINE
10539 zval *value, *arg;
10540 uint32_t arg_num;
10541
10542 if (IS_UNUSED == IS_CONST) {
10543 SAVE_OPLINE();
10544 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10545 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10546 if (UNEXPECTED(!arg)) {
10547
10548 HANDLE_EXCEPTION();
10549 }
10550 } else {
10551 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10552 arg_num = opline->op2.num;
10553 }
10554
10555 if (EXPECTED(0)) {
10556 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10557 goto send_val_by_ref;
10558 }
10559 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10560 send_val_by_ref:
10561 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10562 }
10563 value = RT_CONSTANT(opline, opline->op1);
10564 ZVAL_COPY_VALUE(arg, value);
10565 if (IS_CONST == IS_CONST) {
10566 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10567 Z_ADDREF_P(arg);
10568 }
10569 }
10570 ZEND_VM_NEXT_OPCODE();
10571 }
10572
ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10573 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10574 {
10575 USE_OPLINE
10576 zval *value, *arg;
10577 uint32_t arg_num;
10578
10579 if (IS_UNUSED == IS_CONST) {
10580 SAVE_OPLINE();
10581 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
10582 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
10583 if (UNEXPECTED(!arg)) {
10584
10585 HANDLE_EXCEPTION();
10586 }
10587 } else {
10588 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
10589 arg_num = opline->op2.num;
10590 }
10591
10592 if (EXPECTED(1)) {
10593 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10594 goto send_val_by_ref;
10595 }
10596 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
10597 send_val_by_ref:
10598 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
10599 }
10600 value = RT_CONSTANT(opline, opline->op1);
10601 ZVAL_COPY_VALUE(arg, value);
10602 if (IS_CONST == IS_CONST) {
10603 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
10604 Z_ADDREF_P(arg);
10605 }
10606 }
10607 ZEND_VM_NEXT_OPCODE();
10608 }
10609
ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10610 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10611 {
10612 USE_OPLINE
10613 zval *result;
10614 zend_function *constructor;
10615 zend_class_entry *ce;
10616 zend_execute_data *call;
10617
10618 SAVE_OPLINE();
10619 if (IS_CONST == IS_CONST) {
10620 ce = CACHED_PTR(opline->op2.num);
10621 if (UNEXPECTED(ce == NULL)) {
10622 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);
10623 if (UNEXPECTED(ce == NULL)) {
10624 ZVAL_UNDEF(EX_VAR(opline->result.var));
10625 HANDLE_EXCEPTION();
10626 }
10627 CACHE_PTR(opline->op2.num, ce);
10628 }
10629 } else if (IS_CONST == IS_UNUSED) {
10630 ce = zend_fetch_class(NULL, opline->op1.num);
10631 if (UNEXPECTED(ce == NULL)) {
10632 ZVAL_UNDEF(EX_VAR(opline->result.var));
10633 HANDLE_EXCEPTION();
10634 }
10635 } else {
10636 ce = Z_CE_P(EX_VAR(opline->op1.var));
10637 }
10638
10639 result = EX_VAR(opline->result.var);
10640 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
10641 ZVAL_UNDEF(result);
10642 HANDLE_EXCEPTION();
10643 }
10644
10645 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
10646 if (constructor == NULL) {
10647 if (UNEXPECTED(EG(exception))) {
10648 HANDLE_EXCEPTION();
10649 }
10650
10651 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
10652 * opcode is DO_FCALL in case EXT instructions are used. */
10653 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
10654 ZEND_VM_NEXT_OPCODE_EX(1, 2);
10655 }
10656
10657 /* Perform a dummy function call */
10658 call = zend_vm_stack_push_call_frame(
10659 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
10660 opline->extended_value, NULL);
10661 } else {
10662 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
10663 init_func_run_time_cache(&constructor->op_array);
10664 }
10665 /* We are not handling overloaded classes right now */
10666 call = zend_vm_stack_push_call_frame(
10667 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
10668 constructor,
10669 opline->extended_value,
10670 Z_OBJ_P(result));
10671 Z_ADDREF_P(result);
10672 }
10673
10674 call->prev_execute_data = EX(call);
10675 EX(call) = call;
10676 ZEND_VM_NEXT_OPCODE();
10677 }
10678
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10679 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10680 {
10681 USE_OPLINE
10682 zval *expr_ptr, new_expr;
10683
10684 SAVE_OPLINE();
10685 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
10686 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
10687 expr_ptr = zend_get_bad_ptr();
10688 if (Z_ISREF_P(expr_ptr)) {
10689 Z_ADDREF_P(expr_ptr);
10690 } else {
10691 ZVAL_MAKE_REF_EX(expr_ptr, 2);
10692 }
10693
10694 } else {
10695 expr_ptr = RT_CONSTANT(opline, opline->op1);
10696 if (IS_CONST == IS_TMP_VAR) {
10697 /* pass */
10698 } else if (IS_CONST == IS_CONST) {
10699 Z_TRY_ADDREF_P(expr_ptr);
10700 } else if (IS_CONST == IS_CV) {
10701 ZVAL_DEREF(expr_ptr);
10702 Z_TRY_ADDREF_P(expr_ptr);
10703 } else /* if (IS_CONST == IS_VAR) */ {
10704 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
10705 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
10706
10707 expr_ptr = Z_REFVAL_P(expr_ptr);
10708 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
10709 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
10710 expr_ptr = &new_expr;
10711 efree_size(ref, sizeof(zend_reference));
10712 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
10713 Z_ADDREF_P(expr_ptr);
10714 }
10715 }
10716 }
10717 }
10718
10719 if (IS_UNUSED != IS_UNUSED) {
10720 zval *offset = NULL;
10721 zend_string *str;
10722 zend_ulong hval;
10723
10724 add_again:
10725 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
10726 str = Z_STR_P(offset);
10727 if (IS_UNUSED != IS_CONST) {
10728 if (ZEND_HANDLE_NUMERIC(str, hval)) {
10729 goto num_index;
10730 }
10731 }
10732 str_index:
10733 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
10734 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
10735 hval = Z_LVAL_P(offset);
10736 num_index:
10737 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
10738 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
10739 offset = Z_REFVAL_P(offset);
10740 goto add_again;
10741 } else if (Z_TYPE_P(offset) == IS_NULL) {
10742 str = ZSTR_EMPTY_ALLOC();
10743 goto str_index;
10744 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
10745 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
10746 goto num_index;
10747 } else if (Z_TYPE_P(offset) == IS_FALSE) {
10748 hval = 0;
10749 goto num_index;
10750 } else if (Z_TYPE_P(offset) == IS_TRUE) {
10751 hval = 1;
10752 goto num_index;
10753 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
10754 zend_use_resource_as_offset(offset);
10755 hval = Z_RES_HANDLE_P(offset);
10756 goto num_index;
10757 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
10758 ZVAL_UNDEFINED_OP2();
10759 str = ZSTR_EMPTY_ALLOC();
10760 goto str_index;
10761 } else {
10762 zend_illegal_array_offset_access(offset);
10763 zval_ptr_dtor_nogc(expr_ptr);
10764 }
10765
10766 } else {
10767 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
10768 zend_cannot_add_element();
10769 zval_ptr_dtor_nogc(expr_ptr);
10770 }
10771 }
10772 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10773 }
10774
ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10775 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10776 {
10777 zval *array;
10778 uint32_t size;
10779 USE_OPLINE
10780
10781 array = EX_VAR(opline->result.var);
10782 if (IS_CONST != IS_UNUSED) {
10783 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
10784 ZVAL_ARR(array, zend_new_array(size));
10785 /* Explicitly initialize array as not-packed if flag is set */
10786 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
10787 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
10788 }
10789 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10790 } else {
10791 ZVAL_ARR(array, zend_new_array(0));
10792 ZEND_VM_NEXT_OPCODE();
10793 }
10794 }
10795
ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10796 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10797 {
10798 USE_OPLINE
10799 zval *varname;
10800 zend_string *name, *tmp_name;
10801 HashTable *target_symbol_table;
10802
10803 SAVE_OPLINE();
10804
10805 varname = RT_CONSTANT(opline, opline->op1);
10806
10807 if (IS_CONST == IS_CONST) {
10808 name = Z_STR_P(varname);
10809 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
10810 name = Z_STR_P(varname);
10811 tmp_name = NULL;
10812 } else {
10813 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
10814 varname = ZVAL_UNDEFINED_OP1();
10815 }
10816 name = zval_try_get_tmp_string(varname, &tmp_name);
10817 if (UNEXPECTED(!name)) {
10818
10819 HANDLE_EXCEPTION();
10820 }
10821 }
10822
10823 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
10824 zend_hash_del_ind(target_symbol_table, name);
10825
10826 if (IS_CONST != IS_CONST) {
10827 zend_tmp_string_release(tmp_name);
10828 }
10829
10830 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
10831 }
10832
10833 /* 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)10834 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10835 {
10836 USE_OPLINE
10837 zval *value;
10838 /* Should be bool result? as below got: result = (opline->extended_value & ZEND_ISEMPTY) */
10839 int result;
10840 zval *varname;
10841 zend_string *name, *tmp_name;
10842 HashTable *target_symbol_table;
10843
10844 SAVE_OPLINE();
10845 varname = RT_CONSTANT(opline, opline->op1);
10846 if (IS_CONST == IS_CONST) {
10847 name = Z_STR_P(varname);
10848 } else {
10849 name = zval_get_tmp_string(varname, &tmp_name);
10850 }
10851
10852 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
10853 value = zend_hash_find_ex(target_symbol_table, name, IS_CONST == IS_CONST);
10854
10855 if (IS_CONST != IS_CONST) {
10856 zend_tmp_string_release(tmp_name);
10857 }
10858
10859 if (!value) {
10860 result = (opline->extended_value & ZEND_ISEMPTY);
10861 } else {
10862 if (Z_TYPE_P(value) == IS_INDIRECT) {
10863 value = Z_INDIRECT_P(value);
10864 }
10865 if (!(opline->extended_value & ZEND_ISEMPTY)) {
10866 if (Z_ISREF_P(value)) {
10867 value = Z_REFVAL_P(value);
10868 }
10869 result = Z_TYPE_P(value) > IS_NULL;
10870 } else {
10871 result = !i_zend_is_true(value);
10872 }
10873 }
10874
10875 ZEND_VM_SMART_BRANCH(result, 1);
10876 }
10877
10878 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)10879 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
10880 {
10881 USE_OPLINE
10882
10883 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
10884
10885 SAVE_OPLINE();
10886 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
10887 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
10888 }
10889
10890 /* Destroy the previously yielded value */
10891 zval_ptr_dtor(&generator->value);
10892
10893 /* Destroy the previously yielded key */
10894 zval_ptr_dtor(&generator->key);
10895
10896 /* Set the new yielded value */
10897 if (IS_CONST != IS_UNUSED) {
10898 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
10899 /* Constants and temporary variables aren't yieldable by reference,
10900 * but we still allow them with a notice. */
10901 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
10902 zval *value;
10903
10904 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10905
10906 value = RT_CONSTANT(opline, opline->op1);
10907 ZVAL_COPY_VALUE(&generator->value, value);
10908 if (IS_CONST == IS_CONST) {
10909 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10910 Z_ADDREF(generator->value);
10911 }
10912 }
10913 } else {
10914 zval *value_ptr = zend_get_bad_ptr();
10915
10916 /* If a function call result is yielded and the function did
10917 * not return by reference we throw a notice. */
10918 do {
10919 if (IS_CONST == IS_VAR) {
10920 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
10921 if (opline->extended_value == ZEND_RETURNS_FUNCTION
10922 && !Z_ISREF_P(value_ptr)) {
10923 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
10924 ZVAL_COPY(&generator->value, value_ptr);
10925 break;
10926 }
10927 }
10928 if (Z_ISREF_P(value_ptr)) {
10929 Z_ADDREF_P(value_ptr);
10930 } else {
10931 ZVAL_MAKE_REF_EX(value_ptr, 2);
10932 }
10933 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
10934 } while (0);
10935
10936 }
10937 } else {
10938 zval *value = RT_CONSTANT(opline, opline->op1);
10939
10940 /* Consts, temporary variables and references need copying */
10941 if (IS_CONST == IS_CONST) {
10942 ZVAL_COPY_VALUE(&generator->value, value);
10943 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
10944 Z_ADDREF(generator->value);
10945 }
10946 } else if (IS_CONST == IS_TMP_VAR) {
10947 ZVAL_COPY_VALUE(&generator->value, value);
10948 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
10949 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
10950
10951 } else {
10952 ZVAL_COPY_VALUE(&generator->value, value);
10953 if (IS_CONST == IS_CV) {
10954 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
10955 }
10956 }
10957 }
10958 } else {
10959 /* If no value was specified yield null */
10960 ZVAL_NULL(&generator->value);
10961 }
10962
10963 /* Set the new yielded key */
10964 if (IS_UNUSED != IS_UNUSED) {
10965 zval *key = NULL;
10966 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
10967 key = Z_REFVAL_P(key);
10968 }
10969 ZVAL_COPY(&generator->key, key);
10970
10971 if (Z_TYPE(generator->key) == IS_LONG
10972 && Z_LVAL(generator->key) > generator->largest_used_integer_key
10973 ) {
10974 generator->largest_used_integer_key = Z_LVAL(generator->key);
10975 }
10976 } else {
10977 /* If no key was specified we use auto-increment keys */
10978 generator->largest_used_integer_key++;
10979 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
10980 }
10981
10982 if (RETURN_VALUE_USED(opline)) {
10983 /* If the return value of yield is used set the send
10984 * target and initialize it to NULL */
10985 generator->send_target = EX_VAR(opline->result.var);
10986 ZVAL_NULL(generator->send_target);
10987 } else {
10988 generator->send_target = NULL;
10989 }
10990
10991 /* We increment to the next op, so we are at the correct position when the
10992 * generator is resumed. */
10993 ZEND_VM_INC_OPCODE();
10994
10995 /* The GOTO VM uses a local opline variable. We need to set the opline
10996 * variable in execute_data so we don't resume at an old position. */
10997 SAVE_OPLINE();
10998
10999 ZEND_VM_RETURN();
11000 }
11001
ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11002 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11003 {
11004 USE_OPLINE
11005 zval *op;
11006
11007 SAVE_OPLINE();
11008 op = RT_CONSTANT(opline, opline->op1);
11009 zend_match_unhandled_error(op);
11010 HANDLE_EXCEPTION();
11011 }
11012
ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11013 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11014 {
11015 USE_OPLINE
11016 zval *op1;
11017 zend_long count;
11018
11019 SAVE_OPLINE();
11020 op1 = RT_CONSTANT(opline, opline->op1);
11021
11022 while (1) {
11023 if (Z_TYPE_P(op1) == IS_ARRAY) {
11024 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
11025 break;
11026 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
11027 zend_object *zobj = Z_OBJ_P(op1);
11028
11029 /* first, we check if the handler is defined */
11030 if (zobj->handlers->count_elements) {
11031 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
11032 break;
11033 }
11034 if (UNEXPECTED(EG(exception))) {
11035 count = 0;
11036 break;
11037 }
11038 }
11039
11040 /* if not and the object implements Countable we call its count() method */
11041 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
11042 zval retval;
11043
11044 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
11045 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
11046 count = zval_get_long(&retval);
11047 zval_ptr_dtor(&retval);
11048 break;
11049 }
11050
11051 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
11052 } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11053 op1 = Z_REFVAL_P(op1);
11054 continue;
11055 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11056 ZVAL_UNDEFINED_OP1();
11057 }
11058 count = 0;
11059 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));
11060 break;
11061 }
11062
11063 ZVAL_LONG(EX_VAR(opline->result.var), count);
11064
11065 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11066 }
11067
ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11068 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11069 {
11070 USE_OPLINE
11071
11072 if (IS_CONST == IS_UNUSED) {
11073 SAVE_OPLINE();
11074 if (UNEXPECTED(!EX(func)->common.scope)) {
11075 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
11076 ZVAL_UNDEF(EX_VAR(opline->result.var));
11077 HANDLE_EXCEPTION();
11078 } else {
11079 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
11080 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
11081 if (UNEXPECTED(EG(exception))) {
11082 HANDLE_EXCEPTION();
11083 }
11084 ZEND_VM_NEXT_OPCODE();
11085 }
11086 } else {
11087 zval *op1;
11088
11089 SAVE_OPLINE();
11090 op1 = RT_CONSTANT(opline, opline->op1);
11091 while (1) {
11092 if (Z_TYPE_P(op1) == IS_OBJECT) {
11093 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
11094 } else if ((IS_CONST & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
11095 op1 = Z_REFVAL_P(op1);
11096 continue;
11097 } else {
11098 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11099 ZVAL_UNDEFINED_OP1();
11100 }
11101 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
11102 ZVAL_UNDEF(EX_VAR(opline->result.var));
11103 }
11104 break;
11105 }
11106
11107 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11108 }
11109 }
11110
ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11111 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11112 {
11113 USE_OPLINE
11114 zval *op1;
11115 zend_string *type;
11116
11117 SAVE_OPLINE();
11118 op1 = RT_CONSTANT(opline, opline->op1);
11119 type = zend_zval_get_legacy_type(op1);
11120 if (EXPECTED(type)) {
11121 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
11122 } else {
11123 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
11124 }
11125
11126 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11127 }
11128
ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11129 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11130 {
11131 USE_OPLINE
11132 zend_array *ht;
11133 uint32_t arg_count, result_size, skip;
11134
11135 arg_count = EX_NUM_ARGS();
11136 if (IS_CONST == IS_CONST) {
11137 skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
11138 if (arg_count < skip) {
11139 result_size = 0;
11140 } else {
11141 result_size = arg_count - skip;
11142 }
11143 } else {
11144 skip = 0;
11145 result_size = arg_count;
11146 }
11147
11148 if (result_size) {
11149 SAVE_OPLINE();
11150 uint32_t first_extra_arg = EX(func)->op_array.num_args;
11151
11152 ht = zend_new_array(result_size);
11153 ZVAL_ARR(EX_VAR(opline->result.var), ht);
11154 zend_hash_real_init_packed(ht);
11155 ZEND_HASH_FILL_PACKED(ht) {
11156 zval *p, *q;
11157 uint32_t i = skip;
11158 p = EX_VAR_NUM(i);
11159 if (arg_count > first_extra_arg) {
11160 while (i < first_extra_arg) {
11161 q = p;
11162 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11163 ZVAL_DEREF(q);
11164 if (Z_OPT_REFCOUNTED_P(q)) {
11165 Z_ADDREF_P(q);
11166 }
11167 ZEND_HASH_FILL_SET(q);
11168 } else {
11169 ZEND_HASH_FILL_SET_NULL();
11170 }
11171 ZEND_HASH_FILL_NEXT();
11172 p++;
11173 i++;
11174 }
11175 if (skip < first_extra_arg) {
11176 skip = 0;
11177 } else {
11178 skip -= first_extra_arg;
11179 }
11180 p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
11181 }
11182 while (i < arg_count) {
11183 q = p;
11184 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
11185 ZVAL_DEREF(q);
11186 if (Z_OPT_REFCOUNTED_P(q)) {
11187 Z_ADDREF_P(q);
11188 }
11189 ZEND_HASH_FILL_SET(q);
11190 } else {
11191 ZEND_HASH_FILL_SET_NULL();
11192 }
11193 ZEND_HASH_FILL_NEXT();
11194 p++;
11195 i++;
11196 }
11197 } ZEND_HASH_FILL_END();
11198 ht->nNumOfElements = result_size;
11199 } else {
11200 ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
11201 }
11202 ZEND_VM_NEXT_OPCODE();
11203 }
11204
11205 /* Contrary to what its name indicates, ZEND_COPY_TMP may receive and define references. */
ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11206 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11207 {
11208 USE_OPLINE
11209 zval *op1, *op2;
11210
11211 SAVE_OPLINE();
11212 op1 = RT_CONSTANT(opline, opline->op1);
11213 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11214 div_function(EX_VAR(opline->result.var), op1, op2);
11215
11216
11217 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11218 }
11219
ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11220 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11221 {
11222 USE_OPLINE
11223 zval *op1, *op2;
11224
11225 SAVE_OPLINE();
11226 op1 = RT_CONSTANT(opline, opline->op1);
11227 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11228 pow_function(EX_VAR(opline->result.var), op1, op2);
11229
11230
11231 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11232 }
11233
ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11234 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11235 {
11236 USE_OPLINE
11237 zval *op1, *op2;
11238
11239 op1 = RT_CONSTANT(opline, opline->op1);
11240 op2 = EX_VAR(opline->op2.var);
11241
11242 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
11243 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
11244 zend_string *op1_str = Z_STR_P(op1);
11245 zend_string *op2_str = Z_STR_P(op2);
11246 zend_string *str;
11247 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
11248
11249 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
11250 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
11251 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
11252 } else {
11253 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
11254 }
11255 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11256 zend_string_release_ex(op1_str, 0);
11257 }
11258 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
11259 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
11260 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
11261 } else {
11262 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
11263 }
11264 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11265 zend_string_release_ex(op2_str, 0);
11266 }
11267 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
11268 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
11269 size_t len = ZSTR_LEN(op1_str);
11270
11271 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
11272 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
11273 }
11274 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
11275 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11276 GC_ADD_FLAGS(str, flags);
11277 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11278 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11279 zend_string_release_ex(op2_str, 0);
11280 }
11281 } else {
11282 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
11283 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
11284 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11285 GC_ADD_FLAGS(str, flags);
11286 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11287 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11288 zend_string_release_ex(op1_str, 0);
11289 }
11290 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11291 zend_string_release_ex(op2_str, 0);
11292 }
11293 }
11294 ZEND_VM_NEXT_OPCODE();
11295 } else {
11296 SAVE_OPLINE();
11297
11298 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11299 op1 = ZVAL_UNDEFINED_OP1();
11300 }
11301 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
11302 op2 = ZVAL_UNDEFINED_OP2();
11303 }
11304 concat_function(EX_VAR(opline->result.var), op1, op2);
11305
11306
11307 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11308 }
11309 }
11310
ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11311 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11312 {
11313 USE_OPLINE
11314 zval *op1, *op2;
11315
11316 SAVE_OPLINE();
11317 op1 = RT_CONSTANT(opline, opline->op1);
11318 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
11319 compare_function(EX_VAR(opline->result.var), op1, op2);
11320
11321
11322 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11323 }
11324
ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11325 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11326 {
11327 USE_OPLINE
11328 zval *container, *dim, *value;
11329
11330 SAVE_OPLINE();
11331 container = RT_CONSTANT(opline, opline->op1);
11332 dim = EX_VAR(opline->op2.var);
11333 if (IS_CONST != IS_CONST) {
11334 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11335 fetch_dim_r_array:
11336 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
11337 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
11338 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
11339 container = Z_REFVAL_P(container);
11340 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
11341 goto fetch_dim_r_array;
11342 } else {
11343 goto fetch_dim_r_slow;
11344 }
11345 } else {
11346 fetch_dim_r_slow:
11347 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
11348 dim++;
11349 }
11350 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
11351 }
11352 } else {
11353 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
11354 }
11355
11356
11357 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11358 }
11359
ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11360 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11361 {
11362 USE_OPLINE
11363 zval *container;
11364
11365 SAVE_OPLINE();
11366 container = RT_CONSTANT(opline, opline->op1);
11367 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
11368
11369
11370 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11371 }
11372
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11373 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11374 {
11375 #if 0
11376 USE_OPLINE
11377 #endif
11378
11379 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
11380 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
11381 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11382 }
11383 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11384 } else {
11385 if (IS_CV == IS_UNUSED) {
11386 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11387 }
11388 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11389 }
11390 }
11391
ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11392 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11393 {
11394 USE_OPLINE
11395 zval *container;
11396 void **cache_slot = NULL;
11397
11398 SAVE_OPLINE();
11399 container = RT_CONSTANT(opline, opline->op1);
11400
11401 if (IS_CONST == IS_CONST ||
11402 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
11403 do {
11404 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
11405 container = Z_REFVAL_P(container);
11406 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
11407 break;
11408 }
11409 }
11410 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
11411 ZVAL_UNDEFINED_OP1();
11412 }
11413 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11414 ZVAL_NULL(EX_VAR(opline->result.var));
11415 goto fetch_obj_r_finish;
11416 } while (0);
11417 }
11418
11419 /* here we are sure we are dealing with an object */
11420 do {
11421 zend_object *zobj = Z_OBJ_P(container);
11422 zend_string *name, *tmp_name;
11423 zval *retval;
11424
11425 if (IS_CV == IS_CONST) {
11426 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
11427
11428 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
11429 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
11430
11431 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
11432 retval = OBJ_PROP(zobj, prop_offset);
11433 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
11434 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11435 goto fetch_obj_r_copy;
11436 } else {
11437 fetch_obj_r_fast_copy:
11438 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11439 ZEND_VM_NEXT_OPCODE();
11440 }
11441 }
11442 } else if (EXPECTED(zobj->properties != NULL)) {
11443 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11444 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
11445 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
11446
11447 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
11448 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
11449
11450 if (EXPECTED(p->key == name) ||
11451 (EXPECTED(p->h == ZSTR_H(name)) &&
11452 EXPECTED(p->key != NULL) &&
11453 EXPECTED(zend_string_equal_content(p->key, name)))) {
11454 retval = &p->val;
11455 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11456 goto fetch_obj_r_copy;
11457 } else {
11458 goto fetch_obj_r_fast_copy;
11459 }
11460 }
11461 }
11462 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
11463 }
11464 retval = zend_hash_find_known_hash(zobj->properties, name);
11465 if (EXPECTED(retval)) {
11466 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
11467 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
11468 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11469 goto fetch_obj_r_copy;
11470 } else {
11471 goto fetch_obj_r_fast_copy;
11472 }
11473 }
11474 }
11475 }
11476 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11477 } else {
11478 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
11479 if (UNEXPECTED(!name)) {
11480 ZVAL_UNDEF(EX_VAR(opline->result.var));
11481 break;
11482 }
11483 }
11484
11485 #if ZEND_DEBUG
11486 /* For non-standard object handlers, verify a declared property type in debug builds.
11487 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
11488 zend_property_info *prop_info = NULL;
11489 if (zobj->handlers->read_property != zend_std_read_property) {
11490 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
11491 }
11492 #endif
11493 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
11494 #if ZEND_DEBUG
11495 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
11496 && ZEND_TYPE_IS_SET(prop_info->type)) {
11497 ZVAL_OPT_DEREF(retval);
11498 zend_verify_property_type(prop_info, retval, /* strict */ true);
11499 }
11500 #endif
11501
11502 if (IS_CV != IS_CONST) {
11503 zend_tmp_string_release(tmp_name);
11504 }
11505
11506 if (retval != EX_VAR(opline->result.var)) {
11507 fetch_obj_r_copy:
11508 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11509 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
11510 zend_unwrap_reference(retval);
11511 }
11512 } while (0);
11513
11514 fetch_obj_r_finish:
11515
11516
11517 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11518 }
11519
ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11520 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11521 {
11522 USE_OPLINE
11523 zval *container;
11524 void **cache_slot = NULL;
11525
11526 SAVE_OPLINE();
11527 container = RT_CONSTANT(opline, opline->op1);
11528
11529 if (IS_CONST == IS_CONST ||
11530 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
11531 do {
11532 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
11533 container = Z_REFVAL_P(container);
11534 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
11535 break;
11536 }
11537 }
11538 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
11539 ZVAL_UNDEFINED_OP2();
11540 }
11541 ZVAL_NULL(EX_VAR(opline->result.var));
11542 goto fetch_obj_is_finish;
11543 } while (0);
11544 }
11545
11546 /* here we are sure we are dealing with an object */
11547 do {
11548 zend_object *zobj = Z_OBJ_P(container);
11549 zend_string *name, *tmp_name;
11550 zval *retval;
11551
11552 if (IS_CV == IS_CONST) {
11553 cache_slot = CACHE_ADDR(opline->extended_value);
11554
11555 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
11556 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
11557
11558 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
11559 retval = OBJ_PROP(zobj, prop_offset);
11560 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
11561 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11562 goto fetch_obj_is_copy;
11563 } else {
11564 fetch_obj_is_fast_copy:
11565 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11566 ZEND_VM_NEXT_OPCODE();
11567 }
11568 }
11569 } else if (EXPECTED(zobj->properties != NULL)) {
11570 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11571 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
11572 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
11573
11574 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
11575 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
11576
11577 if (EXPECTED(p->key == name) ||
11578 (EXPECTED(p->h == ZSTR_H(name)) &&
11579 EXPECTED(p->key != NULL) &&
11580 EXPECTED(zend_string_equal_content(p->key, name)))) {
11581 retval = &p->val;
11582 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11583 goto fetch_obj_is_copy;
11584 } else {
11585 goto fetch_obj_is_fast_copy;
11586 }
11587 }
11588 }
11589 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
11590 }
11591 retval = zend_hash_find_known_hash(zobj->properties, name);
11592 if (EXPECTED(retval)) {
11593 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
11594 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
11595 if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
11596 goto fetch_obj_is_copy;
11597 } else {
11598 goto fetch_obj_is_fast_copy;
11599 }
11600 }
11601 }
11602 }
11603 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
11604 } else {
11605 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
11606 if (UNEXPECTED(!name)) {
11607 ZVAL_UNDEF(EX_VAR(opline->result.var));
11608 break;
11609 }
11610 }
11611
11612 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
11613
11614 if (IS_CV != IS_CONST) {
11615 zend_tmp_string_release(tmp_name);
11616 }
11617
11618 if (retval != EX_VAR(opline->result.var)) {
11619 fetch_obj_is_copy:
11620 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
11621 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
11622 zend_unwrap_reference(retval);
11623 }
11624 } while (0);
11625
11626 fetch_obj_is_finish:
11627
11628
11629 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11630 }
11631
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11632 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11633 {
11634 #if 0
11635 USE_OPLINE
11636 #endif
11637
11638 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
11639 /* Behave like FETCH_OBJ_W */
11640 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
11641 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11642 }
11643 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11644 } else {
11645 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
11646 }
11647 }
11648
ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11649 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11650 {
11651 USE_OPLINE
11652 zval *container;
11653
11654 SAVE_OPLINE();
11655 container = RT_CONSTANT(opline, opline->op1);
11656 zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
11657
11658 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11659 }
11660
ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11661 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11662 {
11663 USE_OPLINE
11664 zval *op1, *op2;
11665 zend_string *op1_str, *op2_str, *str;
11666
11667
11668 op1 = RT_CONSTANT(opline, opline->op1);
11669 op2 = EX_VAR(opline->op2.var);
11670 if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
11671 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
11672 zend_string *op1_str = Z_STR_P(op1);
11673 zend_string *op2_str = Z_STR_P(op2);
11674 zend_string *str;
11675 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
11676
11677 if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
11678 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
11679 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
11680 } else {
11681 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
11682 }
11683 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11684 zend_string_release_ex(op1_str, 0);
11685 }
11686 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
11687 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
11688 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
11689 } else {
11690 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
11691 }
11692 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11693 zend_string_release_ex(op2_str, 0);
11694 }
11695 } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
11696 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
11697 size_t len = ZSTR_LEN(op1_str);
11698
11699 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
11700 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11701 GC_ADD_FLAGS(str, flags);
11702 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11703 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11704 zend_string_release_ex(op2_str, 0);
11705 }
11706 } else {
11707 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
11708 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
11709 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11710 GC_ADD_FLAGS(str, flags);
11711 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11712 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
11713 zend_string_release_ex(op1_str, 0);
11714 }
11715 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
11716 zend_string_release_ex(op2_str, 0);
11717 }
11718 }
11719 ZEND_VM_NEXT_OPCODE();
11720 }
11721
11722 SAVE_OPLINE();
11723 if (IS_CONST == IS_CONST) {
11724 op1_str = Z_STR_P(op1);
11725 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
11726 op1_str = zend_string_copy(Z_STR_P(op1));
11727 } else {
11728 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
11729 ZVAL_UNDEFINED_OP1();
11730 }
11731 op1_str = zval_get_string_func(op1);
11732 }
11733 if (IS_CV == IS_CONST) {
11734 op2_str = Z_STR_P(op2);
11735 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
11736 op2_str = zend_string_copy(Z_STR_P(op2));
11737 } else {
11738 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
11739 ZVAL_UNDEFINED_OP2();
11740 }
11741 op2_str = zval_get_string_func(op2);
11742 }
11743 do {
11744 if (IS_CONST != IS_CONST) {
11745 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
11746 if (IS_CV == IS_CONST) {
11747 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
11748 GC_ADDREF(op2_str);
11749 }
11750 }
11751 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
11752 zend_string_release_ex(op1_str, 0);
11753 break;
11754 }
11755 }
11756 if (IS_CV != IS_CONST) {
11757 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
11758 if (IS_CONST == IS_CONST) {
11759 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
11760 GC_ADDREF(op1_str);
11761 }
11762 }
11763 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
11764 zend_string_release_ex(op2_str, 0);
11765 break;
11766 }
11767 }
11768 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
11769 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
11770 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
11771
11772 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
11773 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
11774 if (IS_CONST != IS_CONST) {
11775 zend_string_release_ex(op1_str, 0);
11776 }
11777 if (IS_CV != IS_CONST) {
11778 zend_string_release_ex(op2_str, 0);
11779 }
11780 } while (0);
11781
11782
11783 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
11784 }
11785
ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11786 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11787 {
11788 USE_OPLINE
11789 zval *function_name;
11790 zval *object;
11791 zend_function *fbc;
11792 zend_class_entry *called_scope;
11793 zend_object *obj;
11794 zend_execute_data *call;
11795 uint32_t call_info;
11796
11797 SAVE_OPLINE();
11798
11799 object = RT_CONSTANT(opline, opline->op1);
11800
11801 if (IS_CV != IS_CONST) {
11802 function_name = EX_VAR(opline->op2.var);
11803 }
11804
11805 if (IS_CV != IS_CONST &&
11806 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
11807 do {
11808 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
11809 function_name = Z_REFVAL_P(function_name);
11810 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
11811 break;
11812 }
11813 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
11814 ZVAL_UNDEFINED_OP2();
11815 if (UNEXPECTED(EG(exception) != NULL)) {
11816
11817 HANDLE_EXCEPTION();
11818 }
11819 }
11820 zend_throw_error(NULL, "Method name must be a string");
11821
11822
11823 HANDLE_EXCEPTION();
11824 } while (0);
11825 }
11826
11827 if (IS_CONST == IS_UNUSED) {
11828 obj = Z_OBJ_P(object);
11829 } else {
11830 do {
11831 if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
11832 obj = Z_OBJ_P(object);
11833 } else {
11834 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
11835 zend_reference *ref = Z_REF_P(object);
11836
11837 object = &ref->val;
11838 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
11839 obj = Z_OBJ_P(object);
11840 if (IS_CONST & IS_VAR) {
11841 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
11842 efree_size(ref, sizeof(zend_reference));
11843 } else {
11844 Z_ADDREF_P(object);
11845 }
11846 }
11847 break;
11848 }
11849 }
11850 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
11851 object = ZVAL_UNDEFINED_OP1();
11852 if (UNEXPECTED(EG(exception) != NULL)) {
11853 if (IS_CV != IS_CONST) {
11854
11855 }
11856 HANDLE_EXCEPTION();
11857 }
11858 }
11859 if (IS_CV == IS_CONST) {
11860 function_name = EX_VAR(opline->op2.var);
11861 }
11862 zend_invalid_method_call(object, function_name);
11863
11864
11865 HANDLE_EXCEPTION();
11866 }
11867 } while (0);
11868 }
11869
11870 called_scope = obj->ce;
11871
11872 if (IS_CV == IS_CONST &&
11873 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
11874 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
11875 } else {
11876 zend_object *orig_obj = obj;
11877
11878 if (IS_CV == IS_CONST) {
11879 function_name = EX_VAR(opline->op2.var);
11880 }
11881
11882 /* First, locate the function. */
11883 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
11884 if (UNEXPECTED(fbc == NULL)) {
11885 if (EXPECTED(!EG(exception))) {
11886 zend_undefined_method(obj->ce, Z_STR_P(function_name));
11887 }
11888
11889 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
11890 zend_objects_store_del(orig_obj);
11891 }
11892 HANDLE_EXCEPTION();
11893 }
11894 if (IS_CV == IS_CONST &&
11895 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
11896 EXPECTED(obj == orig_obj)) {
11897 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
11898 }
11899 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
11900 GC_ADDREF(obj); /* For $this pointer */
11901 if (GC_DELREF(orig_obj) == 0) {
11902 zend_objects_store_del(orig_obj);
11903 }
11904 }
11905 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
11906 init_func_run_time_cache(&fbc->op_array);
11907 }
11908 }
11909
11910 if (IS_CV != IS_CONST) {
11911
11912 }
11913
11914 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
11915 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
11916 if ((IS_CONST & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
11917 zend_objects_store_del(obj);
11918 if (UNEXPECTED(EG(exception))) {
11919 HANDLE_EXCEPTION();
11920 }
11921 }
11922 /* call static method */
11923 obj = (zend_object*)called_scope;
11924 call_info = ZEND_CALL_NESTED_FUNCTION;
11925 } else if (IS_CONST & (IS_VAR|IS_TMP_VAR|IS_CV)) {
11926 if (IS_CONST == IS_CV) {
11927 GC_ADDREF(obj); /* For $this pointer */
11928 }
11929 /* CV may be changed indirectly (e.g. when it's a reference) */
11930 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
11931 }
11932
11933 call = zend_vm_stack_push_call_frame(call_info,
11934 fbc, opline->extended_value, obj);
11935 call->prev_execute_data = EX(call);
11936 EX(call) = call;
11937
11938 ZEND_VM_NEXT_OPCODE();
11939 }
11940
ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)11941 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
11942 {
11943 USE_OPLINE
11944 zval *function_name;
11945 zend_class_entry *ce;
11946 uint32_t call_info;
11947 zend_function *fbc;
11948 zend_execute_data *call;
11949
11950 SAVE_OPLINE();
11951
11952 if (IS_CONST == IS_CONST) {
11953 /* no function found. try a static method in class */
11954 ce = CACHED_PTR(opline->result.num);
11955 if (UNEXPECTED(ce == NULL)) {
11956 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);
11957 if (UNEXPECTED(ce == NULL)) {
11958
11959 HANDLE_EXCEPTION();
11960 }
11961 if (IS_CV != IS_CONST) {
11962 CACHE_PTR(opline->result.num, ce);
11963 }
11964 }
11965 } else if (IS_CONST == IS_UNUSED) {
11966 ce = zend_fetch_class(NULL, opline->op1.num);
11967 if (UNEXPECTED(ce == NULL)) {
11968
11969 HANDLE_EXCEPTION();
11970 }
11971 } else {
11972 ce = Z_CE_P(EX_VAR(opline->op1.var));
11973 }
11974
11975 if (IS_CONST == IS_CONST &&
11976 IS_CV == IS_CONST &&
11977 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
11978 /* nothing to do */
11979 } else if (IS_CONST != IS_CONST &&
11980 IS_CV == IS_CONST &&
11981 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
11982 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
11983 } else if (IS_CV != IS_UNUSED) {
11984 function_name = EX_VAR(opline->op2.var);
11985 if (IS_CV != IS_CONST) {
11986 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
11987 do {
11988 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
11989 function_name = Z_REFVAL_P(function_name);
11990 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
11991 break;
11992 }
11993 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
11994 ZVAL_UNDEFINED_OP2();
11995 if (UNEXPECTED(EG(exception) != NULL)) {
11996 HANDLE_EXCEPTION();
11997 }
11998 }
11999 zend_throw_error(NULL, "Method name must be a string");
12000
12001 HANDLE_EXCEPTION();
12002 } while (0);
12003 }
12004 }
12005
12006 if (ce->get_static_method) {
12007 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
12008 } else {
12009 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
12010 }
12011 if (UNEXPECTED(fbc == NULL)) {
12012 if (EXPECTED(!EG(exception))) {
12013 zend_undefined_method(ce, Z_STR_P(function_name));
12014 }
12015
12016 HANDLE_EXCEPTION();
12017 }
12018 if (IS_CV == IS_CONST &&
12019 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
12020 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
12021 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
12022 }
12023 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12024 init_func_run_time_cache(&fbc->op_array);
12025 }
12026 if (IS_CV != IS_CONST) {
12027
12028 }
12029 } else {
12030 if (UNEXPECTED(ce->constructor == NULL)) {
12031 zend_throw_error(NULL, "Cannot call constructor");
12032 HANDLE_EXCEPTION();
12033 }
12034 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
12035 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
12036 HANDLE_EXCEPTION();
12037 }
12038 fbc = ce->constructor;
12039 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
12040 init_func_run_time_cache(&fbc->op_array);
12041 }
12042 }
12043
12044 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
12045 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
12046 ce = (zend_class_entry*)Z_OBJ(EX(This));
12047 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
12048 } else {
12049 zend_non_static_method_call(fbc);
12050 HANDLE_EXCEPTION();
12051 }
12052 } else {
12053 /* previous opcode is ZEND_FETCH_CLASS */
12054 if (IS_CONST == IS_UNUSED
12055 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
12056 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
12057 if (Z_TYPE(EX(This)) == IS_OBJECT) {
12058 ce = Z_OBJCE(EX(This));
12059 } else {
12060 ce = Z_CE(EX(This));
12061 }
12062 }
12063 call_info = ZEND_CALL_NESTED_FUNCTION;
12064 }
12065
12066 call = zend_vm_stack_push_call_frame(call_info,
12067 fbc, opline->extended_value, ce);
12068 call->prev_execute_data = EX(call);
12069 EX(call) = call;
12070
12071 ZEND_VM_NEXT_OPCODE();
12072 }
12073
ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12074 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12075 {
12076 USE_OPLINE
12077 zval *function_name;
12078 zend_fcall_info_cache fcc;
12079 char *error = NULL;
12080 zend_function *func;
12081 void *object_or_called_scope;
12082 zend_execute_data *call;
12083 uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC;
12084
12085 SAVE_OPLINE();
12086 function_name = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12087 if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) {
12088 ZEND_ASSERT(!error);
12089 func = fcc.function_handler;
12090 object_or_called_scope = fcc.called_scope;
12091 if (func->common.fn_flags & ZEND_ACC_CLOSURE) {
12092 /* Delay closure destruction until its invocation */
12093 GC_ADDREF(ZEND_CLOSURE_OBJECT(func));
12094 call_info |= ZEND_CALL_CLOSURE;
12095 if (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) {
12096 call_info |= ZEND_CALL_FAKE_CLOSURE;
12097 }
12098 if (fcc.object) {
12099 object_or_called_scope = fcc.object;
12100 call_info |= ZEND_CALL_HAS_THIS;
12101 }
12102 } else if (fcc.object) {
12103 GC_ADDREF(fcc.object); /* For $this pointer */
12104 object_or_called_scope = fcc.object;
12105 call_info |= ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS;
12106 }
12107
12108 if ((IS_CV & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) {
12109 if (call_info & ZEND_CALL_CLOSURE) {
12110 zend_object_release(ZEND_CLOSURE_OBJECT(func));
12111 } else if (call_info & ZEND_CALL_RELEASE_THIS) {
12112 zend_object_release(fcc.object);
12113 }
12114 HANDLE_EXCEPTION();
12115 }
12116
12117 if (EXPECTED(func->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&func->op_array))) {
12118 init_func_run_time_cache(&func->op_array);
12119 }
12120 } else {
12121 zend_type_error("%s(): Argument #1 ($callback) must be a valid callback, %s", Z_STRVAL_P(RT_CONSTANT(opline, opline->op1)), error);
12122 efree(error);
12123
12124 HANDLE_EXCEPTION();
12125 }
12126
12127 call = zend_vm_stack_push_call_frame(call_info,
12128 func, opline->extended_value, object_or_called_scope);
12129 call->prev_execute_data = EX(call);
12130 EX(call) = call;
12131
12132 ZEND_VM_NEXT_OPCODE();
12133 }
12134
ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12135 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12136 {
12137 USE_OPLINE
12138 zval *expr_ptr, new_expr;
12139
12140 SAVE_OPLINE();
12141 if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
12142 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
12143 expr_ptr = zend_get_bad_ptr();
12144 if (Z_ISREF_P(expr_ptr)) {
12145 Z_ADDREF_P(expr_ptr);
12146 } else {
12147 ZVAL_MAKE_REF_EX(expr_ptr, 2);
12148 }
12149
12150 } else {
12151 expr_ptr = RT_CONSTANT(opline, opline->op1);
12152 if (IS_CONST == IS_TMP_VAR) {
12153 /* pass */
12154 } else if (IS_CONST == IS_CONST) {
12155 Z_TRY_ADDREF_P(expr_ptr);
12156 } else if (IS_CONST == IS_CV) {
12157 ZVAL_DEREF(expr_ptr);
12158 Z_TRY_ADDREF_P(expr_ptr);
12159 } else /* if (IS_CONST == IS_VAR) */ {
12160 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
12161 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
12162
12163 expr_ptr = Z_REFVAL_P(expr_ptr);
12164 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
12165 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
12166 expr_ptr = &new_expr;
12167 efree_size(ref, sizeof(zend_reference));
12168 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
12169 Z_ADDREF_P(expr_ptr);
12170 }
12171 }
12172 }
12173 }
12174
12175 if (IS_CV != IS_UNUSED) {
12176 zval *offset = EX_VAR(opline->op2.var);
12177 zend_string *str;
12178 zend_ulong hval;
12179
12180 add_again:
12181 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12182 str = Z_STR_P(offset);
12183 if (IS_CV != IS_CONST) {
12184 if (ZEND_HANDLE_NUMERIC(str, hval)) {
12185 goto num_index;
12186 }
12187 }
12188 str_index:
12189 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
12190 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12191 hval = Z_LVAL_P(offset);
12192 num_index:
12193 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
12194 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
12195 offset = Z_REFVAL_P(offset);
12196 goto add_again;
12197 } else if (Z_TYPE_P(offset) == IS_NULL) {
12198 str = ZSTR_EMPTY_ALLOC();
12199 goto str_index;
12200 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
12201 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
12202 goto num_index;
12203 } else if (Z_TYPE_P(offset) == IS_FALSE) {
12204 hval = 0;
12205 goto num_index;
12206 } else if (Z_TYPE_P(offset) == IS_TRUE) {
12207 hval = 1;
12208 goto num_index;
12209 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
12210 zend_use_resource_as_offset(offset);
12211 hval = Z_RES_HANDLE_P(offset);
12212 goto num_index;
12213 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
12214 ZVAL_UNDEFINED_OP2();
12215 str = ZSTR_EMPTY_ALLOC();
12216 goto str_index;
12217 } else {
12218 zend_illegal_array_offset_access(offset);
12219 zval_ptr_dtor_nogc(expr_ptr);
12220 }
12221
12222 } else {
12223 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
12224 zend_cannot_add_element();
12225 zval_ptr_dtor_nogc(expr_ptr);
12226 }
12227 }
12228 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
12229 }
12230
ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12231 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12232 {
12233 zval *array;
12234 uint32_t size;
12235 USE_OPLINE
12236
12237 array = EX_VAR(opline->result.var);
12238 if (IS_CONST != IS_UNUSED) {
12239 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
12240 ZVAL_ARR(array, zend_new_array(size));
12241 /* Explicitly initialize array as not-packed if flag is set */
12242 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
12243 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
12244 }
12245 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12246 } else {
12247 ZVAL_ARR(array, zend_new_array(0));
12248 ZEND_VM_NEXT_OPCODE();
12249 }
12250 }
12251
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12252 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12253 {
12254 USE_OPLINE
12255 zval *container;
12256 bool result;
12257 zend_ulong hval;
12258 zval *offset;
12259
12260 SAVE_OPLINE();
12261 container = RT_CONSTANT(opline, opline->op1);
12262 offset = EX_VAR(opline->op2.var);
12263
12264 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12265 HashTable *ht;
12266 zval *value;
12267 zend_string *str;
12268
12269 isset_dim_obj_array:
12270 ht = Z_ARRVAL_P(container);
12271 isset_again:
12272 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
12273 str = Z_STR_P(offset);
12274 if (IS_CV != IS_CONST) {
12275 if (ZEND_HANDLE_NUMERIC(str, hval)) {
12276 goto num_index_prop;
12277 }
12278 }
12279 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
12280 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
12281 hval = Z_LVAL_P(offset);
12282 num_index_prop:
12283 value = zend_hash_index_find(ht, hval);
12284 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
12285 offset = Z_REFVAL_P(offset);
12286 goto isset_again;
12287 } else {
12288 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
12289 if (UNEXPECTED(EG(exception))) {
12290 result = 0;
12291 goto isset_dim_obj_exit;
12292 }
12293 }
12294
12295 if (!(opline->extended_value & ZEND_ISEMPTY)) {
12296 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
12297 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
12298 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
12299
12300 if (IS_CONST & (IS_CONST|IS_CV)) {
12301 /* avoid exception check */
12302
12303 ZEND_VM_SMART_BRANCH(result, 0);
12304 }
12305 } else {
12306 result = (value == NULL || !i_zend_is_true(value));
12307 }
12308 goto isset_dim_obj_exit;
12309 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
12310 container = Z_REFVAL_P(container);
12311 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
12312 goto isset_dim_obj_array;
12313 }
12314 }
12315
12316 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
12317 offset++;
12318 }
12319 if (!(opline->extended_value & ZEND_ISEMPTY)) {
12320 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
12321 } else {
12322 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
12323 }
12324
12325 isset_dim_obj_exit:
12326
12327
12328 ZEND_VM_SMART_BRANCH(result, 1);
12329 }
12330
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12331 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12332 {
12333 USE_OPLINE
12334 zval *container;
12335 int result;
12336 zval *offset;
12337 zend_string *name, *tmp_name;
12338
12339 SAVE_OPLINE();
12340 container = RT_CONSTANT(opline, opline->op1);
12341 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12342
12343 if (IS_CONST == IS_CONST ||
12344 (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
12345 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
12346 container = Z_REFVAL_P(container);
12347 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
12348 result = (opline->extended_value & ZEND_ISEMPTY);
12349 goto isset_object_finish;
12350 }
12351 } else {
12352 result = (opline->extended_value & ZEND_ISEMPTY);
12353 goto isset_object_finish;
12354 }
12355 }
12356
12357 if (IS_CV == IS_CONST) {
12358 name = Z_STR_P(offset);
12359 } else {
12360 name = zval_try_get_tmp_string(offset, &tmp_name);
12361 if (UNEXPECTED(!name)) {
12362 result = 0;
12363 goto isset_object_finish;
12364 }
12365 }
12366
12367 result =
12368 (opline->extended_value & ZEND_ISEMPTY) ^
12369 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));
12370
12371 if (IS_CV != IS_CONST) {
12372 zend_tmp_string_release(tmp_name);
12373 }
12374
12375 isset_object_finish:
12376
12377
12378 ZEND_VM_SMART_BRANCH(result, 1);
12379 }
12380
ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12381 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12382 {
12383 USE_OPLINE
12384
12385 zval *key, *subject;
12386 HashTable *ht;
12387 bool result;
12388
12389 SAVE_OPLINE();
12390
12391 key = RT_CONSTANT(opline, opline->op1);
12392 subject = EX_VAR(opline->op2.var);
12393
12394 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12395 array_key_exists_array:
12396 ht = Z_ARRVAL_P(subject);
12397 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
12398 } else {
12399 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
12400 subject = Z_REFVAL_P(subject);
12401 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
12402 goto array_key_exists_array;
12403 }
12404 }
12405 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
12406 result = 0;
12407 }
12408
12409
12410 ZEND_VM_SMART_BRANCH(result, 1);
12411 }
12412
12413 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12414 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12415 {
12416 USE_OPLINE
12417
12418 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
12419
12420 SAVE_OPLINE();
12421 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
12422 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12423 }
12424
12425 /* Destroy the previously yielded value */
12426 zval_ptr_dtor(&generator->value);
12427
12428 /* Destroy the previously yielded key */
12429 zval_ptr_dtor(&generator->key);
12430
12431 /* Set the new yielded value */
12432 if (IS_CONST != IS_UNUSED) {
12433 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
12434 /* Constants and temporary variables aren't yieldable by reference,
12435 * but we still allow them with a notice. */
12436 if (IS_CONST & (IS_CONST|IS_TMP_VAR)) {
12437 zval *value;
12438
12439 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12440
12441 value = RT_CONSTANT(opline, opline->op1);
12442 ZVAL_COPY_VALUE(&generator->value, value);
12443 if (IS_CONST == IS_CONST) {
12444 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12445 Z_ADDREF(generator->value);
12446 }
12447 }
12448 } else {
12449 zval *value_ptr = zend_get_bad_ptr();
12450
12451 /* If a function call result is yielded and the function did
12452 * not return by reference we throw a notice. */
12453 do {
12454 if (IS_CONST == IS_VAR) {
12455 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
12456 if (opline->extended_value == ZEND_RETURNS_FUNCTION
12457 && !Z_ISREF_P(value_ptr)) {
12458 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
12459 ZVAL_COPY(&generator->value, value_ptr);
12460 break;
12461 }
12462 }
12463 if (Z_ISREF_P(value_ptr)) {
12464 Z_ADDREF_P(value_ptr);
12465 } else {
12466 ZVAL_MAKE_REF_EX(value_ptr, 2);
12467 }
12468 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
12469 } while (0);
12470
12471 }
12472 } else {
12473 zval *value = RT_CONSTANT(opline, opline->op1);
12474
12475 /* Consts, temporary variables and references need copying */
12476 if (IS_CONST == IS_CONST) {
12477 ZVAL_COPY_VALUE(&generator->value, value);
12478 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
12479 Z_ADDREF(generator->value);
12480 }
12481 } else if (IS_CONST == IS_TMP_VAR) {
12482 ZVAL_COPY_VALUE(&generator->value, value);
12483 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
12484 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
12485
12486 } else {
12487 ZVAL_COPY_VALUE(&generator->value, value);
12488 if (IS_CONST == IS_CV) {
12489 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
12490 }
12491 }
12492 }
12493 } else {
12494 /* If no value was specified yield null */
12495 ZVAL_NULL(&generator->value);
12496 }
12497
12498 /* Set the new yielded key */
12499 if (IS_CV != IS_UNUSED) {
12500 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
12501 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
12502 key = Z_REFVAL_P(key);
12503 }
12504 ZVAL_COPY(&generator->key, key);
12505
12506 if (Z_TYPE(generator->key) == IS_LONG
12507 && Z_LVAL(generator->key) > generator->largest_used_integer_key
12508 ) {
12509 generator->largest_used_integer_key = Z_LVAL(generator->key);
12510 }
12511 } else {
12512 /* If no key was specified we use auto-increment keys */
12513 generator->largest_used_integer_key++;
12514 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
12515 }
12516
12517 if (RETURN_VALUE_USED(opline)) {
12518 /* If the return value of yield is used set the send
12519 * target and initialize it to NULL */
12520 generator->send_target = EX_VAR(opline->result.var);
12521 ZVAL_NULL(generator->send_target);
12522 } else {
12523 generator->send_target = NULL;
12524 }
12525
12526 /* We increment to the next op, so we are at the correct position when the
12527 * generator is resumed. */
12528 ZEND_VM_INC_OPCODE();
12529
12530 /* The GOTO VM uses a local opline variable. We need to set the opline
12531 * variable in execute_data so we don't resume at an old position. */
12532 SAVE_OPLINE();
12533
12534 ZEND_VM_RETURN();
12535 }
12536
ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12537 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12538 {
12539 USE_OPLINE
12540 zval *op1;
12541
12542 op1 = EX_VAR(opline->op1.var);
12543 if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12544 ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
12545 ZEND_VM_NEXT_OPCODE();
12546 }
12547
12548 ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(op1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12549 }
12550
ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12551 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12552 {
12553 USE_OPLINE
12554 zval *value;
12555
12556 value = EX_VAR(opline->op1.var);
12557 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(value));
12558 ZEND_VM_NEXT_OPCODE();
12559 }
12560
ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12561 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12562 {
12563 USE_OPLINE
12564 zval *value;
12565
12566 value = EX_VAR(opline->op1.var);
12567 ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(value));
12568 ZEND_VM_NEXT_OPCODE();
12569 }
12570
ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12571 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12572 {
12573 USE_OPLINE
12574 zval *value;
12575
12576 value = EX_VAR(opline->op1.var);
12577 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
12578 ZEND_VM_NEXT_OPCODE();
12579 }
12580
ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12581 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12582 {
12583 USE_OPLINE
12584 zval *op1, *op2, *result;
12585 double d1, d2;
12586
12587 op1 = EX_VAR(opline->op1.var);
12588 op2 = RT_CONSTANT(opline, opline->op2);
12589 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12590 /* pass */
12591 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12592 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12593 result = EX_VAR(opline->result.var);
12594 fast_long_add_function(result, op1, op2);
12595 ZEND_VM_NEXT_OPCODE();
12596 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12597 d1 = (double)Z_LVAL_P(op1);
12598 d2 = Z_DVAL_P(op2);
12599 goto add_double;
12600 }
12601 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12602 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12603 d1 = Z_DVAL_P(op1);
12604 d2 = Z_DVAL_P(op2);
12605 add_double:
12606 result = EX_VAR(opline->result.var);
12607 ZVAL_DOUBLE(result, d1 + d2);
12608 ZEND_VM_NEXT_OPCODE();
12609 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12610 d1 = Z_DVAL_P(op1);
12611 d2 = (double)Z_LVAL_P(op2);
12612 goto add_double;
12613 }
12614 }
12615
12616 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12617 }
12618
ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12619 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12620 {
12621 USE_OPLINE
12622 zval *op1, *op2, *result;
12623 double d1, d2;
12624
12625 op1 = EX_VAR(opline->op1.var);
12626 op2 = RT_CONSTANT(opline, opline->op2);
12627 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12628 /* pass */
12629 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12630 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12631 result = EX_VAR(opline->result.var);
12632 fast_long_sub_function(result, op1, op2);
12633 ZEND_VM_NEXT_OPCODE();
12634 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12635 d1 = (double)Z_LVAL_P(op1);
12636 d2 = Z_DVAL_P(op2);
12637 goto sub_double;
12638 }
12639 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12640 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12641 d1 = Z_DVAL_P(op1);
12642 d2 = Z_DVAL_P(op2);
12643 sub_double:
12644 result = EX_VAR(opline->result.var);
12645 ZVAL_DOUBLE(result, d1 - d2);
12646 ZEND_VM_NEXT_OPCODE();
12647 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12648 d1 = Z_DVAL_P(op1);
12649 d2 = (double)Z_LVAL_P(op2);
12650 goto sub_double;
12651 }
12652 }
12653
12654 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12655 }
12656
ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12657 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12658 {
12659 USE_OPLINE
12660 zval *op1, *op2, *result;
12661 double d1, d2;
12662
12663 op1 = EX_VAR(opline->op1.var);
12664 op2 = RT_CONSTANT(opline, opline->op2);
12665 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12666 /* pass */
12667 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12668 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12669 zend_long overflow;
12670
12671 result = EX_VAR(opline->result.var);
12672 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
12673 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
12674 ZEND_VM_NEXT_OPCODE();
12675 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12676 d1 = (double)Z_LVAL_P(op1);
12677 d2 = Z_DVAL_P(op2);
12678 goto mul_double;
12679 }
12680 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12681 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12682 d1 = Z_DVAL_P(op1);
12683 d2 = Z_DVAL_P(op2);
12684 mul_double:
12685 result = EX_VAR(opline->result.var);
12686 ZVAL_DOUBLE(result, d1 * d2);
12687 ZEND_VM_NEXT_OPCODE();
12688 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12689 d1 = Z_DVAL_P(op1);
12690 d2 = (double)Z_LVAL_P(op2);
12691 goto mul_double;
12692 }
12693 }
12694
12695 ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12696 }
12697
ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12698 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12699 {
12700 USE_OPLINE
12701 zval *op1, *op2, *result;
12702
12703 op1 = EX_VAR(opline->op1.var);
12704 op2 = RT_CONSTANT(opline, opline->op2);
12705 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12706 /* pass */
12707 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12708 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12709 result = EX_VAR(opline->result.var);
12710 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
12711 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
12712 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
12713 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
12714 ZVAL_LONG(result, 0);
12715 } else {
12716 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
12717 }
12718 ZEND_VM_NEXT_OPCODE();
12719 }
12720 }
12721
12722 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12723 }
12724
ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12725 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12726 {
12727 USE_OPLINE
12728 zval *op1, *op2;
12729
12730 op1 = EX_VAR(opline->op1.var);
12731 op2 = RT_CONSTANT(opline, opline->op2);
12732 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12733 /* pass */
12734 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
12735 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
12736 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
12737 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
12738 ZVAL_LONG(EX_VAR(opline->result.var),
12739 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
12740 ZEND_VM_NEXT_OPCODE();
12741 }
12742
12743 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12744 }
12745
ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12746 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12747 {
12748 USE_OPLINE
12749 zval *op1, *op2;
12750
12751 op1 = EX_VAR(opline->op1.var);
12752 op2 = RT_CONSTANT(opline, opline->op2);
12753 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12754 /* pass */
12755 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
12756 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
12757 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
12758 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
12759 ZEND_VM_NEXT_OPCODE();
12760 }
12761
12762 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12763 }
12764
ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12765 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12766 {
12767 USE_OPLINE
12768 zval *op1, *op2;
12769 double d1, d2;
12770
12771 op1 = EX_VAR(opline->op1.var);
12772 op2 = RT_CONSTANT(opline, opline->op2);
12773 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12774 /* pass */
12775 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12776 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12777 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
12778 is_smaller_true:
12779 ZEND_VM_SMART_BRANCH_TRUE_NONE();
12780 } else {
12781 is_smaller_false:
12782 ZEND_VM_SMART_BRANCH_FALSE_NONE();
12783 }
12784 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12785 d1 = (double)Z_LVAL_P(op1);
12786 d2 = Z_DVAL_P(op2);
12787 goto is_smaller_double;
12788 }
12789 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12790 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12791 d1 = Z_DVAL_P(op1);
12792 d2 = Z_DVAL_P(op2);
12793 is_smaller_double:
12794 if (d1 < d2) {
12795 goto is_smaller_true;
12796 } else {
12797 goto is_smaller_false;
12798 }
12799 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12800 d1 = Z_DVAL_P(op1);
12801 d2 = (double)Z_LVAL_P(op2);
12802 goto is_smaller_double;
12803 }
12804 }
12805 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12806 }
12807
ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12808 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12809 {
12810 USE_OPLINE
12811 zval *op1, *op2;
12812 double d1, d2;
12813
12814 op1 = EX_VAR(opline->op1.var);
12815 op2 = RT_CONSTANT(opline, opline->op2);
12816 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12817 /* pass */
12818 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12819 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12820 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
12821 is_smaller_true:
12822 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
12823 } else {
12824 is_smaller_false:
12825 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
12826 }
12827 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12828 d1 = (double)Z_LVAL_P(op1);
12829 d2 = Z_DVAL_P(op2);
12830 goto is_smaller_double;
12831 }
12832 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12833 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12834 d1 = Z_DVAL_P(op1);
12835 d2 = Z_DVAL_P(op2);
12836 is_smaller_double:
12837 if (d1 < d2) {
12838 goto is_smaller_true;
12839 } else {
12840 goto is_smaller_false;
12841 }
12842 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12843 d1 = Z_DVAL_P(op1);
12844 d2 = (double)Z_LVAL_P(op2);
12845 goto is_smaller_double;
12846 }
12847 }
12848 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12849 }
12850
ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12851 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12852 {
12853 USE_OPLINE
12854 zval *op1, *op2;
12855 double d1, d2;
12856
12857 op1 = EX_VAR(opline->op1.var);
12858 op2 = RT_CONSTANT(opline, opline->op2);
12859 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12860 /* pass */
12861 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12862 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12863 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
12864 is_smaller_true:
12865 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
12866 } else {
12867 is_smaller_false:
12868 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
12869 }
12870 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12871 d1 = (double)Z_LVAL_P(op1);
12872 d2 = Z_DVAL_P(op2);
12873 goto is_smaller_double;
12874 }
12875 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12876 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12877 d1 = Z_DVAL_P(op1);
12878 d2 = Z_DVAL_P(op2);
12879 is_smaller_double:
12880 if (d1 < d2) {
12881 goto is_smaller_true;
12882 } else {
12883 goto is_smaller_false;
12884 }
12885 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12886 d1 = Z_DVAL_P(op1);
12887 d2 = (double)Z_LVAL_P(op2);
12888 goto is_smaller_double;
12889 }
12890 }
12891 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12892 }
12893
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12894 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12895 {
12896 USE_OPLINE
12897 zval *op1, *op2;
12898 double d1, d2;
12899
12900 op1 = EX_VAR(opline->op1.var);
12901 op2 = RT_CONSTANT(opline, opline->op2);
12902 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12903 /* pass */
12904 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12905 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12906 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
12907 is_smaller_or_equal_true:
12908 ZEND_VM_SMART_BRANCH_TRUE_NONE();
12909 ZVAL_TRUE(EX_VAR(opline->result.var));
12910 ZEND_VM_NEXT_OPCODE();
12911 } else {
12912 is_smaller_or_equal_false:
12913 ZEND_VM_SMART_BRANCH_FALSE_NONE();
12914 ZVAL_FALSE(EX_VAR(opline->result.var));
12915 ZEND_VM_NEXT_OPCODE();
12916 }
12917 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12918 d1 = (double)Z_LVAL_P(op1);
12919 d2 = Z_DVAL_P(op2);
12920 goto is_smaller_or_equal_double;
12921 }
12922 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12923 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12924 d1 = Z_DVAL_P(op1);
12925 d2 = Z_DVAL_P(op2);
12926 is_smaller_or_equal_double:
12927 if (d1 <= d2) {
12928 goto is_smaller_or_equal_true;
12929 } else {
12930 goto is_smaller_or_equal_false;
12931 }
12932 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12933 d1 = Z_DVAL_P(op1);
12934 d2 = (double)Z_LVAL_P(op2);
12935 goto is_smaller_or_equal_double;
12936 }
12937 }
12938 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12939 }
12940
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12941 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12942 {
12943 USE_OPLINE
12944 zval *op1, *op2;
12945 double d1, d2;
12946
12947 op1 = EX_VAR(opline->op1.var);
12948 op2 = RT_CONSTANT(opline, opline->op2);
12949 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12950 /* pass */
12951 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12952 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12953 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
12954 is_smaller_or_equal_true:
12955 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
12956 ZVAL_TRUE(EX_VAR(opline->result.var));
12957 ZEND_VM_NEXT_OPCODE();
12958 } else {
12959 is_smaller_or_equal_false:
12960 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
12961 ZVAL_FALSE(EX_VAR(opline->result.var));
12962 ZEND_VM_NEXT_OPCODE();
12963 }
12964 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12965 d1 = (double)Z_LVAL_P(op1);
12966 d2 = Z_DVAL_P(op2);
12967 goto is_smaller_or_equal_double;
12968 }
12969 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
12970 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
12971 d1 = Z_DVAL_P(op1);
12972 d2 = Z_DVAL_P(op2);
12973 is_smaller_or_equal_double:
12974 if (d1 <= d2) {
12975 goto is_smaller_or_equal_true;
12976 } else {
12977 goto is_smaller_or_equal_false;
12978 }
12979 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
12980 d1 = Z_DVAL_P(op1);
12981 d2 = (double)Z_LVAL_P(op2);
12982 goto is_smaller_or_equal_double;
12983 }
12984 }
12985 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
12986 }
12987
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)12988 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
12989 {
12990 USE_OPLINE
12991 zval *op1, *op2;
12992 double d1, d2;
12993
12994 op1 = EX_VAR(opline->op1.var);
12995 op2 = RT_CONSTANT(opline, opline->op2);
12996 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
12997 /* pass */
12998 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
12999 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13000 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13001 is_smaller_or_equal_true:
13002 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13003 ZVAL_TRUE(EX_VAR(opline->result.var));
13004 ZEND_VM_NEXT_OPCODE();
13005 } else {
13006 is_smaller_or_equal_false:
13007 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13008 ZVAL_FALSE(EX_VAR(opline->result.var));
13009 ZEND_VM_NEXT_OPCODE();
13010 }
13011 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13012 d1 = (double)Z_LVAL_P(op1);
13013 d2 = Z_DVAL_P(op2);
13014 goto is_smaller_or_equal_double;
13015 }
13016 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13017 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13018 d1 = Z_DVAL_P(op1);
13019 d2 = Z_DVAL_P(op2);
13020 is_smaller_or_equal_double:
13021 if (d1 <= d2) {
13022 goto is_smaller_or_equal_true;
13023 } else {
13024 goto is_smaller_or_equal_false;
13025 }
13026 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13027 d1 = Z_DVAL_P(op1);
13028 d2 = (double)Z_LVAL_P(op2);
13029 goto is_smaller_or_equal_double;
13030 }
13031 }
13032 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13033 }
13034
ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13035 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13036 {
13037 USE_OPLINE
13038 zval *op1, *op2;
13039
13040 op1 = EX_VAR(opline->op1.var);
13041 op2 = RT_CONSTANT(opline, opline->op2);
13042 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13043 /* pass */
13044 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13045 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13046 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
13047 ZEND_VM_NEXT_OPCODE();
13048 }
13049
13050 ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13051 }
13052
ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13053 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13054 {
13055 USE_OPLINE
13056 zval *op1, *op2;
13057
13058 op1 = EX_VAR(opline->op1.var);
13059 op2 = RT_CONSTANT(opline, opline->op2);
13060 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13061 /* pass */
13062 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13063 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13064 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
13065 ZEND_VM_NEXT_OPCODE();
13066 }
13067
13068 ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13069 }
13070
ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13071 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13072 {
13073 USE_OPLINE
13074 zval *op1, *op2;
13075
13076 op1 = EX_VAR(opline->op1.var);
13077 op2 = RT_CONSTANT(opline, opline->op2);
13078 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && IS_CONST == IS_CONST) {
13079 /* pass */
13080 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13081 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13082 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
13083 ZEND_VM_NEXT_OPCODE();
13084 }
13085
13086 ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13087 }
13088
ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13089 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13090 {
13091 USE_OPLINE
13092 zval *container;
13093
13094 SAVE_OPLINE();
13095 container = EX_VAR(opline->op1.var);
13096 zend_fetch_dimension_address_LIST_r(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
13097
13098 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
13099 }
13100
ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13101 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13102 {
13103 USE_OPLINE
13104 zval *op, *jump_zv;
13105 HashTable *jumptable;
13106
13107 op = EX_VAR(opline->op1.var);
13108
13109 if (Z_TYPE_P(op) != IS_LONG) {
13110 ZVAL_DEREF(op);
13111 if (Z_TYPE_P(op) != IS_LONG) {
13112 /* Wrong type, fall back to ZEND_CASE chain */
13113 ZEND_VM_NEXT_OPCODE();
13114 }
13115 }
13116
13117 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13118 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13119 if (jump_zv != NULL) {
13120 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13121 ZEND_VM_CONTINUE();
13122 } else {
13123 /* default */
13124 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13125 ZEND_VM_CONTINUE();
13126 }
13127 }
13128
ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13129 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13130 {
13131 USE_OPLINE
13132 zval *op, *jump_zv;
13133 HashTable *jumptable;
13134
13135 op = EX_VAR(opline->op1.var);
13136
13137 if (Z_TYPE_P(op) != IS_STRING) {
13138 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13139 /* Wrong type, fall back to ZEND_CASE chain */
13140 ZEND_VM_NEXT_OPCODE();
13141 } else {
13142 ZVAL_DEREF(op);
13143 if (Z_TYPE_P(op) != IS_STRING) {
13144 /* Wrong type, fall back to ZEND_CASE chain */
13145 ZEND_VM_NEXT_OPCODE();
13146 }
13147 }
13148 }
13149
13150 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13151 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13152 if (jump_zv != NULL) {
13153 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13154 ZEND_VM_CONTINUE();
13155 } else {
13156 /* default */
13157 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13158 ZEND_VM_CONTINUE();
13159 }
13160 }
13161
ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13162 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13163 {
13164 USE_OPLINE
13165 zval *op, *jump_zv;
13166 HashTable *jumptable;
13167
13168 op = EX_VAR(opline->op1.var);
13169 jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
13170
13171 match_try_again:
13172 if (Z_TYPE_P(op) == IS_LONG) {
13173 jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op));
13174 } else if (Z_TYPE_P(op) == IS_STRING) {
13175 jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST);
13176 } else if (Z_TYPE_P(op) == IS_REFERENCE) {
13177 op = Z_REFVAL_P(op);
13178 goto match_try_again;
13179 } else {
13180 if (UNEXPECTED(((IS_TMP_VAR|IS_VAR|IS_CV) & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) {
13181 SAVE_OPLINE();
13182 op = ZVAL_UNDEFINED_OP1();
13183 if (UNEXPECTED(EG(exception))) {
13184 HANDLE_EXCEPTION();
13185 }
13186 goto match_try_again;
13187 }
13188
13189 goto default_branch;
13190 }
13191
13192 if (jump_zv != NULL) {
13193 ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv));
13194 ZEND_VM_CONTINUE();
13195 } else {
13196 default_branch:
13197 /* default */
13198 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
13199 ZEND_VM_CONTINUE();
13200 }
13201 }
13202
ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13203 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13204 {
13205 USE_OPLINE
13206 zval *op1, *op2, *result;
13207
13208 op1 = EX_VAR(opline->op1.var);
13209 op2 = RT_CONSTANT(opline, opline->op2);
13210 result = EX_VAR(opline->result.var);
13211 ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
13212 ZEND_VM_NEXT_OPCODE();
13213 }
13214
ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13215 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13216 {
13217 USE_OPLINE
13218 zval *op1, *op2, *result;
13219
13220 op1 = EX_VAR(opline->op1.var);
13221 op2 = RT_CONSTANT(opline, opline->op2);
13222 result = EX_VAR(opline->result.var);
13223 fast_long_add_function(result, op1, op2);
13224 ZEND_VM_NEXT_OPCODE();
13225 }
13226
ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13227 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13228 {
13229 USE_OPLINE
13230 zval *op1, *op2, *result;
13231
13232 op1 = EX_VAR(opline->op1.var);
13233 op2 = RT_CONSTANT(opline, opline->op2);
13234 result = EX_VAR(opline->result.var);
13235 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
13236 ZEND_VM_NEXT_OPCODE();
13237 }
13238
ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13239 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13240 {
13241 USE_OPLINE
13242 zval *op1, *op2, *result;
13243
13244 op1 = EX_VAR(opline->op1.var);
13245 op2 = RT_CONSTANT(opline, opline->op2);
13246 result = EX_VAR(opline->result.var);
13247 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
13248 ZEND_VM_NEXT_OPCODE();
13249 }
13250
ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13251 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13252 {
13253 USE_OPLINE
13254 zval *op1, *op2, *result;
13255
13256 op1 = EX_VAR(opline->op1.var);
13257 op2 = RT_CONSTANT(opline, opline->op2);
13258 result = EX_VAR(opline->result.var);
13259 fast_long_sub_function(result, op1, op2);
13260 ZEND_VM_NEXT_OPCODE();
13261 }
13262
ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13263 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13264 {
13265 USE_OPLINE
13266 zval *op1, *op2, *result;
13267
13268 op1 = EX_VAR(opline->op1.var);
13269 op2 = RT_CONSTANT(opline, opline->op2);
13270 result = EX_VAR(opline->result.var);
13271 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
13272 ZEND_VM_NEXT_OPCODE();
13273 }
13274
ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13275 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13276 {
13277 USE_OPLINE
13278 zval *op1, *op2, *result;
13279
13280 op1 = EX_VAR(opline->op1.var);
13281 op2 = RT_CONSTANT(opline, opline->op2);
13282 result = EX_VAR(opline->result.var);
13283 ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
13284 ZEND_VM_NEXT_OPCODE();
13285 }
13286
ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13287 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13288 {
13289 USE_OPLINE
13290 zval *op1, *op2, *result;
13291 zend_long overflow;
13292
13293 op1 = EX_VAR(opline->op1.var);
13294 op2 = RT_CONSTANT(opline, opline->op2);
13295 result = EX_VAR(opline->result.var);
13296 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13297 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13298 ZEND_VM_NEXT_OPCODE();
13299 }
13300
ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13301 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13302 {
13303 USE_OPLINE
13304 zval *op1, *op2, *result;
13305
13306 op1 = EX_VAR(opline->op1.var);
13307 op2 = RT_CONSTANT(opline, opline->op2);
13308 result = EX_VAR(opline->result.var);
13309 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
13310 ZEND_VM_NEXT_OPCODE();
13311 }
13312
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13313 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13314 {
13315 USE_OPLINE
13316 zval *op1, *op2;
13317 bool result;
13318
13319 op1 = EX_VAR(opline->op1.var);
13320 op2 = RT_CONSTANT(opline, opline->op2);
13321 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13322 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13323 }
13324
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13325 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13326 {
13327 USE_OPLINE
13328 zval *op1, *op2;
13329 bool result;
13330
13331 op1 = EX_VAR(opline->op1.var);
13332 op2 = RT_CONSTANT(opline, opline->op2);
13333 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13334 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13335 }
13336
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13337 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13338 {
13339 USE_OPLINE
13340 zval *op1, *op2;
13341 bool result;
13342
13343 op1 = EX_VAR(opline->op1.var);
13344 op2 = RT_CONSTANT(opline, opline->op2);
13345 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
13346 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13347 }
13348
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13349 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13350 {
13351 USE_OPLINE
13352 zval *op1, *op2;
13353 bool result;
13354
13355 op1 = EX_VAR(opline->op1.var);
13356 op2 = RT_CONSTANT(opline, opline->op2);
13357 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13358 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13359 }
13360
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13361 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13362 {
13363 USE_OPLINE
13364 zval *op1, *op2;
13365 bool result;
13366
13367 op1 = EX_VAR(opline->op1.var);
13368 op2 = RT_CONSTANT(opline, opline->op2);
13369 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13370 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13371 }
13372
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13373 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13374 {
13375 USE_OPLINE
13376 zval *op1, *op2;
13377 bool result;
13378
13379 op1 = EX_VAR(opline->op1.var);
13380 op2 = RT_CONSTANT(opline, opline->op2);
13381 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
13382 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13383 }
13384
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13385 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13386 {
13387 USE_OPLINE
13388 zval *op1, *op2;
13389 bool result;
13390
13391 op1 = EX_VAR(opline->op1.var);
13392 op2 = RT_CONSTANT(opline, opline->op2);
13393 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13394 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13395 }
13396
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13397 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13398 {
13399 USE_OPLINE
13400 zval *op1, *op2;
13401 bool result;
13402
13403 op1 = EX_VAR(opline->op1.var);
13404 op2 = RT_CONSTANT(opline, opline->op2);
13405 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13406 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13407 }
13408
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13409 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13410 {
13411 USE_OPLINE
13412 zval *op1, *op2;
13413 bool result;
13414
13415 op1 = EX_VAR(opline->op1.var);
13416 op2 = RT_CONSTANT(opline, opline->op2);
13417 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
13418 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13419 }
13420
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13421 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13422 {
13423 USE_OPLINE
13424 zval *op1, *op2;
13425 bool result;
13426
13427 op1 = EX_VAR(opline->op1.var);
13428 op2 = RT_CONSTANT(opline, opline->op2);
13429 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13430 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13431 }
13432
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13433 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13434 {
13435 USE_OPLINE
13436 zval *op1, *op2;
13437 bool result;
13438
13439 op1 = EX_VAR(opline->op1.var);
13440 op2 = RT_CONSTANT(opline, opline->op2);
13441 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13442 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13443 }
13444
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13445 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13446 {
13447 USE_OPLINE
13448 zval *op1, *op2;
13449 bool result;
13450
13451 op1 = EX_VAR(opline->op1.var);
13452 op2 = RT_CONSTANT(opline, opline->op2);
13453 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
13454 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13455 }
13456
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13457 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13458 {
13459 USE_OPLINE
13460 zval *op1, *op2;
13461 bool result;
13462
13463 op1 = EX_VAR(opline->op1.var);
13464 op2 = RT_CONSTANT(opline, opline->op2);
13465 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13466 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13467 }
13468
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13469 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13470 {
13471 USE_OPLINE
13472 zval *op1, *op2;
13473 bool result;
13474
13475 op1 = EX_VAR(opline->op1.var);
13476 op2 = RT_CONSTANT(opline, opline->op2);
13477 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13478 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13479 }
13480
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13481 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13482 {
13483 USE_OPLINE
13484 zval *op1, *op2;
13485 bool result;
13486
13487 op1 = EX_VAR(opline->op1.var);
13488 op2 = RT_CONSTANT(opline, opline->op2);
13489 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
13490 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13491 }
13492
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13493 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13494 {
13495 USE_OPLINE
13496 zval *op1, *op2;
13497 bool result;
13498
13499 op1 = EX_VAR(opline->op1.var);
13500 op2 = RT_CONSTANT(opline, opline->op2);
13501 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13502 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13503 }
13504
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13505 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13506 {
13507 USE_OPLINE
13508 zval *op1, *op2;
13509 bool result;
13510
13511 op1 = EX_VAR(opline->op1.var);
13512 op2 = RT_CONSTANT(opline, opline->op2);
13513 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13514 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13515 }
13516
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13517 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13518 {
13519 USE_OPLINE
13520 zval *op1, *op2;
13521 bool result;
13522
13523 op1 = EX_VAR(opline->op1.var);
13524 op2 = RT_CONSTANT(opline, opline->op2);
13525 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
13526 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13527 }
13528
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13529 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13530 {
13531 USE_OPLINE
13532 zval *op1, *op2;
13533 bool result;
13534
13535 op1 = EX_VAR(opline->op1.var);
13536 op2 = RT_CONSTANT(opline, opline->op2);
13537 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13538 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13539 }
13540
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13541 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)
13542 {
13543 USE_OPLINE
13544 zval *op1, *op2;
13545 bool result;
13546
13547 op1 = EX_VAR(opline->op1.var);
13548 op2 = RT_CONSTANT(opline, opline->op2);
13549 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13550 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13551 }
13552
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13553 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)
13554 {
13555 USE_OPLINE
13556 zval *op1, *op2;
13557 bool result;
13558
13559 op1 = EX_VAR(opline->op1.var);
13560 op2 = RT_CONSTANT(opline, opline->op2);
13561 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
13562 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13563 }
13564
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13565 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13566 {
13567 USE_OPLINE
13568 zval *op1, *op2;
13569 bool result;
13570
13571 op1 = EX_VAR(opline->op1.var);
13572 op2 = RT_CONSTANT(opline, opline->op2);
13573 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13574 ZEND_VM_SMART_BRANCH_NONE(result, 0);
13575 }
13576
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13577 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)
13578 {
13579 USE_OPLINE
13580 zval *op1, *op2;
13581 bool result;
13582
13583 op1 = EX_VAR(opline->op1.var);
13584 op2 = RT_CONSTANT(opline, opline->op2);
13585 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13586 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
13587 }
13588
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13589 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)
13590 {
13591 USE_OPLINE
13592 zval *op1, *op2;
13593 bool result;
13594
13595 op1 = EX_VAR(opline->op1.var);
13596 op2 = RT_CONSTANT(opline, opline->op2);
13597 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
13598 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
13599 }
13600
ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13601 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13602 {
13603 USE_OPLINE
13604 zval *op1, *op2, *result;
13605 double d1, d2;
13606
13607 op1 = EX_VAR(opline->op1.var);
13608 op2 = EX_VAR(opline->op2.var);
13609 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13610 /* pass */
13611 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13612 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13613 result = EX_VAR(opline->result.var);
13614 fast_long_add_function(result, op1, op2);
13615 ZEND_VM_NEXT_OPCODE();
13616 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13617 d1 = (double)Z_LVAL_P(op1);
13618 d2 = Z_DVAL_P(op2);
13619 goto add_double;
13620 }
13621 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13622 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13623 d1 = Z_DVAL_P(op1);
13624 d2 = Z_DVAL_P(op2);
13625 add_double:
13626 result = EX_VAR(opline->result.var);
13627 ZVAL_DOUBLE(result, d1 + d2);
13628 ZEND_VM_NEXT_OPCODE();
13629 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13630 d1 = Z_DVAL_P(op1);
13631 d2 = (double)Z_LVAL_P(op2);
13632 goto add_double;
13633 }
13634 }
13635
13636 ZEND_VM_TAIL_CALL(zend_add_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13637 }
13638
ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13639 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13640 {
13641 USE_OPLINE
13642 zval *op1, *op2, *result;
13643 double d1, d2;
13644
13645 op1 = EX_VAR(opline->op1.var);
13646 op2 = EX_VAR(opline->op2.var);
13647 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13648 /* pass */
13649 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13650 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13651 result = EX_VAR(opline->result.var);
13652 fast_long_sub_function(result, op1, op2);
13653 ZEND_VM_NEXT_OPCODE();
13654 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13655 d1 = (double)Z_LVAL_P(op1);
13656 d2 = Z_DVAL_P(op2);
13657 goto sub_double;
13658 }
13659 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13660 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13661 d1 = Z_DVAL_P(op1);
13662 d2 = Z_DVAL_P(op2);
13663 sub_double:
13664 result = EX_VAR(opline->result.var);
13665 ZVAL_DOUBLE(result, d1 - d2);
13666 ZEND_VM_NEXT_OPCODE();
13667 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13668 d1 = Z_DVAL_P(op1);
13669 d2 = (double)Z_LVAL_P(op2);
13670 goto sub_double;
13671 }
13672 }
13673
13674 ZEND_VM_TAIL_CALL(zend_sub_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13675 }
13676
ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13677 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13678 {
13679 USE_OPLINE
13680 zval *op1, *op2, *result;
13681 double d1, d2;
13682
13683 op1 = EX_VAR(opline->op1.var);
13684 op2 = EX_VAR(opline->op2.var);
13685 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13686 /* pass */
13687 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13688 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13689 zend_long overflow;
13690
13691 result = EX_VAR(opline->result.var);
13692 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
13693 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
13694 ZEND_VM_NEXT_OPCODE();
13695 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13696 d1 = (double)Z_LVAL_P(op1);
13697 d2 = Z_DVAL_P(op2);
13698 goto mul_double;
13699 }
13700 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13701 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13702 d1 = Z_DVAL_P(op1);
13703 d2 = Z_DVAL_P(op2);
13704 mul_double:
13705 result = EX_VAR(opline->result.var);
13706 ZVAL_DOUBLE(result, d1 * d2);
13707 ZEND_VM_NEXT_OPCODE();
13708 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13709 d1 = Z_DVAL_P(op1);
13710 d2 = (double)Z_LVAL_P(op2);
13711 goto mul_double;
13712 }
13713 }
13714
13715 ZEND_VM_TAIL_CALL(zend_mul_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13716 }
13717
ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13718 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13719 {
13720 USE_OPLINE
13721 zval *op1, *op2, *result;
13722
13723 op1 = EX_VAR(opline->op1.var);
13724 op2 = EX_VAR(opline->op2.var);
13725 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13726 /* pass */
13727 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13728 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13729 result = EX_VAR(opline->result.var);
13730 if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
13731 ZEND_VM_TAIL_CALL(zend_mod_by_zero_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
13732 } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
13733 /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
13734 ZVAL_LONG(result, 0);
13735 } else {
13736 ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
13737 }
13738 ZEND_VM_NEXT_OPCODE();
13739 }
13740 }
13741
13742 ZEND_VM_TAIL_CALL(zend_mod_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13743 }
13744
ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13745 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13746 {
13747 USE_OPLINE
13748 zval *op1, *op2;
13749
13750 op1 = EX_VAR(opline->op1.var);
13751 op2 = EX_VAR(opline->op2.var);
13752 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13753 /* pass */
13754 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13755 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13756 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13757 /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
13758 ZVAL_LONG(EX_VAR(opline->result.var),
13759 (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
13760 ZEND_VM_NEXT_OPCODE();
13761 }
13762
13763 ZEND_VM_TAIL_CALL(zend_shift_left_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13764 }
13765
ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13766 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13767 {
13768 USE_OPLINE
13769 zval *op1, *op2;
13770
13771 op1 = EX_VAR(opline->op1.var);
13772 op2 = EX_VAR(opline->op2.var);
13773 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13774 /* pass */
13775 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
13776 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
13777 && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
13778 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
13779 ZEND_VM_NEXT_OPCODE();
13780 }
13781
13782 ZEND_VM_TAIL_CALL(zend_shift_right_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13783 }
13784
ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13785 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13786 {
13787 USE_OPLINE
13788 zval *op1, *op2;
13789 double d1, d2;
13790
13791 op1 = EX_VAR(opline->op1.var);
13792 op2 = EX_VAR(opline->op2.var);
13793 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13794 /* pass */
13795 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13796 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13797 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13798 is_smaller_true:
13799 ZEND_VM_SMART_BRANCH_TRUE_NONE();
13800 } else {
13801 is_smaller_false:
13802 ZEND_VM_SMART_BRANCH_FALSE_NONE();
13803 }
13804 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13805 d1 = (double)Z_LVAL_P(op1);
13806 d2 = Z_DVAL_P(op2);
13807 goto is_smaller_double;
13808 }
13809 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13810 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13811 d1 = Z_DVAL_P(op1);
13812 d2 = Z_DVAL_P(op2);
13813 is_smaller_double:
13814 if (d1 < d2) {
13815 goto is_smaller_true;
13816 } else {
13817 goto is_smaller_false;
13818 }
13819 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13820 d1 = Z_DVAL_P(op1);
13821 d2 = (double)Z_LVAL_P(op2);
13822 goto is_smaller_double;
13823 }
13824 }
13825 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13826 }
13827
ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13828 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13829 {
13830 USE_OPLINE
13831 zval *op1, *op2;
13832 double d1, d2;
13833
13834 op1 = EX_VAR(opline->op1.var);
13835 op2 = EX_VAR(opline->op2.var);
13836 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13837 /* pass */
13838 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13839 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13840 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13841 is_smaller_true:
13842 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13843 } else {
13844 is_smaller_false:
13845 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13846 }
13847 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13848 d1 = (double)Z_LVAL_P(op1);
13849 d2 = Z_DVAL_P(op2);
13850 goto is_smaller_double;
13851 }
13852 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13853 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13854 d1 = Z_DVAL_P(op1);
13855 d2 = Z_DVAL_P(op2);
13856 is_smaller_double:
13857 if (d1 < d2) {
13858 goto is_smaller_true;
13859 } else {
13860 goto is_smaller_false;
13861 }
13862 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13863 d1 = Z_DVAL_P(op1);
13864 d2 = (double)Z_LVAL_P(op2);
13865 goto is_smaller_double;
13866 }
13867 }
13868 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13869 }
13870
ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13871 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13872 {
13873 USE_OPLINE
13874 zval *op1, *op2;
13875 double d1, d2;
13876
13877 op1 = EX_VAR(opline->op1.var);
13878 op2 = EX_VAR(opline->op2.var);
13879 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13880 /* pass */
13881 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13882 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13883 if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
13884 is_smaller_true:
13885 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
13886 } else {
13887 is_smaller_false:
13888 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
13889 }
13890 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13891 d1 = (double)Z_LVAL_P(op1);
13892 d2 = Z_DVAL_P(op2);
13893 goto is_smaller_double;
13894 }
13895 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13896 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13897 d1 = Z_DVAL_P(op1);
13898 d2 = Z_DVAL_P(op2);
13899 is_smaller_double:
13900 if (d1 < d2) {
13901 goto is_smaller_true;
13902 } else {
13903 goto is_smaller_false;
13904 }
13905 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13906 d1 = Z_DVAL_P(op1);
13907 d2 = (double)Z_LVAL_P(op2);
13908 goto is_smaller_double;
13909 }
13910 }
13911 ZEND_VM_TAIL_CALL(zend_is_smaller_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13912 }
13913
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13914 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13915 {
13916 USE_OPLINE
13917 zval *op1, *op2;
13918 double d1, d2;
13919
13920 op1 = EX_VAR(opline->op1.var);
13921 op2 = EX_VAR(opline->op2.var);
13922 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13923 /* pass */
13924 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13925 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13926 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13927 is_smaller_or_equal_true:
13928 ZEND_VM_SMART_BRANCH_TRUE_NONE();
13929 ZVAL_TRUE(EX_VAR(opline->result.var));
13930 ZEND_VM_NEXT_OPCODE();
13931 } else {
13932 is_smaller_or_equal_false:
13933 ZEND_VM_SMART_BRANCH_FALSE_NONE();
13934 ZVAL_FALSE(EX_VAR(opline->result.var));
13935 ZEND_VM_NEXT_OPCODE();
13936 }
13937 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13938 d1 = (double)Z_LVAL_P(op1);
13939 d2 = Z_DVAL_P(op2);
13940 goto is_smaller_or_equal_double;
13941 }
13942 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13943 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13944 d1 = Z_DVAL_P(op1);
13945 d2 = Z_DVAL_P(op2);
13946 is_smaller_or_equal_double:
13947 if (d1 <= d2) {
13948 goto is_smaller_or_equal_true;
13949 } else {
13950 goto is_smaller_or_equal_false;
13951 }
13952 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13953 d1 = Z_DVAL_P(op1);
13954 d2 = (double)Z_LVAL_P(op2);
13955 goto is_smaller_or_equal_double;
13956 }
13957 }
13958 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
13959 }
13960
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)13961 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
13962 {
13963 USE_OPLINE
13964 zval *op1, *op2;
13965 double d1, d2;
13966
13967 op1 = EX_VAR(opline->op1.var);
13968 op2 = EX_VAR(opline->op2.var);
13969 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
13970 /* pass */
13971 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
13972 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
13973 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
13974 is_smaller_or_equal_true:
13975 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
13976 ZVAL_TRUE(EX_VAR(opline->result.var));
13977 ZEND_VM_NEXT_OPCODE();
13978 } else {
13979 is_smaller_or_equal_false:
13980 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
13981 ZVAL_FALSE(EX_VAR(opline->result.var));
13982 ZEND_VM_NEXT_OPCODE();
13983 }
13984 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13985 d1 = (double)Z_LVAL_P(op1);
13986 d2 = Z_DVAL_P(op2);
13987 goto is_smaller_or_equal_double;
13988 }
13989 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
13990 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
13991 d1 = Z_DVAL_P(op1);
13992 d2 = Z_DVAL_P(op2);
13993 is_smaller_or_equal_double:
13994 if (d1 <= d2) {
13995 goto is_smaller_or_equal_true;
13996 } else {
13997 goto is_smaller_or_equal_false;
13998 }
13999 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14000 d1 = Z_DVAL_P(op1);
14001 d2 = (double)Z_LVAL_P(op2);
14002 goto is_smaller_or_equal_double;
14003 }
14004 }
14005 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14006 }
14007
ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14008 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14009 {
14010 USE_OPLINE
14011 zval *op1, *op2;
14012 double d1, d2;
14013
14014 op1 = EX_VAR(opline->op1.var);
14015 op2 = EX_VAR(opline->op2.var);
14016 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14017 /* pass */
14018 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
14019 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14020 if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
14021 is_smaller_or_equal_true:
14022 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
14023 ZVAL_TRUE(EX_VAR(opline->result.var));
14024 ZEND_VM_NEXT_OPCODE();
14025 } else {
14026 is_smaller_or_equal_false:
14027 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
14028 ZVAL_FALSE(EX_VAR(opline->result.var));
14029 ZEND_VM_NEXT_OPCODE();
14030 }
14031 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14032 d1 = (double)Z_LVAL_P(op1);
14033 d2 = Z_DVAL_P(op2);
14034 goto is_smaller_or_equal_double;
14035 }
14036 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
14037 if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
14038 d1 = Z_DVAL_P(op1);
14039 d2 = Z_DVAL_P(op2);
14040 is_smaller_or_equal_double:
14041 if (d1 <= d2) {
14042 goto is_smaller_or_equal_true;
14043 } else {
14044 goto is_smaller_or_equal_false;
14045 }
14046 } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14047 d1 = Z_DVAL_P(op1);
14048 d2 = (double)Z_LVAL_P(op2);
14049 goto is_smaller_or_equal_double;
14050 }
14051 }
14052 ZEND_VM_TAIL_CALL(zend_is_smaller_or_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14053 }
14054
ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14055 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14056 {
14057 USE_OPLINE
14058 zval *op1, *op2;
14059
14060 op1 = EX_VAR(opline->op1.var);
14061 op2 = EX_VAR(opline->op2.var);
14062 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14063 /* pass */
14064 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14065 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14066 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
14067 ZEND_VM_NEXT_OPCODE();
14068 }
14069
14070 ZEND_VM_TAIL_CALL(zend_bw_or_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14071 }
14072
ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14073 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14074 {
14075 USE_OPLINE
14076 zval *op1, *op2;
14077
14078 op1 = EX_VAR(opline->op1.var);
14079 op2 = EX_VAR(opline->op2.var);
14080 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14081 /* pass */
14082 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14083 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14084 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
14085 ZEND_VM_NEXT_OPCODE();
14086 }
14087
14088 ZEND_VM_TAIL_CALL(zend_bw_and_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14089 }
14090
ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14091 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14092 {
14093 USE_OPLINE
14094 zval *op1, *op2;
14095
14096 op1 = EX_VAR(opline->op1.var);
14097 op2 = EX_VAR(opline->op2.var);
14098 if (1 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
14099 /* pass */
14100 } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
14101 && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
14102 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
14103 ZEND_VM_NEXT_OPCODE();
14104 }
14105
14106 ZEND_VM_TAIL_CALL(zend_bw_xor_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
14107 }
14108
ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14109 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14110 {
14111 USE_OPLINE
14112 zval *op1, *op2, *result;
14113
14114 op1 = EX_VAR(opline->op1.var);
14115 op2 = EX_VAR(opline->op2.var);
14116 result = EX_VAR(opline->result.var);
14117 ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
14118 ZEND_VM_NEXT_OPCODE();
14119 }
14120
ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14121 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14122 {
14123 USE_OPLINE
14124 zval *op1, *op2, *result;
14125
14126 op1 = EX_VAR(opline->op1.var);
14127 op2 = EX_VAR(opline->op2.var);
14128 result = EX_VAR(opline->result.var);
14129 fast_long_add_function(result, op1, op2);
14130 ZEND_VM_NEXT_OPCODE();
14131 }
14132
ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14133 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14134 {
14135 USE_OPLINE
14136 zval *op1, *op2, *result;
14137
14138 op1 = EX_VAR(opline->op1.var);
14139 op2 = EX_VAR(opline->op2.var);
14140 result = EX_VAR(opline->result.var);
14141 ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
14142 ZEND_VM_NEXT_OPCODE();
14143 }
14144
ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14145 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14146 {
14147 USE_OPLINE
14148 zval *op1, *op2, *result;
14149
14150 op1 = EX_VAR(opline->op1.var);
14151 op2 = EX_VAR(opline->op2.var);
14152 result = EX_VAR(opline->result.var);
14153 ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
14154 ZEND_VM_NEXT_OPCODE();
14155 }
14156
ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14157 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14158 {
14159 USE_OPLINE
14160 zval *op1, *op2, *result;
14161
14162 op1 = EX_VAR(opline->op1.var);
14163 op2 = EX_VAR(opline->op2.var);
14164 result = EX_VAR(opline->result.var);
14165 fast_long_sub_function(result, op1, op2);
14166 ZEND_VM_NEXT_OPCODE();
14167 }
14168
ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14169 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14170 {
14171 USE_OPLINE
14172 zval *op1, *op2, *result;
14173
14174 op1 = EX_VAR(opline->op1.var);
14175 op2 = EX_VAR(opline->op2.var);
14176 result = EX_VAR(opline->result.var);
14177 ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
14178 ZEND_VM_NEXT_OPCODE();
14179 }
14180
ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14181 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14182 {
14183 USE_OPLINE
14184 zval *op1, *op2, *result;
14185
14186 op1 = EX_VAR(opline->op1.var);
14187 op2 = EX_VAR(opline->op2.var);
14188 result = EX_VAR(opline->result.var);
14189 ZVAL_LONG(result, Z_LVAL_P(op1) * Z_LVAL_P(op2));
14190 ZEND_VM_NEXT_OPCODE();
14191 }
14192
ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14193 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14194 {
14195 USE_OPLINE
14196 zval *op1, *op2, *result;
14197 zend_long overflow;
14198
14199 op1 = EX_VAR(opline->op1.var);
14200 op2 = EX_VAR(opline->op2.var);
14201 result = EX_VAR(opline->result.var);
14202 ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
14203 Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
14204 ZEND_VM_NEXT_OPCODE();
14205 }
14206
ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14207 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14208 {
14209 USE_OPLINE
14210 zval *op1, *op2, *result;
14211
14212 op1 = EX_VAR(opline->op1.var);
14213 op2 = EX_VAR(opline->op2.var);
14214 result = EX_VAR(opline->result.var);
14215 ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
14216 ZEND_VM_NEXT_OPCODE();
14217 }
14218
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14219 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14220 {
14221 USE_OPLINE
14222 zval *op1, *op2;
14223 bool result;
14224
14225 op1 = EX_VAR(opline->op1.var);
14226 op2 = EX_VAR(opline->op2.var);
14227 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14228 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14229 }
14230
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14231 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14232 {
14233 USE_OPLINE
14234 zval *op1, *op2;
14235 bool result;
14236
14237 op1 = EX_VAR(opline->op1.var);
14238 op2 = EX_VAR(opline->op2.var);
14239 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14240 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14241 }
14242
ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14243 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14244 {
14245 USE_OPLINE
14246 zval *op1, *op2;
14247 bool result;
14248
14249 op1 = EX_VAR(opline->op1.var);
14250 op2 = EX_VAR(opline->op2.var);
14251 result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
14252 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14253 }
14254
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14255 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14256 {
14257 USE_OPLINE
14258 zval *op1, *op2;
14259 bool result;
14260
14261 op1 = EX_VAR(opline->op1.var);
14262 op2 = EX_VAR(opline->op2.var);
14263 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14264 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14265 }
14266
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14267 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14268 {
14269 USE_OPLINE
14270 zval *op1, *op2;
14271 bool result;
14272
14273 op1 = EX_VAR(opline->op1.var);
14274 op2 = EX_VAR(opline->op2.var);
14275 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14276 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14277 }
14278
ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14279 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14280 {
14281 USE_OPLINE
14282 zval *op1, *op2;
14283 bool result;
14284
14285 op1 = EX_VAR(opline->op1.var);
14286 op2 = EX_VAR(opline->op2.var);
14287 result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
14288 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14289 }
14290
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14291 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14292 {
14293 USE_OPLINE
14294 zval *op1, *op2;
14295 bool result;
14296
14297 op1 = EX_VAR(opline->op1.var);
14298 op2 = EX_VAR(opline->op2.var);
14299 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14300 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14301 }
14302
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14303 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14304 {
14305 USE_OPLINE
14306 zval *op1, *op2;
14307 bool result;
14308
14309 op1 = EX_VAR(opline->op1.var);
14310 op2 = EX_VAR(opline->op2.var);
14311 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14312 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14313 }
14314
ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14315 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14316 {
14317 USE_OPLINE
14318 zval *op1, *op2;
14319 bool result;
14320
14321 op1 = EX_VAR(opline->op1.var);
14322 op2 = EX_VAR(opline->op2.var);
14323 result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
14324 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14325 }
14326
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14327 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14328 {
14329 USE_OPLINE
14330 zval *op1, *op2;
14331 bool result;
14332
14333 op1 = EX_VAR(opline->op1.var);
14334 op2 = EX_VAR(opline->op2.var);
14335 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14336 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14337 }
14338
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14339 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14340 {
14341 USE_OPLINE
14342 zval *op1, *op2;
14343 bool result;
14344
14345 op1 = EX_VAR(opline->op1.var);
14346 op2 = EX_VAR(opline->op2.var);
14347 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14348 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14349 }
14350
ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14351 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14352 {
14353 USE_OPLINE
14354 zval *op1, *op2;
14355 bool result;
14356
14357 op1 = EX_VAR(opline->op1.var);
14358 op2 = EX_VAR(opline->op2.var);
14359 result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
14360 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14361 }
14362
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14363 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14364 {
14365 USE_OPLINE
14366 zval *op1, *op2;
14367 bool result;
14368
14369 op1 = EX_VAR(opline->op1.var);
14370 op2 = EX_VAR(opline->op2.var);
14371 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14372 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14373 }
14374
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14375 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14376 {
14377 USE_OPLINE
14378 zval *op1, *op2;
14379 bool result;
14380
14381 op1 = EX_VAR(opline->op1.var);
14382 op2 = EX_VAR(opline->op2.var);
14383 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14384 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14385 }
14386
ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14387 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14388 {
14389 USE_OPLINE
14390 zval *op1, *op2;
14391 bool result;
14392
14393 op1 = EX_VAR(opline->op1.var);
14394 op2 = EX_VAR(opline->op2.var);
14395 result = (Z_LVAL_P(op1) < Z_LVAL_P(op2));
14396 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14397 }
14398
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14399 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14400 {
14401 USE_OPLINE
14402 zval *op1, *op2;
14403 bool result;
14404
14405 op1 = EX_VAR(opline->op1.var);
14406 op2 = EX_VAR(opline->op2.var);
14407 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14408 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14409 }
14410
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14411 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14412 {
14413 USE_OPLINE
14414 zval *op1, *op2;
14415 bool result;
14416
14417 op1 = EX_VAR(opline->op1.var);
14418 op2 = EX_VAR(opline->op2.var);
14419 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14420 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14421 }
14422
ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14423 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14424 {
14425 USE_OPLINE
14426 zval *op1, *op2;
14427 bool result;
14428
14429 op1 = EX_VAR(opline->op1.var);
14430 op2 = EX_VAR(opline->op2.var);
14431 result = (Z_DVAL_P(op1) < Z_DVAL_P(op2));
14432 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14433 }
14434
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14435 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14436 {
14437 USE_OPLINE
14438 zval *op1, *op2;
14439 bool result;
14440
14441 op1 = EX_VAR(opline->op1.var);
14442 op2 = EX_VAR(opline->op2.var);
14443 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14444 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14445 }
14446
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14447 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)
14448 {
14449 USE_OPLINE
14450 zval *op1, *op2;
14451 bool result;
14452
14453 op1 = EX_VAR(opline->op1.var);
14454 op2 = EX_VAR(opline->op2.var);
14455 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14456 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14457 }
14458
ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14459 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)
14460 {
14461 USE_OPLINE
14462 zval *op1, *op2;
14463 bool result;
14464
14465 op1 = EX_VAR(opline->op1.var);
14466 op2 = EX_VAR(opline->op2.var);
14467 result = (Z_LVAL_P(op1) <= Z_LVAL_P(op2));
14468 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14469 }
14470
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14471 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14472 {
14473 USE_OPLINE
14474 zval *op1, *op2;
14475 bool result;
14476
14477 op1 = EX_VAR(opline->op1.var);
14478 op2 = EX_VAR(opline->op2.var);
14479 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14480 ZEND_VM_SMART_BRANCH_NONE(result, 0);
14481 }
14482
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14483 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)
14484 {
14485 USE_OPLINE
14486 zval *op1, *op2;
14487 bool result;
14488
14489 op1 = EX_VAR(opline->op1.var);
14490 op2 = EX_VAR(opline->op2.var);
14491 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14492 ZEND_VM_SMART_BRANCH_JMPZ(result, 0);
14493 }
14494
ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14495 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)
14496 {
14497 USE_OPLINE
14498 zval *op1, *op2;
14499 bool result;
14500
14501 op1 = EX_VAR(opline->op1.var);
14502 op2 = EX_VAR(opline->op2.var);
14503 result = (Z_DVAL_P(op1) <= Z_DVAL_P(op2));
14504 ZEND_VM_SMART_BRANCH_JMPNZ(result, 0);
14505 }
14506
ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14507 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14508 {
14509 USE_OPLINE
14510 zval *container;
14511
14512 SAVE_OPLINE();
14513 container = EX_VAR(opline->op1.var);
14514 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);
14515 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
14516 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14517 }
14518
ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14519 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14520 {
14521 USE_OPLINE
14522 zval *op;
14523
14524 SAVE_OPLINE();
14525 op = EX_VAR(opline->op1.var);
14526 zend_match_unhandled_error(op);
14527 HANDLE_EXCEPTION();
14528 }
14529
ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14530 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14531 {
14532 USE_OPLINE
14533 zval *container;
14534
14535 SAVE_OPLINE();
14536 container = EX_VAR(opline->op1.var);
14537 zend_fetch_dimension_address_LIST_r(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
14538
14539 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14540 }
14541
ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14542 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14543 {
14544 USE_OPLINE
14545 zval *val;
14546
14547 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14548 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14549 ZVAL_FALSE(EX_VAR(opline->result.var));
14550 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14551 /* The result and op1 can be the same cv zval */
14552 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
14553 ZVAL_TRUE(EX_VAR(opline->result.var));
14554 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
14555 SAVE_OPLINE();
14556 ZVAL_UNDEFINED_OP1();
14557 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14558 }
14559 } else {
14560 SAVE_OPLINE();
14561 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
14562 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14563 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14564 }
14565 ZEND_VM_NEXT_OPCODE();
14566 }
14567
ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14568 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14569 {
14570 USE_OPLINE
14571 zval *z;
14572
14573 SAVE_OPLINE();
14574 z = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14575
14576 if (Z_TYPE_P(z) == IS_STRING) {
14577 zend_string *str = Z_STR_P(z);
14578
14579 if (ZSTR_LEN(str) != 0) {
14580 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
14581 }
14582 } else {
14583 zend_string *str = zval_get_string_func(z);
14584
14585 if (ZSTR_LEN(str) != 0) {
14586 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
14587 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
14588 ZVAL_UNDEFINED_OP1();
14589 }
14590 zend_string_release_ex(str, 0);
14591 }
14592
14593 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14594 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14595 }
14596
ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14597 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14598 {
14599 USE_OPLINE
14600 zval *val;
14601 uint8_t op1_type;
14602
14603 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14604
14605 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14606 ZEND_VM_NEXT_OPCODE();
14607 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14608 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
14609 SAVE_OPLINE();
14610 ZVAL_UNDEFINED_OP1();
14611 if (UNEXPECTED(EG(exception))) {
14612 HANDLE_EXCEPTION();
14613 }
14614 }
14615 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
14616 }
14617
14618 SAVE_OPLINE();
14619 op1_type = (IS_TMP_VAR|IS_VAR);
14620 if (i_zend_is_true(val)) {
14621 opline++;
14622 } else {
14623 opline = OP_JMP_ADDR(opline, opline->op2);
14624 }
14625 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
14626 zval_ptr_dtor_nogc(val);
14627 }
14628 ZEND_VM_JMP(opline);
14629 }
14630
ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14631 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14632 {
14633 USE_OPLINE
14634 zval *val;
14635 uint8_t op1_type;
14636
14637 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14638
14639 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14640 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
14641 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14642 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
14643 SAVE_OPLINE();
14644 ZVAL_UNDEFINED_OP1();
14645 if (UNEXPECTED(EG(exception))) {
14646 HANDLE_EXCEPTION();
14647 }
14648 }
14649 ZEND_VM_NEXT_OPCODE();
14650 }
14651
14652 SAVE_OPLINE();
14653 op1_type = (IS_TMP_VAR|IS_VAR);
14654 if (i_zend_is_true(val)) {
14655 opline = OP_JMP_ADDR(opline, opline->op2);
14656 } else {
14657 opline++;
14658 }
14659 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
14660 zval_ptr_dtor_nogc(val);
14661 }
14662 ZEND_VM_JMP(opline);
14663 }
14664
ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14665 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14666 {
14667 USE_OPLINE
14668 zval *val;
14669 bool ret;
14670
14671 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14672
14673 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14674 ZVAL_TRUE(EX_VAR(opline->result.var));
14675 ZEND_VM_NEXT_OPCODE();
14676 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14677 ZVAL_FALSE(EX_VAR(opline->result.var));
14678 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
14679 SAVE_OPLINE();
14680 ZVAL_UNDEFINED_OP1();
14681 if (UNEXPECTED(EG(exception))) {
14682 HANDLE_EXCEPTION();
14683 }
14684 }
14685 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
14686 }
14687
14688 SAVE_OPLINE();
14689 ret = i_zend_is_true(val);
14690 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14691 if (ret) {
14692 ZVAL_TRUE(EX_VAR(opline->result.var));
14693 opline++;
14694 } else {
14695 ZVAL_FALSE(EX_VAR(opline->result.var));
14696 opline = OP_JMP_ADDR(opline, opline->op2);
14697 }
14698 ZEND_VM_JMP(opline);
14699 }
14700
ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14701 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14702 {
14703 USE_OPLINE
14704 zval *val;
14705 bool ret;
14706
14707 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14708
14709 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14710 ZVAL_TRUE(EX_VAR(opline->result.var));
14711 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
14712 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14713 ZVAL_FALSE(EX_VAR(opline->result.var));
14714 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
14715 SAVE_OPLINE();
14716 ZVAL_UNDEFINED_OP1();
14717 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14718 } else {
14719 ZEND_VM_NEXT_OPCODE();
14720 }
14721 }
14722
14723 SAVE_OPLINE();
14724 ret = i_zend_is_true(val);
14725 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14726 if (ret) {
14727 ZVAL_TRUE(EX_VAR(opline->result.var));
14728 opline = OP_JMP_ADDR(opline, opline->op2);
14729 } else {
14730 ZVAL_FALSE(EX_VAR(opline->result.var));
14731 opline++;
14732 }
14733 ZEND_VM_JMP(opline);
14734 }
14735
ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14736 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14737 {
14738 USE_OPLINE
14739
14740 SAVE_OPLINE();
14741 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14742 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14743 }
14744
ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14745 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14746 {
14747 zval *var;
14748 USE_OPLINE
14749
14750 var = EX_VAR(opline->op1.var);
14751 if (Z_TYPE_P(var) != IS_ARRAY) {
14752 SAVE_OPLINE();
14753 if (Z_FE_ITER_P(var) != (uint32_t)-1) {
14754 zend_hash_iterator_del(Z_FE_ITER_P(var));
14755 }
14756 zval_ptr_dtor_nogc(var);
14757 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14758 }
14759
14760 /* This is freeing an array. Use an inlined version of zval_ptr_dtor_nogc. */
14761 /* 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) */
14762 if (Z_REFCOUNTED_P(var) && !Z_DELREF_P(var)) {
14763 SAVE_OPLINE();
14764 rc_dtor_func(Z_COUNTED_P(var));
14765 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14766 }
14767 ZEND_VM_NEXT_OPCODE();
14768 }
14769
ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14770 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14771 {
14772 USE_OPLINE
14773 zval *value;
14774
14775 SAVE_OPLINE();
14776 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14777
14778 do {
14779 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
14780 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
14781 value = Z_REFVAL_P(value);
14782 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
14783 break;
14784 }
14785 }
14786 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
14787 ZVAL_UNDEFINED_OP1();
14788 if (UNEXPECTED(EG(exception) != NULL)) {
14789 HANDLE_EXCEPTION();
14790 }
14791 }
14792 zend_throw_error(NULL, "Can only throw objects");
14793 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14794 HANDLE_EXCEPTION();
14795 }
14796 } while (0);
14797
14798 zend_exception_save();
14799 Z_TRY_ADDREF_P(value);
14800 zend_throw_exception_object(value);
14801 zend_exception_restore();
14802 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14803 HANDLE_EXCEPTION();
14804 }
14805
ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14806 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14807 {
14808 USE_OPLINE
14809 zval *val;
14810
14811 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14812 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
14813 ZVAL_TRUE(EX_VAR(opline->result.var));
14814 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
14815 /* The result and op1 can be the same cv zval */
14816 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
14817 ZVAL_FALSE(EX_VAR(opline->result.var));
14818 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
14819 SAVE_OPLINE();
14820 ZVAL_UNDEFINED_OP1();
14821 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14822 }
14823 } else {
14824 SAVE_OPLINE();
14825 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
14826 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14827 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14828 }
14829 ZEND_VM_NEXT_OPCODE();
14830 }
14831
ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14832 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14833 {
14834 USE_OPLINE
14835 zval *obj;
14836 zend_object *zobj;
14837 zend_class_entry *ce, *scope;
14838 zend_function *clone;
14839 zend_object_clone_obj_t clone_call;
14840
14841 SAVE_OPLINE();
14842 obj = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14843
14844 do {
14845 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
14846 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
14847 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
14848 obj = Z_REFVAL_P(obj);
14849 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
14850 break;
14851 }
14852 }
14853 ZVAL_UNDEF(EX_VAR(opline->result.var));
14854 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
14855 ZVAL_UNDEFINED_OP1();
14856 if (UNEXPECTED(EG(exception) != NULL)) {
14857 HANDLE_EXCEPTION();
14858 }
14859 }
14860 zend_throw_error(NULL, "__clone method called on non-object");
14861 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14862 HANDLE_EXCEPTION();
14863 }
14864 } while (0);
14865
14866 zobj = Z_OBJ_P(obj);
14867 ce = zobj->ce;
14868 clone = ce->clone;
14869 clone_call = zobj->handlers->clone_obj;
14870 if (UNEXPECTED(clone_call == NULL)) {
14871 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
14872 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14873 ZVAL_UNDEF(EX_VAR(opline->result.var));
14874 HANDLE_EXCEPTION();
14875 }
14876
14877 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
14878 scope = EX(func)->op_array.scope;
14879 if (clone->common.scope != scope) {
14880 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
14881 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
14882 zend_wrong_clone_call(clone, scope);
14883 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14884 ZVAL_UNDEF(EX_VAR(opline->result.var));
14885 HANDLE_EXCEPTION();
14886 }
14887 }
14888 }
14889
14890 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
14891
14892 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14893 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
14894 }
14895
ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14896 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14897 {
14898 USE_OPLINE
14899 zend_op_array *new_op_array;
14900 zval *inc_filename;
14901
14902 SAVE_OPLINE();
14903 inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14904 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
14905 if (UNEXPECTED(EG(exception) != NULL)) {
14906 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14907 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
14908 destroy_op_array(new_op_array);
14909 efree_size(new_op_array, sizeof(zend_op_array));
14910 }
14911 UNDEF_RESULT();
14912 HANDLE_EXCEPTION();
14913 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
14914 if (RETURN_VALUE_USED(opline)) {
14915 ZVAL_TRUE(EX_VAR(opline->result.var));
14916 }
14917 } else if (UNEXPECTED(new_op_array == NULL)) {
14918 if (RETURN_VALUE_USED(opline)) {
14919 ZVAL_FALSE(EX_VAR(opline->result.var));
14920 }
14921 } else if (new_op_array->last == 1
14922 && new_op_array->opcodes[0].opcode == ZEND_RETURN
14923 && new_op_array->opcodes[0].op1_type == IS_CONST
14924 && EXPECTED(zend_execute_ex == execute_ex)) {
14925 if (RETURN_VALUE_USED(opline)) {
14926 const zend_op *op = new_op_array->opcodes;
14927
14928 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
14929 }
14930 zend_destroy_static_vars(new_op_array);
14931 destroy_op_array(new_op_array);
14932 efree_size(new_op_array, sizeof(zend_op_array));
14933 } else {
14934 zval *return_value = NULL;
14935 zend_execute_data *call;
14936 if (RETURN_VALUE_USED(opline)) {
14937 return_value = EX_VAR(opline->result.var);
14938 }
14939
14940 new_op_array->scope = EX(func)->op_array.scope;
14941
14942 call = zend_vm_stack_push_call_frame(
14943 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
14944 (zend_function*)new_op_array, 0,
14945 Z_PTR(EX(This)));
14946
14947 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
14948 call->symbol_table = EX(symbol_table);
14949 } else {
14950 call->symbol_table = zend_rebuild_symbol_table();
14951 }
14952
14953 call->prev_execute_data = execute_data;
14954 i_init_code_execute_data(call, new_op_array, return_value);
14955
14956 if (EXPECTED(zend_execute_ex == execute_ex)) {
14957 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14958 ZEND_VM_ENTER();
14959 } else {
14960 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
14961 zend_execute_ex(call);
14962 zend_vm_stack_free_call_frame(call);
14963 }
14964
14965 zend_destroy_static_vars(new_op_array);
14966 destroy_op_array(new_op_array);
14967 efree_size(new_op_array, sizeof(zend_op_array));
14968 if (UNEXPECTED(EG(exception) != NULL)) {
14969 zend_rethrow_exception(execute_data);
14970 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14971 UNDEF_RESULT();
14972 HANDLE_EXCEPTION();
14973 }
14974 }
14975 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14976 ZEND_VM_NEXT_OPCODE();
14977 }
14978
ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)14979 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
14980 {
14981 USE_OPLINE
14982 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
14983 zval *val;
14984
14985 SAVE_OPLINE();
14986 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
14987
14988 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
14989 zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
14990 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
14991 UNDEF_RESULT();
14992 HANDLE_EXCEPTION();
14993 }
14994
14995 yield_from_try_again:
14996 if (Z_TYPE_P(val) == IS_ARRAY) {
14997 ZVAL_COPY_VALUE(&generator->values, val);
14998 if (Z_OPT_REFCOUNTED_P(val)) {
14999 Z_ADDREF_P(val);
15000 }
15001 Z_FE_POS(generator->values) = 0;
15002 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15003 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
15004 zend_class_entry *ce = Z_OBJCE_P(val);
15005 if (ce == zend_ce_generator) {
15006 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
15007
15008 Z_ADDREF_P(val);
15009 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15010
15011 if (UNEXPECTED(new_gen->execute_data == NULL)) {
15012 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
15013 zval_ptr_dtor(val);
15014 UNDEF_RESULT();
15015 HANDLE_EXCEPTION();
15016 } else if (Z_ISUNDEF(new_gen->retval)) {
15017 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
15018 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
15019 zval_ptr_dtor(val);
15020 UNDEF_RESULT();
15021 HANDLE_EXCEPTION();
15022 } else {
15023 zend_generator_yield_from(generator, new_gen);
15024 }
15025 } else {
15026 if (RETURN_VALUE_USED(opline)) {
15027 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
15028 }
15029 ZEND_VM_NEXT_OPCODE();
15030 }
15031 } else {
15032 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
15033 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15034
15035 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
15036 if (!EG(exception)) {
15037 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
15038 }
15039 UNDEF_RESULT();
15040 HANDLE_EXCEPTION();
15041 }
15042
15043 iter->index = 0;
15044 if (iter->funcs->rewind) {
15045 iter->funcs->rewind(iter);
15046 if (UNEXPECTED(EG(exception) != NULL)) {
15047 OBJ_RELEASE(&iter->std);
15048 UNDEF_RESULT();
15049 HANDLE_EXCEPTION();
15050 }
15051 }
15052
15053 ZVAL_OBJ(&generator->values, &iter->std);
15054 }
15055 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
15056 val = Z_REFVAL_P(val);
15057 goto yield_from_try_again;
15058 } else {
15059 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
15060 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15061 UNDEF_RESULT();
15062 HANDLE_EXCEPTION();
15063 }
15064
15065 /* This is the default return value
15066 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
15067 if (RETURN_VALUE_USED(opline)) {
15068 ZVAL_NULL(EX_VAR(opline->result.var));
15069 }
15070
15071 /* This generator has no send target (though the generator we delegate to might have one) */
15072 generator->send_target = NULL;
15073
15074 /* We increment to the next op, so we are at the correct position when the
15075 * generator is resumed. */
15076 ZEND_VM_INC_OPCODE();
15077
15078 /* The GOTO VM uses a local opline variable. We need to set the opline
15079 * variable in execute_data so we don't resume at an old position. */
15080 SAVE_OPLINE();
15081
15082 ZEND_VM_RETURN();
15083 }
15084
ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15085 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15086 {
15087 USE_OPLINE
15088 zval *value;
15089
15090 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15091 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15092 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15093 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15094 zval_ptr_dtor_str(value);
15095 }
15096 ZEND_VM_NEXT_OPCODE();
15097 } else {
15098 bool strict;
15099
15100 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
15101 value = Z_REFVAL_P(value);
15102 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
15103 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
15104 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15105 ZEND_VM_NEXT_OPCODE();
15106 }
15107 }
15108
15109 SAVE_OPLINE();
15110 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15111 value = ZVAL_UNDEFINED_OP1();
15112 }
15113 strict = EX_USES_STRICT_TYPES();
15114 do {
15115 if (EXPECTED(!strict)) {
15116 zend_string *str;
15117 zval tmp;
15118
15119 if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
15120 zend_error(E_DEPRECATED,
15121 "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
15122 ZVAL_LONG(EX_VAR(opline->result.var), 0);
15123 if (UNEXPECTED(EG(exception))) {
15124 HANDLE_EXCEPTION();
15125 }
15126 break;
15127 }
15128
15129 ZVAL_COPY(&tmp, value);
15130 if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
15131 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
15132 zval_ptr_dtor(&tmp);
15133 break;
15134 }
15135 zval_ptr_dtor(&tmp);
15136 }
15137 if (!EG(exception)) {
15138 zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
15139 }
15140 ZVAL_UNDEF(EX_VAR(opline->result.var));
15141 } while (0);
15142 }
15143 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15144 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15145 }
15146
ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15147 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15148 {
15149 USE_OPLINE
15150 zval *value;
15151 int result = 0;
15152
15153 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15154 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15155 type_check_resource:
15156 if (opline->extended_value != MAY_BE_RESOURCE
15157 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
15158 result = 1;
15159 }
15160 } else if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
15161 value = Z_REFVAL_P(value);
15162 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
15163 goto type_check_resource;
15164 }
15165 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
15166 result = ((1 << IS_NULL) & opline->extended_value) != 0;
15167 SAVE_OPLINE();
15168 ZVAL_UNDEFINED_OP1();
15169 if (UNEXPECTED(EG(exception))) {
15170 ZVAL_UNDEF(EX_VAR(opline->result.var));
15171 HANDLE_EXCEPTION();
15172 }
15173 }
15174 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15175 SAVE_OPLINE();
15176 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15177 ZEND_VM_SMART_BRANCH(result, 1);
15178 } else {
15179 ZEND_VM_SMART_BRANCH(result, 0);
15180 }
15181 }
15182
ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15183 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15184 {
15185 uint32_t fetch_type;
15186 zend_class_entry *called_scope, *scope;
15187 USE_OPLINE
15188
15189 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
15190 SAVE_OPLINE();
15191 zval *op = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15192 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
15193 ZVAL_DEREF(op);
15194 if (Z_TYPE_P(op) != IS_OBJECT) {
15195 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
15196 ZVAL_UNDEF(EX_VAR(opline->result.var));
15197 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15198 HANDLE_EXCEPTION();
15199 }
15200 }
15201
15202 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
15203 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15204 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15205 }
15206
15207 fetch_type = opline->op1.num;
15208 scope = EX(func)->op_array.scope;
15209 if (UNEXPECTED(scope == NULL)) {
15210 SAVE_OPLINE();
15211 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
15212 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
15213 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
15214 ZVAL_UNDEF(EX_VAR(opline->result.var));
15215 HANDLE_EXCEPTION();
15216 }
15217
15218 switch (fetch_type) {
15219 case ZEND_FETCH_CLASS_SELF:
15220 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
15221 break;
15222 case ZEND_FETCH_CLASS_PARENT:
15223 if (UNEXPECTED(scope->parent == NULL)) {
15224 SAVE_OPLINE();
15225 zend_throw_error(NULL,
15226 "Cannot use \"parent\" when current class scope has no parent");
15227 ZVAL_UNDEF(EX_VAR(opline->result.var));
15228 HANDLE_EXCEPTION();
15229 }
15230 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
15231 break;
15232 case ZEND_FETCH_CLASS_STATIC:
15233 if (Z_TYPE(EX(This)) == IS_OBJECT) {
15234 called_scope = Z_OBJCE(EX(This));
15235 } else {
15236 called_scope = Z_CE(EX(This));
15237 }
15238 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
15239 break;
15240 EMPTY_SWITCH_DEFAULT_CASE()
15241 }
15242 ZEND_VM_NEXT_OPCODE();
15243 }
15244
ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15245 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15246 {
15247 USE_OPLINE
15248 zval *op1, *op2;
15249
15250 SAVE_OPLINE();
15251 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15252 op2 = RT_CONSTANT(opline, opline->op2);
15253 div_function(EX_VAR(opline->result.var), op1, op2);
15254 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15255
15256 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15257 }
15258
ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15259 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15260 {
15261 USE_OPLINE
15262 zval *op1, *op2;
15263
15264 SAVE_OPLINE();
15265 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15266 op2 = RT_CONSTANT(opline, opline->op2);
15267 pow_function(EX_VAR(opline->result.var), op1, op2);
15268 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15269
15270 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15271 }
15272
ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15273 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15274 {
15275 USE_OPLINE
15276 zval *op1, *op2;
15277
15278 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15279 op2 = RT_CONSTANT(opline, opline->op2);
15280
15281 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
15282 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
15283 zend_string *op1_str = Z_STR_P(op1);
15284 zend_string *op2_str = Z_STR_P(op2);
15285 zend_string *str;
15286 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
15287
15288 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
15289 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
15290 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
15291 } else {
15292 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
15293 }
15294 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15295 zend_string_release_ex(op1_str, 0);
15296 }
15297 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
15298 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
15299 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
15300 } else {
15301 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
15302 }
15303 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15304 zend_string_release_ex(op2_str, 0);
15305 }
15306 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
15307 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
15308 size_t len = ZSTR_LEN(op1_str);
15309
15310 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
15311 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
15312 }
15313 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
15314 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15315 GC_ADD_FLAGS(str, flags);
15316 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15317 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15318 zend_string_release_ex(op2_str, 0);
15319 }
15320 } else {
15321 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
15322 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
15323 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
15324 GC_ADD_FLAGS(str, flags);
15325 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
15326 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15327 zend_string_release_ex(op1_str, 0);
15328 }
15329 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15330 zend_string_release_ex(op2_str, 0);
15331 }
15332 }
15333 ZEND_VM_NEXT_OPCODE();
15334 } else {
15335 SAVE_OPLINE();
15336
15337 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
15338 op1 = ZVAL_UNDEFINED_OP1();
15339 }
15340 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
15341 op2 = ZVAL_UNDEFINED_OP2();
15342 }
15343 concat_function(EX_VAR(opline->result.var), op1, op2);
15344 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15345
15346 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15347 }
15348 }
15349
ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15350 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15351 {
15352 USE_OPLINE
15353 zval *op1, *op2;
15354 double d1, d2;
15355
15356 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15357 op2 = RT_CONSTANT(opline, opline->op2);
15358 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15359 /* pass */
15360 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15361 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15362 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15363 is_equal_true:
15364 ZEND_VM_SMART_BRANCH_TRUE_NONE();
15365 } else {
15366 is_equal_false:
15367 ZEND_VM_SMART_BRANCH_FALSE_NONE();
15368 }
15369 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15370 d1 = (double)Z_LVAL_P(op1);
15371 d2 = Z_DVAL_P(op2);
15372 goto is_equal_double;
15373 }
15374 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15375 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15376 d1 = Z_DVAL_P(op1);
15377 d2 = Z_DVAL_P(op2);
15378 is_equal_double:
15379 if (d1 == d2) {
15380 goto is_equal_true;
15381 } else {
15382 goto is_equal_false;
15383 }
15384 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15385 d1 = Z_DVAL_P(op1);
15386 d2 = (double)Z_LVAL_P(op2);
15387 goto is_equal_double;
15388 }
15389 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15390 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15391 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15392 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15393 zval_ptr_dtor_str(op1);
15394 }
15395 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15396 zval_ptr_dtor_str(op2);
15397 }
15398 if (result) {
15399 goto is_equal_true;
15400 } else {
15401 goto is_equal_false;
15402 }
15403 }
15404 }
15405 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15406 }
15407
ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15408 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15409 {
15410 USE_OPLINE
15411 zval *op1, *op2;
15412 double d1, d2;
15413
15414 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15415 op2 = RT_CONSTANT(opline, opline->op2);
15416 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15417 /* pass */
15418 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15419 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15420 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15421 is_equal_true:
15422 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
15423 } else {
15424 is_equal_false:
15425 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
15426 }
15427 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15428 d1 = (double)Z_LVAL_P(op1);
15429 d2 = Z_DVAL_P(op2);
15430 goto is_equal_double;
15431 }
15432 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15433 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15434 d1 = Z_DVAL_P(op1);
15435 d2 = Z_DVAL_P(op2);
15436 is_equal_double:
15437 if (d1 == d2) {
15438 goto is_equal_true;
15439 } else {
15440 goto is_equal_false;
15441 }
15442 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15443 d1 = Z_DVAL_P(op1);
15444 d2 = (double)Z_LVAL_P(op2);
15445 goto is_equal_double;
15446 }
15447 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15448 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15449 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15450 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15451 zval_ptr_dtor_str(op1);
15452 }
15453 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15454 zval_ptr_dtor_str(op2);
15455 }
15456 if (result) {
15457 goto is_equal_true;
15458 } else {
15459 goto is_equal_false;
15460 }
15461 }
15462 }
15463 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15464 }
15465
ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15466 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15467 {
15468 USE_OPLINE
15469 zval *op1, *op2;
15470 double d1, d2;
15471
15472 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15473 op2 = RT_CONSTANT(opline, opline->op2);
15474 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15475 /* pass */
15476 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15477 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15478 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
15479 is_equal_true:
15480 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
15481 } else {
15482 is_equal_false:
15483 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
15484 }
15485 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15486 d1 = (double)Z_LVAL_P(op1);
15487 d2 = Z_DVAL_P(op2);
15488 goto is_equal_double;
15489 }
15490 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15491 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15492 d1 = Z_DVAL_P(op1);
15493 d2 = Z_DVAL_P(op2);
15494 is_equal_double:
15495 if (d1 == d2) {
15496 goto is_equal_true;
15497 } else {
15498 goto is_equal_false;
15499 }
15500 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15501 d1 = Z_DVAL_P(op1);
15502 d2 = (double)Z_LVAL_P(op2);
15503 goto is_equal_double;
15504 }
15505 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15506 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15507 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15508 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15509 zval_ptr_dtor_str(op1);
15510 }
15511 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15512 zval_ptr_dtor_str(op2);
15513 }
15514 if (result) {
15515 goto is_equal_true;
15516 } else {
15517 goto is_equal_false;
15518 }
15519 }
15520 }
15521 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15522 }
15523
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15524 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15525 {
15526 USE_OPLINE
15527 zval *op1, *op2;
15528 double d1, d2;
15529
15530 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15531 op2 = RT_CONSTANT(opline, opline->op2);
15532 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15533 /* pass */
15534 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15535 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15536 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
15537 is_not_equal_true:
15538 ZEND_VM_SMART_BRANCH_TRUE_NONE();
15539 } else {
15540 is_not_equal_false:
15541 ZEND_VM_SMART_BRANCH_FALSE_NONE();
15542 }
15543 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15544 d1 = (double)Z_LVAL_P(op1);
15545 d2 = Z_DVAL_P(op2);
15546 goto is_not_equal_double;
15547 }
15548 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15549 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15550 d1 = Z_DVAL_P(op1);
15551 d2 = Z_DVAL_P(op2);
15552 is_not_equal_double:
15553 if (d1 != d2) {
15554 goto is_not_equal_true;
15555 } else {
15556 goto is_not_equal_false;
15557 }
15558 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15559 d1 = Z_DVAL_P(op1);
15560 d2 = (double)Z_LVAL_P(op2);
15561 goto is_not_equal_double;
15562 }
15563 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15564 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15565 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15566 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15567 zval_ptr_dtor_str(op1);
15568 }
15569 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15570 zval_ptr_dtor_str(op2);
15571 }
15572 if (!result) {
15573 goto is_not_equal_true;
15574 } else {
15575 goto is_not_equal_false;
15576 }
15577 }
15578 }
15579 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15580 }
15581
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15582 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15583 {
15584 USE_OPLINE
15585 zval *op1, *op2;
15586 double d1, d2;
15587
15588 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15589 op2 = RT_CONSTANT(opline, opline->op2);
15590 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15591 /* pass */
15592 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15593 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15594 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
15595 is_not_equal_true:
15596 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
15597 } else {
15598 is_not_equal_false:
15599 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
15600 }
15601 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15602 d1 = (double)Z_LVAL_P(op1);
15603 d2 = Z_DVAL_P(op2);
15604 goto is_not_equal_double;
15605 }
15606 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15607 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15608 d1 = Z_DVAL_P(op1);
15609 d2 = Z_DVAL_P(op2);
15610 is_not_equal_double:
15611 if (d1 != d2) {
15612 goto is_not_equal_true;
15613 } else {
15614 goto is_not_equal_false;
15615 }
15616 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15617 d1 = Z_DVAL_P(op1);
15618 d2 = (double)Z_LVAL_P(op2);
15619 goto is_not_equal_double;
15620 }
15621 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15622 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15623 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15624 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15625 zval_ptr_dtor_str(op1);
15626 }
15627 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15628 zval_ptr_dtor_str(op2);
15629 }
15630 if (!result) {
15631 goto is_not_equal_true;
15632 } else {
15633 goto is_not_equal_false;
15634 }
15635 }
15636 }
15637 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15638 }
15639
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15640 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15641 {
15642 USE_OPLINE
15643 zval *op1, *op2;
15644 double d1, d2;
15645
15646 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15647 op2 = RT_CONSTANT(opline, opline->op2);
15648 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) {
15649 /* pass */
15650 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
15651 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15652 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
15653 is_not_equal_true:
15654 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
15655 } else {
15656 is_not_equal_false:
15657 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
15658 }
15659 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15660 d1 = (double)Z_LVAL_P(op1);
15661 d2 = Z_DVAL_P(op2);
15662 goto is_not_equal_double;
15663 }
15664 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
15665 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
15666 d1 = Z_DVAL_P(op1);
15667 d2 = Z_DVAL_P(op2);
15668 is_not_equal_double:
15669 if (d1 != d2) {
15670 goto is_not_equal_true;
15671 } else {
15672 goto is_not_equal_false;
15673 }
15674 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
15675 d1 = Z_DVAL_P(op1);
15676 d2 = (double)Z_LVAL_P(op2);
15677 goto is_not_equal_double;
15678 }
15679 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
15680 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
15681 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
15682 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
15683 zval_ptr_dtor_str(op1);
15684 }
15685 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
15686 zval_ptr_dtor_str(op2);
15687 }
15688 if (!result) {
15689 goto is_not_equal_true;
15690 } else {
15691 goto is_not_equal_false;
15692 }
15693 }
15694 }
15695 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
15696 }
15697
ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15698 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15699 {
15700 USE_OPLINE
15701 zval *op1, *op2;
15702
15703 SAVE_OPLINE();
15704 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15705 op2 = RT_CONSTANT(opline, opline->op2);
15706 compare_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
ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15712 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15713 {
15714 USE_OPLINE
15715 zval *op1, *op2;
15716
15717 SAVE_OPLINE();
15718 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15719 op2 = RT_CONSTANT(opline, opline->op2);
15720 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
15721 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15722
15723 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15724 }
15725
ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15726 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15727 {
15728 USE_OPLINE
15729 zval *container, *dim, *value;
15730
15731 SAVE_OPLINE();
15732 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15733 dim = RT_CONSTANT(opline, opline->op2);
15734 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
15735 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
15736 fetch_dim_r_array:
15737 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
15738 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
15739 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
15740 container = Z_REFVAL_P(container);
15741 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
15742 goto fetch_dim_r_array;
15743 } else {
15744 goto fetch_dim_r_slow;
15745 }
15746 } else {
15747 fetch_dim_r_slow:
15748 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
15749 dim++;
15750 }
15751 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
15752 }
15753 } else {
15754 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
15755 }
15756
15757 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15758 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15759 }
15760
ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15761 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15762 {
15763 USE_OPLINE
15764 zval *container;
15765
15766 SAVE_OPLINE();
15767 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15768 zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
15769
15770 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15771 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15772 }
15773
ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15774 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15775 {
15776 USE_OPLINE
15777 zval *container;
15778 void **cache_slot = NULL;
15779
15780 SAVE_OPLINE();
15781 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15782
15783 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
15784 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
15785 do {
15786 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
15787 container = Z_REFVAL_P(container);
15788 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
15789 break;
15790 }
15791 }
15792 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
15793 ZVAL_UNDEFINED_OP1();
15794 }
15795 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
15796 ZVAL_NULL(EX_VAR(opline->result.var));
15797 goto fetch_obj_r_finish;
15798 } while (0);
15799 }
15800
15801 /* here we are sure we are dealing with an object */
15802 do {
15803 zend_object *zobj = Z_OBJ_P(container);
15804 zend_string *name, *tmp_name;
15805 zval *retval;
15806
15807 if (IS_CONST == IS_CONST) {
15808 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
15809
15810 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
15811 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
15812
15813 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
15814 retval = OBJ_PROP(zobj, prop_offset);
15815 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
15816 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15817 goto fetch_obj_r_copy;
15818 } else {
15819 fetch_obj_r_fast_copy:
15820 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
15821 ZEND_VM_NEXT_OPCODE();
15822 }
15823 }
15824 } else if (EXPECTED(zobj->properties != NULL)) {
15825 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
15826 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
15827 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
15828
15829 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
15830 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
15831
15832 if (EXPECTED(p->key == name) ||
15833 (EXPECTED(p->h == ZSTR_H(name)) &&
15834 EXPECTED(p->key != NULL) &&
15835 EXPECTED(zend_string_equal_content(p->key, name)))) {
15836 retval = &p->val;
15837 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15838 goto fetch_obj_r_copy;
15839 } else {
15840 goto fetch_obj_r_fast_copy;
15841 }
15842 }
15843 }
15844 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
15845 }
15846 retval = zend_hash_find_known_hash(zobj->properties, name);
15847 if (EXPECTED(retval)) {
15848 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
15849 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
15850 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15851 goto fetch_obj_r_copy;
15852 } else {
15853 goto fetch_obj_r_fast_copy;
15854 }
15855 }
15856 }
15857 }
15858 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
15859 } else {
15860 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
15861 if (UNEXPECTED(!name)) {
15862 ZVAL_UNDEF(EX_VAR(opline->result.var));
15863 break;
15864 }
15865 }
15866
15867 #if ZEND_DEBUG
15868 /* For non-standard object handlers, verify a declared property type in debug builds.
15869 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
15870 zend_property_info *prop_info = NULL;
15871 if (zobj->handlers->read_property != zend_std_read_property) {
15872 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
15873 }
15874 #endif
15875 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
15876 #if ZEND_DEBUG
15877 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
15878 && ZEND_TYPE_IS_SET(prop_info->type)) {
15879 ZVAL_OPT_DEREF(retval);
15880 zend_verify_property_type(prop_info, retval, /* strict */ true);
15881 }
15882 #endif
15883
15884 if (IS_CONST != IS_CONST) {
15885 zend_tmp_string_release(tmp_name);
15886 }
15887
15888 if (retval != EX_VAR(opline->result.var)) {
15889 fetch_obj_r_copy:
15890 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
15891 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
15892 zend_unwrap_reference(retval);
15893 }
15894 } while (0);
15895
15896 fetch_obj_r_finish:
15897
15898 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
15899 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
15900 }
15901
ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)15902 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
15903 {
15904 USE_OPLINE
15905 zval *container;
15906 void **cache_slot = NULL;
15907
15908 SAVE_OPLINE();
15909 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
15910
15911 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
15912 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
15913 do {
15914 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
15915 container = Z_REFVAL_P(container);
15916 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
15917 break;
15918 }
15919 }
15920 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
15921 ZVAL_UNDEFINED_OP2();
15922 }
15923 ZVAL_NULL(EX_VAR(opline->result.var));
15924 goto fetch_obj_is_finish;
15925 } while (0);
15926 }
15927
15928 /* here we are sure we are dealing with an object */
15929 do {
15930 zend_object *zobj = Z_OBJ_P(container);
15931 zend_string *name, *tmp_name;
15932 zval *retval;
15933
15934 if (IS_CONST == IS_CONST) {
15935 cache_slot = CACHE_ADDR(opline->extended_value);
15936
15937 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
15938 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
15939
15940 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
15941 retval = OBJ_PROP(zobj, prop_offset);
15942 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
15943 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15944 goto fetch_obj_is_copy;
15945 } else {
15946 fetch_obj_is_fast_copy:
15947 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
15948 ZEND_VM_NEXT_OPCODE();
15949 }
15950 }
15951 } else if (EXPECTED(zobj->properties != NULL)) {
15952 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
15953 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
15954 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
15955
15956 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
15957 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
15958
15959 if (EXPECTED(p->key == name) ||
15960 (EXPECTED(p->h == ZSTR_H(name)) &&
15961 EXPECTED(p->key != NULL) &&
15962 EXPECTED(zend_string_equal_content(p->key, name)))) {
15963 retval = &p->val;
15964 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15965 goto fetch_obj_is_copy;
15966 } else {
15967 goto fetch_obj_is_fast_copy;
15968 }
15969 }
15970 }
15971 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
15972 }
15973 retval = zend_hash_find_known_hash(zobj->properties, name);
15974 if (EXPECTED(retval)) {
15975 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
15976 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
15977 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
15978 goto fetch_obj_is_copy;
15979 } else {
15980 goto fetch_obj_is_fast_copy;
15981 }
15982 }
15983 }
15984 }
15985 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
15986 } else {
15987 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
15988 if (UNEXPECTED(!name)) {
15989 ZVAL_UNDEF(EX_VAR(opline->result.var));
15990 break;
15991 }
15992 }
15993
15994 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
15995
15996 if (IS_CONST != IS_CONST) {
15997 zend_tmp_string_release(tmp_name);
15998 }
15999
16000 if (retval != EX_VAR(opline->result.var)) {
16001 fetch_obj_is_copy:
16002 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
16003 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
16004 zend_unwrap_reference(retval);
16005 }
16006 } while (0);
16007
16008 fetch_obj_is_finish:
16009
16010 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16011 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16012 }
16013
ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16014 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16015 {
16016 USE_OPLINE
16017 zval *op1, *op2;
16018 zend_string *op1_str, *op2_str, *str;
16019
16020
16021 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16022 op2 = RT_CONSTANT(opline, opline->op2);
16023 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
16024 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
16025 zend_string *op1_str = Z_STR_P(op1);
16026 zend_string *op2_str = Z_STR_P(op2);
16027 zend_string *str;
16028 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
16029
16030 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16031 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
16032 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
16033 } else {
16034 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16035 }
16036 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16037 zend_string_release_ex(op1_str, 0);
16038 }
16039 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16040 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
16041 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
16042 } else {
16043 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16044 }
16045 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16046 zend_string_release_ex(op2_str, 0);
16047 }
16048 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
16049 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
16050 size_t len = ZSTR_LEN(op1_str);
16051
16052 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
16053 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16054 GC_ADD_FLAGS(str, flags);
16055 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16056 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16057 zend_string_release_ex(op2_str, 0);
16058 }
16059 } else {
16060 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16061 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16062 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16063 GC_ADD_FLAGS(str, flags);
16064 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16065 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16066 zend_string_release_ex(op1_str, 0);
16067 }
16068 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
16069 zend_string_release_ex(op2_str, 0);
16070 }
16071 }
16072 ZEND_VM_NEXT_OPCODE();
16073 }
16074
16075 SAVE_OPLINE();
16076 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16077 op1_str = Z_STR_P(op1);
16078 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16079 op1_str = zend_string_copy(Z_STR_P(op1));
16080 } else {
16081 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
16082 ZVAL_UNDEFINED_OP1();
16083 }
16084 op1_str = zval_get_string_func(op1);
16085 }
16086 if (IS_CONST == IS_CONST) {
16087 op2_str = Z_STR_P(op2);
16088 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16089 op2_str = zend_string_copy(Z_STR_P(op2));
16090 } else {
16091 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
16092 ZVAL_UNDEFINED_OP2();
16093 }
16094 op2_str = zval_get_string_func(op2);
16095 }
16096 do {
16097 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16098 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16099 if (IS_CONST == IS_CONST) {
16100 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
16101 GC_ADDREF(op2_str);
16102 }
16103 }
16104 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16105 zend_string_release_ex(op1_str, 0);
16106 break;
16107 }
16108 }
16109 if (IS_CONST != IS_CONST) {
16110 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16111 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16112 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
16113 GC_ADDREF(op1_str);
16114 }
16115 }
16116 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16117 zend_string_release_ex(op2_str, 0);
16118 break;
16119 }
16120 }
16121 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16122 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16123 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16124
16125 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
16126 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16127 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
16128 zend_string_release_ex(op1_str, 0);
16129 }
16130 if (IS_CONST != IS_CONST) {
16131 zend_string_release_ex(op2_str, 0);
16132 }
16133 } while (0);
16134 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16135
16136 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16137 }
16138
ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16139 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16140 {
16141 USE_OPLINE
16142 zval *function_name;
16143 zval *object;
16144 zend_function *fbc;
16145 zend_class_entry *called_scope;
16146 zend_object *obj;
16147 zend_execute_data *call;
16148 uint32_t call_info;
16149
16150 SAVE_OPLINE();
16151
16152 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16153
16154 if (IS_CONST != IS_CONST) {
16155 function_name = RT_CONSTANT(opline, opline->op2);
16156 }
16157
16158 if (IS_CONST != IS_CONST &&
16159 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
16160 do {
16161 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
16162 function_name = Z_REFVAL_P(function_name);
16163 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
16164 break;
16165 }
16166 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
16167 ZVAL_UNDEFINED_OP2();
16168 if (UNEXPECTED(EG(exception) != NULL)) {
16169 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16170 HANDLE_EXCEPTION();
16171 }
16172 }
16173 zend_throw_error(NULL, "Method name must be a string");
16174
16175 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16176 HANDLE_EXCEPTION();
16177 } while (0);
16178 }
16179
16180 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
16181 obj = Z_OBJ_P(object);
16182 } else {
16183 do {
16184 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16185 obj = Z_OBJ_P(object);
16186 } else {
16187 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
16188 zend_reference *ref = Z_REF_P(object);
16189
16190 object = &ref->val;
16191 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
16192 obj = Z_OBJ_P(object);
16193 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
16194 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
16195 efree_size(ref, sizeof(zend_reference));
16196 } else {
16197 Z_ADDREF_P(object);
16198 }
16199 }
16200 break;
16201 }
16202 }
16203 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
16204 object = ZVAL_UNDEFINED_OP1();
16205 if (UNEXPECTED(EG(exception) != NULL)) {
16206 if (IS_CONST != IS_CONST) {
16207
16208 }
16209 HANDLE_EXCEPTION();
16210 }
16211 }
16212 if (IS_CONST == IS_CONST) {
16213 function_name = RT_CONSTANT(opline, opline->op2);
16214 }
16215 zend_invalid_method_call(object, function_name);
16216
16217 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16218 HANDLE_EXCEPTION();
16219 }
16220 } while (0);
16221 }
16222
16223 called_scope = obj->ce;
16224
16225 if (IS_CONST == IS_CONST &&
16226 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
16227 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
16228 } else {
16229 zend_object *orig_obj = obj;
16230
16231 if (IS_CONST == IS_CONST) {
16232 function_name = RT_CONSTANT(opline, opline->op2);
16233 }
16234
16235 /* First, locate the function. */
16236 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
16237 if (UNEXPECTED(fbc == NULL)) {
16238 if (EXPECTED(!EG(exception))) {
16239 zend_undefined_method(obj->ce, Z_STR_P(function_name));
16240 }
16241
16242 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
16243 zend_objects_store_del(orig_obj);
16244 }
16245 HANDLE_EXCEPTION();
16246 }
16247 if (IS_CONST == IS_CONST &&
16248 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
16249 EXPECTED(obj == orig_obj)) {
16250 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
16251 }
16252 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
16253 GC_ADDREF(obj); /* For $this pointer */
16254 if (GC_DELREF(orig_obj) == 0) {
16255 zend_objects_store_del(orig_obj);
16256 }
16257 }
16258 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
16259 init_func_run_time_cache(&fbc->op_array);
16260 }
16261 }
16262
16263 if (IS_CONST != IS_CONST) {
16264
16265 }
16266
16267 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
16268 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
16269 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
16270 zend_objects_store_del(obj);
16271 if (UNEXPECTED(EG(exception))) {
16272 HANDLE_EXCEPTION();
16273 }
16274 }
16275 /* call static method */
16276 obj = (zend_object*)called_scope;
16277 call_info = ZEND_CALL_NESTED_FUNCTION;
16278 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
16279 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
16280 GC_ADDREF(obj); /* For $this pointer */
16281 }
16282 /* CV may be changed indirectly (e.g. when it's a reference) */
16283 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
16284 }
16285
16286 call = zend_vm_stack_push_call_frame(call_info,
16287 fbc, opline->extended_value, obj);
16288 call->prev_execute_data = EX(call);
16289 EX(call) = call;
16290
16291 ZEND_VM_NEXT_OPCODE();
16292 }
16293
ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16294 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16295 {
16296 USE_OPLINE
16297 zval *value, *arg;
16298
16299 if (IS_CONST == IS_CONST) {
16300 SAVE_OPLINE();
16301 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
16302 uint32_t arg_num;
16303 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
16304 if (UNEXPECTED(!arg)) {
16305 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16306 HANDLE_EXCEPTION();
16307 }
16308 } else {
16309 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
16310 }
16311
16312 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16313 ZVAL_COPY_VALUE(arg, value);
16314 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
16315 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
16316 Z_ADDREF_P(arg);
16317 }
16318 }
16319 ZEND_VM_NEXT_OPCODE();
16320 }
16321
ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16322 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16323 {
16324 USE_OPLINE
16325 zval *op1, *op2;
16326 double d1, d2;
16327
16328 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16329 op2 = RT_CONSTANT(opline, opline->op2);
16330 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16331 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16332 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16333 case_true:
16334 ZEND_VM_SMART_BRANCH_TRUE();
16335 } else {
16336 case_false:
16337 ZEND_VM_SMART_BRANCH_FALSE();
16338 }
16339 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16340 d1 = (double)Z_LVAL_P(op1);
16341 d2 = Z_DVAL_P(op2);
16342 goto case_double;
16343 }
16344 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16345 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16346 d1 = Z_DVAL_P(op1);
16347 d2 = Z_DVAL_P(op2);
16348 case_double:
16349 if (d1 == d2) {
16350 goto case_true;
16351 } else {
16352 goto case_false;
16353 }
16354 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16355 d1 = Z_DVAL_P(op1);
16356 d2 = (double)Z_LVAL_P(op2);
16357 goto case_double;
16358 }
16359 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16360 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16361 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16362
16363 if (result) {
16364 goto case_true;
16365 } else {
16366 goto case_false;
16367 }
16368 }
16369 }
16370 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16371 }
16372
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16373 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16374 {
16375 USE_OPLINE
16376 zval *container;
16377 bool result;
16378 zend_ulong hval;
16379 zval *offset;
16380
16381 SAVE_OPLINE();
16382 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16383 offset = RT_CONSTANT(opline, opline->op2);
16384
16385 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16386 HashTable *ht;
16387 zval *value;
16388 zend_string *str;
16389
16390 isset_dim_obj_array:
16391 ht = Z_ARRVAL_P(container);
16392 isset_again:
16393 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
16394 str = Z_STR_P(offset);
16395 if (IS_CONST != IS_CONST) {
16396 if (ZEND_HANDLE_NUMERIC(str, hval)) {
16397 goto num_index_prop;
16398 }
16399 }
16400 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
16401 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
16402 hval = Z_LVAL_P(offset);
16403 num_index_prop:
16404 value = zend_hash_index_find(ht, hval);
16405 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
16406 offset = Z_REFVAL_P(offset);
16407 goto isset_again;
16408 } else {
16409 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
16410 if (UNEXPECTED(EG(exception))) {
16411 result = 0;
16412 goto isset_dim_obj_exit;
16413 }
16414 }
16415
16416 if (!(opline->extended_value & ZEND_ISEMPTY)) {
16417 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
16418 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
16419 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
16420
16421 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
16422 /* avoid exception check */
16423
16424 ZEND_VM_SMART_BRANCH(result, 0);
16425 }
16426 } else {
16427 result = (value == NULL || !i_zend_is_true(value));
16428 }
16429 goto isset_dim_obj_exit;
16430 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
16431 container = Z_REFVAL_P(container);
16432 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16433 goto isset_dim_obj_array;
16434 }
16435 }
16436
16437 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
16438 offset++;
16439 }
16440 if (!(opline->extended_value & ZEND_ISEMPTY)) {
16441 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
16442 } else {
16443 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
16444 }
16445
16446 isset_dim_obj_exit:
16447
16448 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16449 ZEND_VM_SMART_BRANCH(result, 1);
16450 }
16451
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16452 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16453 {
16454 USE_OPLINE
16455 zval *container;
16456 int result;
16457 zval *offset;
16458 zend_string *name, *tmp_name;
16459
16460 SAVE_OPLINE();
16461 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16462 offset = RT_CONSTANT(opline, opline->op2);
16463
16464 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
16465 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
16466 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
16467 container = Z_REFVAL_P(container);
16468 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
16469 result = (opline->extended_value & ZEND_ISEMPTY);
16470 goto isset_object_finish;
16471 }
16472 } else {
16473 result = (opline->extended_value & ZEND_ISEMPTY);
16474 goto isset_object_finish;
16475 }
16476 }
16477
16478 if (IS_CONST == IS_CONST) {
16479 name = Z_STR_P(offset);
16480 } else {
16481 name = zval_try_get_tmp_string(offset, &tmp_name);
16482 if (UNEXPECTED(!name)) {
16483 result = 0;
16484 goto isset_object_finish;
16485 }
16486 }
16487
16488 result =
16489 (opline->extended_value & ZEND_ISEMPTY) ^
16490 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));
16491
16492 if (IS_CONST != IS_CONST) {
16493 zend_tmp_string_release(tmp_name);
16494 }
16495
16496 isset_object_finish:
16497
16498 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16499 ZEND_VM_SMART_BRANCH(result, 1);
16500 }
16501
ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16502 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16503 {
16504 USE_OPLINE
16505
16506 zval *key, *subject;
16507 HashTable *ht;
16508 bool result;
16509
16510 SAVE_OPLINE();
16511
16512 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16513 subject = RT_CONSTANT(opline, opline->op2);
16514
16515 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
16516 array_key_exists_array:
16517 ht = Z_ARRVAL_P(subject);
16518 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
16519 } else {
16520 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
16521 subject = Z_REFVAL_P(subject);
16522 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
16523 goto array_key_exists_array;
16524 }
16525 }
16526 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
16527 result = 0;
16528 }
16529
16530 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16531 ZEND_VM_SMART_BRANCH(result, 1);
16532 }
16533
16534 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16535 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16536 {
16537 USE_OPLINE
16538 zval *expr;
16539 bool result;
16540
16541 SAVE_OPLINE();
16542 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16543
16544 try_instanceof:
16545 if (Z_TYPE_P(expr) == IS_OBJECT) {
16546 zend_class_entry *ce;
16547
16548 if (IS_CONST == IS_CONST) {
16549 ce = CACHED_PTR(opline->extended_value);
16550 if (UNEXPECTED(ce == NULL)) {
16551 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);
16552 if (EXPECTED(ce)) {
16553 CACHE_PTR(opline->extended_value, ce);
16554 }
16555 }
16556 } else if (IS_CONST == IS_UNUSED) {
16557 ce = zend_fetch_class(NULL, opline->op2.num);
16558 if (UNEXPECTED(ce == NULL)) {
16559 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16560 ZVAL_UNDEF(EX_VAR(opline->result.var));
16561 HANDLE_EXCEPTION();
16562 }
16563 } else {
16564 ce = Z_CE_P(EX_VAR(opline->op2.var));
16565 }
16566 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
16567 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
16568 expr = Z_REFVAL_P(expr);
16569 goto try_instanceof;
16570 } else {
16571 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
16572 ZVAL_UNDEFINED_OP1();
16573 }
16574 result = 0;
16575 }
16576 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16577 ZEND_VM_SMART_BRANCH(result, 1);
16578 }
16579
ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16580 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16581 {
16582 USE_OPLINE
16583 zval *container, *dim, *value;
16584 zend_long offset;
16585 HashTable *ht;
16586
16587 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16588 dim = RT_CONSTANT(opline, opline->op2);
16589 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16590 fetch_dim_r_index_array:
16591 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
16592 offset = Z_LVAL_P(dim);
16593 } else {
16594 SAVE_OPLINE();
16595 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
16596 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16597 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16598 }
16599 ht = Z_ARRVAL_P(container);
16600 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
16601 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
16602 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16603 SAVE_OPLINE();
16604 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16605 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16606 } else {
16607 ZEND_VM_NEXT_OPCODE();
16608 }
16609 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
16610 container = Z_REFVAL_P(container);
16611 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16612 goto fetch_dim_r_index_array;
16613 } else {
16614 goto fetch_dim_r_index_slow;
16615 }
16616 } else {
16617 fetch_dim_r_index_slow:
16618 SAVE_OPLINE();
16619 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
16620 dim++;
16621 }
16622 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
16623 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16624 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16625 }
16626
16627 fetch_dim_r_index_undef:
16628 ZVAL_NULL(EX_VAR(opline->result.var));
16629 SAVE_OPLINE();
16630 zend_undefined_offset(offset);
16631 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16632 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16633 }
16634
ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16635 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16636 {
16637 USE_OPLINE
16638 zval *container, *dim, *value;
16639 zend_long offset;
16640 HashTable *ht;
16641
16642 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16643 dim = EX_VAR(opline->op2.var);
16644 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16645 fetch_dim_r_index_array:
16646 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
16647 offset = Z_LVAL_P(dim);
16648 } else {
16649 SAVE_OPLINE();
16650 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
16651 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16652 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16653 }
16654 ht = Z_ARRVAL_P(container);
16655 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
16656 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
16657 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16658 SAVE_OPLINE();
16659 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16660 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16661 } else {
16662 ZEND_VM_NEXT_OPCODE();
16663 }
16664 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
16665 container = Z_REFVAL_P(container);
16666 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
16667 goto fetch_dim_r_index_array;
16668 } else {
16669 goto fetch_dim_r_index_slow;
16670 }
16671 } else {
16672 fetch_dim_r_index_slow:
16673 SAVE_OPLINE();
16674 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
16675 dim++;
16676 }
16677 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
16678 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16679 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16680 }
16681
16682 fetch_dim_r_index_undef:
16683 ZVAL_NULL(EX_VAR(opline->result.var));
16684 SAVE_OPLINE();
16685 zend_undefined_offset(offset);
16686 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16687 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16688 }
16689
ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16690 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16691 {
16692 USE_OPLINE
16693 zval *op1, *op2;
16694
16695 SAVE_OPLINE();
16696 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16697 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16698 div_function(EX_VAR(opline->result.var), op1, op2);
16699 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16700 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
16701 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16702 }
16703
ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16704 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16705 {
16706 USE_OPLINE
16707 zval *op1, *op2;
16708
16709 SAVE_OPLINE();
16710 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16711 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16712 pow_function(EX_VAR(opline->result.var), op1, op2);
16713 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16714 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
16715 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16716 }
16717
ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16718 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16719 {
16720 USE_OPLINE
16721 zval *op1, *op2;
16722
16723 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16724 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16725
16726 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
16727 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
16728 zend_string *op1_str = Z_STR_P(op1);
16729 zend_string *op2_str = Z_STR_P(op2);
16730 zend_string *str;
16731 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
16732
16733 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
16734 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
16735 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
16736 } else {
16737 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
16738 }
16739 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16740 zend_string_release_ex(op1_str, 0);
16741 }
16742 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
16743 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
16744 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
16745 } else {
16746 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
16747 }
16748 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16749 zend_string_release_ex(op2_str, 0);
16750 }
16751 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
16752 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
16753 size_t len = ZSTR_LEN(op1_str);
16754
16755 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
16756 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
16757 }
16758 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
16759 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16760 GC_ADD_FLAGS(str, flags);
16761 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16762 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16763 zend_string_release_ex(op2_str, 0);
16764 }
16765 } else {
16766 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
16767 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
16768 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
16769 GC_ADD_FLAGS(str, flags);
16770 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
16771 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16772 zend_string_release_ex(op1_str, 0);
16773 }
16774 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16775 zend_string_release_ex(op2_str, 0);
16776 }
16777 }
16778 ZEND_VM_NEXT_OPCODE();
16779 } else {
16780 SAVE_OPLINE();
16781
16782 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
16783 op1 = ZVAL_UNDEFINED_OP1();
16784 }
16785 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
16786 op2 = ZVAL_UNDEFINED_OP2();
16787 }
16788 concat_function(EX_VAR(opline->result.var), op1, op2);
16789 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
16790 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
16791 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
16792 }
16793 }
16794
ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16795 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16796 {
16797 USE_OPLINE
16798 zval *op1, *op2;
16799 double d1, d2;
16800
16801 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16802 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16803 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
16804 /* pass */
16805 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16806 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16807 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16808 is_equal_true:
16809 ZEND_VM_SMART_BRANCH_TRUE_NONE();
16810 } else {
16811 is_equal_false:
16812 ZEND_VM_SMART_BRANCH_FALSE_NONE();
16813 }
16814 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16815 d1 = (double)Z_LVAL_P(op1);
16816 d2 = Z_DVAL_P(op2);
16817 goto is_equal_double;
16818 }
16819 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16820 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16821 d1 = Z_DVAL_P(op1);
16822 d2 = Z_DVAL_P(op2);
16823 is_equal_double:
16824 if (d1 == d2) {
16825 goto is_equal_true;
16826 } else {
16827 goto is_equal_false;
16828 }
16829 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16830 d1 = Z_DVAL_P(op1);
16831 d2 = (double)Z_LVAL_P(op2);
16832 goto is_equal_double;
16833 }
16834 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16835 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16836 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16837 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16838 zval_ptr_dtor_str(op1);
16839 }
16840 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16841 zval_ptr_dtor_str(op2);
16842 }
16843 if (result) {
16844 goto is_equal_true;
16845 } else {
16846 goto is_equal_false;
16847 }
16848 }
16849 }
16850 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16851 }
16852
ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16853 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16854 {
16855 USE_OPLINE
16856 zval *op1, *op2;
16857 double d1, d2;
16858
16859 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16860 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16861 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
16862 /* pass */
16863 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16864 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16865 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16866 is_equal_true:
16867 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
16868 } else {
16869 is_equal_false:
16870 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
16871 }
16872 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16873 d1 = (double)Z_LVAL_P(op1);
16874 d2 = Z_DVAL_P(op2);
16875 goto is_equal_double;
16876 }
16877 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16878 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16879 d1 = Z_DVAL_P(op1);
16880 d2 = Z_DVAL_P(op2);
16881 is_equal_double:
16882 if (d1 == d2) {
16883 goto is_equal_true;
16884 } else {
16885 goto is_equal_false;
16886 }
16887 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16888 d1 = Z_DVAL_P(op1);
16889 d2 = (double)Z_LVAL_P(op2);
16890 goto is_equal_double;
16891 }
16892 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16893 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16894 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16895 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16896 zval_ptr_dtor_str(op1);
16897 }
16898 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16899 zval_ptr_dtor_str(op2);
16900 }
16901 if (result) {
16902 goto is_equal_true;
16903 } else {
16904 goto is_equal_false;
16905 }
16906 }
16907 }
16908 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16909 }
16910
ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16911 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16912 {
16913 USE_OPLINE
16914 zval *op1, *op2;
16915 double d1, d2;
16916
16917 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16918 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16919 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
16920 /* pass */
16921 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16922 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16923 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
16924 is_equal_true:
16925 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
16926 } else {
16927 is_equal_false:
16928 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
16929 }
16930 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16931 d1 = (double)Z_LVAL_P(op1);
16932 d2 = Z_DVAL_P(op2);
16933 goto is_equal_double;
16934 }
16935 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16936 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16937 d1 = Z_DVAL_P(op1);
16938 d2 = Z_DVAL_P(op2);
16939 is_equal_double:
16940 if (d1 == d2) {
16941 goto is_equal_true;
16942 } else {
16943 goto is_equal_false;
16944 }
16945 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16946 d1 = Z_DVAL_P(op1);
16947 d2 = (double)Z_LVAL_P(op2);
16948 goto is_equal_double;
16949 }
16950 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
16951 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
16952 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
16953 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16954 zval_ptr_dtor_str(op1);
16955 }
16956 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
16957 zval_ptr_dtor_str(op2);
16958 }
16959 if (result) {
16960 goto is_equal_true;
16961 } else {
16962 goto is_equal_false;
16963 }
16964 }
16965 }
16966 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
16967 }
16968
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)16969 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
16970 {
16971 USE_OPLINE
16972 zval *op1, *op2;
16973 double d1, d2;
16974
16975 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
16976 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
16977 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
16978 /* pass */
16979 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
16980 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
16981 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
16982 is_not_equal_true:
16983 ZEND_VM_SMART_BRANCH_TRUE_NONE();
16984 } else {
16985 is_not_equal_false:
16986 ZEND_VM_SMART_BRANCH_FALSE_NONE();
16987 }
16988 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16989 d1 = (double)Z_LVAL_P(op1);
16990 d2 = Z_DVAL_P(op2);
16991 goto is_not_equal_double;
16992 }
16993 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
16994 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
16995 d1 = Z_DVAL_P(op1);
16996 d2 = Z_DVAL_P(op2);
16997 is_not_equal_double:
16998 if (d1 != d2) {
16999 goto is_not_equal_true;
17000 } else {
17001 goto is_not_equal_false;
17002 }
17003 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17004 d1 = Z_DVAL_P(op1);
17005 d2 = (double)Z_LVAL_P(op2);
17006 goto is_not_equal_double;
17007 }
17008 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17009 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17010 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17011 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17012 zval_ptr_dtor_str(op1);
17013 }
17014 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17015 zval_ptr_dtor_str(op2);
17016 }
17017 if (!result) {
17018 goto is_not_equal_true;
17019 } else {
17020 goto is_not_equal_false;
17021 }
17022 }
17023 }
17024 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17025 }
17026
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17027 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17028 {
17029 USE_OPLINE
17030 zval *op1, *op2;
17031 double d1, d2;
17032
17033 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17034 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17035 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17036 /* pass */
17037 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17038 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17039 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17040 is_not_equal_true:
17041 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
17042 } else {
17043 is_not_equal_false:
17044 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
17045 }
17046 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17047 d1 = (double)Z_LVAL_P(op1);
17048 d2 = Z_DVAL_P(op2);
17049 goto is_not_equal_double;
17050 }
17051 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17052 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17053 d1 = Z_DVAL_P(op1);
17054 d2 = Z_DVAL_P(op2);
17055 is_not_equal_double:
17056 if (d1 != d2) {
17057 goto is_not_equal_true;
17058 } else {
17059 goto is_not_equal_false;
17060 }
17061 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17062 d1 = Z_DVAL_P(op1);
17063 d2 = (double)Z_LVAL_P(op2);
17064 goto is_not_equal_double;
17065 }
17066 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17067 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17068 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17069 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17070 zval_ptr_dtor_str(op1);
17071 }
17072 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17073 zval_ptr_dtor_str(op2);
17074 }
17075 if (!result) {
17076 goto is_not_equal_true;
17077 } else {
17078 goto is_not_equal_false;
17079 }
17080 }
17081 }
17082 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17083 }
17084
ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17085 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17086 {
17087 USE_OPLINE
17088 zval *op1, *op2;
17089 double d1, d2;
17090
17091 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17092 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17093 if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
17094 /* pass */
17095 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17096 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17097 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
17098 is_not_equal_true:
17099 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
17100 } else {
17101 is_not_equal_false:
17102 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
17103 }
17104 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17105 d1 = (double)Z_LVAL_P(op1);
17106 d2 = Z_DVAL_P(op2);
17107 goto is_not_equal_double;
17108 }
17109 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17110 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17111 d1 = Z_DVAL_P(op1);
17112 d2 = Z_DVAL_P(op2);
17113 is_not_equal_double:
17114 if (d1 != d2) {
17115 goto is_not_equal_true;
17116 } else {
17117 goto is_not_equal_false;
17118 }
17119 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17120 d1 = Z_DVAL_P(op1);
17121 d2 = (double)Z_LVAL_P(op2);
17122 goto is_not_equal_double;
17123 }
17124 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17125 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17126 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17127 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17128 zval_ptr_dtor_str(op1);
17129 }
17130 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17131 zval_ptr_dtor_str(op2);
17132 }
17133 if (!result) {
17134 goto is_not_equal_true;
17135 } else {
17136 goto is_not_equal_false;
17137 }
17138 }
17139 }
17140 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17141 }
17142
ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17143 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17144 {
17145 USE_OPLINE
17146 zval *op1, *op2;
17147
17148 SAVE_OPLINE();
17149 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17150 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17151 compare_function(EX_VAR(opline->result.var), op1, op2);
17152 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17153 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17154 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17155 }
17156
ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17157 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17158 {
17159 USE_OPLINE
17160 zval *op1, *op2;
17161
17162 SAVE_OPLINE();
17163 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17164 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17165 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
17166 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17167 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17168 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17169 }
17170
ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17171 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17172 {
17173 USE_OPLINE
17174 zval *container, *dim, *value;
17175
17176 SAVE_OPLINE();
17177 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17178 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17179 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17180 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17181 fetch_dim_r_array:
17182 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
17183 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
17184 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
17185 container = Z_REFVAL_P(container);
17186 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17187 goto fetch_dim_r_array;
17188 } else {
17189 goto fetch_dim_r_slow;
17190 }
17191 } else {
17192 fetch_dim_r_slow:
17193 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
17194 dim++;
17195 }
17196 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
17197 }
17198 } else {
17199 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
17200 }
17201 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17202 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17203 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17204 }
17205
ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17206 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17207 {
17208 USE_OPLINE
17209 zval *container;
17210
17211 SAVE_OPLINE();
17212 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17213 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);
17214 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17215 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17216 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17217 }
17218
ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17219 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17220 {
17221 USE_OPLINE
17222 zval *container;
17223 void **cache_slot = NULL;
17224
17225 SAVE_OPLINE();
17226 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17227
17228 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17229 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17230 do {
17231 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17232 container = Z_REFVAL_P(container);
17233 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
17234 break;
17235 }
17236 }
17237 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
17238 ZVAL_UNDEFINED_OP1();
17239 }
17240 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17241 ZVAL_NULL(EX_VAR(opline->result.var));
17242 goto fetch_obj_r_finish;
17243 } while (0);
17244 }
17245
17246 /* here we are sure we are dealing with an object */
17247 do {
17248 zend_object *zobj = Z_OBJ_P(container);
17249 zend_string *name, *tmp_name;
17250 zval *retval;
17251
17252 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17253 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
17254
17255 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
17256 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
17257
17258 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
17259 retval = OBJ_PROP(zobj, prop_offset);
17260 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
17261 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17262 goto fetch_obj_r_copy;
17263 } else {
17264 fetch_obj_r_fast_copy:
17265 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17266 ZEND_VM_NEXT_OPCODE();
17267 }
17268 }
17269 } else if (EXPECTED(zobj->properties != NULL)) {
17270 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17271 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
17272 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
17273
17274 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
17275 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
17276
17277 if (EXPECTED(p->key == name) ||
17278 (EXPECTED(p->h == ZSTR_H(name)) &&
17279 EXPECTED(p->key != NULL) &&
17280 EXPECTED(zend_string_equal_content(p->key, name)))) {
17281 retval = &p->val;
17282 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17283 goto fetch_obj_r_copy;
17284 } else {
17285 goto fetch_obj_r_fast_copy;
17286 }
17287 }
17288 }
17289 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
17290 }
17291 retval = zend_hash_find_known_hash(zobj->properties, name);
17292 if (EXPECTED(retval)) {
17293 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
17294 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
17295 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17296 goto fetch_obj_r_copy;
17297 } else {
17298 goto fetch_obj_r_fast_copy;
17299 }
17300 }
17301 }
17302 }
17303 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17304 } else {
17305 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
17306 if (UNEXPECTED(!name)) {
17307 ZVAL_UNDEF(EX_VAR(opline->result.var));
17308 break;
17309 }
17310 }
17311
17312 #if ZEND_DEBUG
17313 /* For non-standard object handlers, verify a declared property type in debug builds.
17314 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
17315 zend_property_info *prop_info = NULL;
17316 if (zobj->handlers->read_property != zend_std_read_property) {
17317 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
17318 }
17319 #endif
17320 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
17321 #if ZEND_DEBUG
17322 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
17323 && ZEND_TYPE_IS_SET(prop_info->type)) {
17324 ZVAL_OPT_DEREF(retval);
17325 zend_verify_property_type(prop_info, retval, /* strict */ true);
17326 }
17327 #endif
17328
17329 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17330 zend_tmp_string_release(tmp_name);
17331 }
17332
17333 if (retval != EX_VAR(opline->result.var)) {
17334 fetch_obj_r_copy:
17335 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17336 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
17337 zend_unwrap_reference(retval);
17338 }
17339 } while (0);
17340
17341 fetch_obj_r_finish:
17342 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17343 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17344 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17345 }
17346
ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17347 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17348 {
17349 USE_OPLINE
17350 zval *container;
17351 void **cache_slot = NULL;
17352
17353 SAVE_OPLINE();
17354 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17355
17356 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17357 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17358 do {
17359 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17360 container = Z_REFVAL_P(container);
17361 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
17362 break;
17363 }
17364 }
17365 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
17366 ZVAL_UNDEFINED_OP2();
17367 }
17368 ZVAL_NULL(EX_VAR(opline->result.var));
17369 goto fetch_obj_is_finish;
17370 } while (0);
17371 }
17372
17373 /* here we are sure we are dealing with an object */
17374 do {
17375 zend_object *zobj = Z_OBJ_P(container);
17376 zend_string *name, *tmp_name;
17377 zval *retval;
17378
17379 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17380 cache_slot = CACHE_ADDR(opline->extended_value);
17381
17382 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
17383 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
17384
17385 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
17386 retval = OBJ_PROP(zobj, prop_offset);
17387 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
17388 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17389 goto fetch_obj_is_copy;
17390 } else {
17391 fetch_obj_is_fast_copy:
17392 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17393 ZEND_VM_NEXT_OPCODE();
17394 }
17395 }
17396 } else if (EXPECTED(zobj->properties != NULL)) {
17397 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17398 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
17399 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
17400
17401 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
17402 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
17403
17404 if (EXPECTED(p->key == name) ||
17405 (EXPECTED(p->h == ZSTR_H(name)) &&
17406 EXPECTED(p->key != NULL) &&
17407 EXPECTED(zend_string_equal_content(p->key, name)))) {
17408 retval = &p->val;
17409 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17410 goto fetch_obj_is_copy;
17411 } else {
17412 goto fetch_obj_is_fast_copy;
17413 }
17414 }
17415 }
17416 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
17417 }
17418 retval = zend_hash_find_known_hash(zobj->properties, name);
17419 if (EXPECTED(retval)) {
17420 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
17421 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
17422 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
17423 goto fetch_obj_is_copy;
17424 } else {
17425 goto fetch_obj_is_fast_copy;
17426 }
17427 }
17428 }
17429 }
17430 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
17431 } else {
17432 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
17433 if (UNEXPECTED(!name)) {
17434 ZVAL_UNDEF(EX_VAR(opline->result.var));
17435 break;
17436 }
17437 }
17438
17439 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
17440
17441 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17442 zend_tmp_string_release(tmp_name);
17443 }
17444
17445 if (retval != EX_VAR(opline->result.var)) {
17446 fetch_obj_is_copy:
17447 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
17448 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
17449 zend_unwrap_reference(retval);
17450 }
17451 } while (0);
17452
17453 fetch_obj_is_finish:
17454 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17455 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17456 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17457 }
17458
ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17459 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17460 {
17461 USE_OPLINE
17462 zval *op1, *op2;
17463 zend_string *op1_str, *op2_str, *str;
17464
17465
17466 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17467 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17468 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
17469 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
17470 zend_string *op1_str = Z_STR_P(op1);
17471 zend_string *op2_str = Z_STR_P(op2);
17472 zend_string *str;
17473 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
17474
17475 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
17476 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17477 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
17478 } else {
17479 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
17480 }
17481 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17482 zend_string_release_ex(op1_str, 0);
17483 }
17484 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
17485 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
17486 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
17487 } else {
17488 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
17489 }
17490 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17491 zend_string_release_ex(op2_str, 0);
17492 }
17493 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
17494 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
17495 size_t len = ZSTR_LEN(op1_str);
17496
17497 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
17498 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17499 GC_ADD_FLAGS(str, flags);
17500 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17501 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17502 zend_string_release_ex(op2_str, 0);
17503 }
17504 } else {
17505 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
17506 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
17507 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17508 GC_ADD_FLAGS(str, flags);
17509 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17510 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17511 zend_string_release_ex(op1_str, 0);
17512 }
17513 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
17514 zend_string_release_ex(op2_str, 0);
17515 }
17516 }
17517 ZEND_VM_NEXT_OPCODE();
17518 }
17519
17520 SAVE_OPLINE();
17521 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17522 op1_str = Z_STR_P(op1);
17523 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17524 op1_str = zend_string_copy(Z_STR_P(op1));
17525 } else {
17526 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
17527 ZVAL_UNDEFINED_OP1();
17528 }
17529 op1_str = zval_get_string_func(op1);
17530 }
17531 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17532 op2_str = Z_STR_P(op2);
17533 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17534 op2_str = zend_string_copy(Z_STR_P(op2));
17535 } else {
17536 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
17537 ZVAL_UNDEFINED_OP2();
17538 }
17539 op2_str = zval_get_string_func(op2);
17540 }
17541 do {
17542 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17543 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
17544 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17545 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
17546 GC_ADDREF(op2_str);
17547 }
17548 }
17549 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
17550 zend_string_release_ex(op1_str, 0);
17551 break;
17552 }
17553 }
17554 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17555 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
17556 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17557 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
17558 GC_ADDREF(op1_str);
17559 }
17560 }
17561 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
17562 zend_string_release_ex(op2_str, 0);
17563 break;
17564 }
17565 }
17566 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
17567 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
17568 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
17569
17570 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
17571 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
17572 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17573 zend_string_release_ex(op1_str, 0);
17574 }
17575 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17576 zend_string_release_ex(op2_str, 0);
17577 }
17578 } while (0);
17579 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17580 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17581 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
17582 }
17583
ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17584 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17585 {
17586 USE_OPLINE
17587 zval *function_name;
17588 zval *object;
17589 zend_function *fbc;
17590 zend_class_entry *called_scope;
17591 zend_object *obj;
17592 zend_execute_data *call;
17593 uint32_t call_info;
17594
17595 SAVE_OPLINE();
17596
17597 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17598
17599 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17600 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17601 }
17602
17603 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
17604 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
17605 do {
17606 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
17607 function_name = Z_REFVAL_P(function_name);
17608 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
17609 break;
17610 }
17611 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
17612 ZVAL_UNDEFINED_OP2();
17613 if (UNEXPECTED(EG(exception) != NULL)) {
17614 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17615 HANDLE_EXCEPTION();
17616 }
17617 }
17618 zend_throw_error(NULL, "Method name must be a string");
17619 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17620 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17621 HANDLE_EXCEPTION();
17622 } while (0);
17623 }
17624
17625 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
17626 obj = Z_OBJ_P(object);
17627 } else {
17628 do {
17629 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
17630 obj = Z_OBJ_P(object);
17631 } else {
17632 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
17633 zend_reference *ref = Z_REF_P(object);
17634
17635 object = &ref->val;
17636 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
17637 obj = Z_OBJ_P(object);
17638 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
17639 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
17640 efree_size(ref, sizeof(zend_reference));
17641 } else {
17642 Z_ADDREF_P(object);
17643 }
17644 }
17645 break;
17646 }
17647 }
17648 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
17649 object = ZVAL_UNDEFINED_OP1();
17650 if (UNEXPECTED(EG(exception) != NULL)) {
17651 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17652 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17653 }
17654 HANDLE_EXCEPTION();
17655 }
17656 }
17657 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17658 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17659 }
17660 zend_invalid_method_call(object, function_name);
17661 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17662 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17663 HANDLE_EXCEPTION();
17664 }
17665 } while (0);
17666 }
17667
17668 called_scope = obj->ce;
17669
17670 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
17671 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
17672 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
17673 } else {
17674 zend_object *orig_obj = obj;
17675
17676 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17677 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17678 }
17679
17680 /* First, locate the function. */
17681 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));
17682 if (UNEXPECTED(fbc == NULL)) {
17683 if (EXPECTED(!EG(exception))) {
17684 zend_undefined_method(obj->ce, Z_STR_P(function_name));
17685 }
17686 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17687 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
17688 zend_objects_store_del(orig_obj);
17689 }
17690 HANDLE_EXCEPTION();
17691 }
17692 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
17693 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
17694 EXPECTED(obj == orig_obj)) {
17695 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
17696 }
17697 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
17698 GC_ADDREF(obj); /* For $this pointer */
17699 if (GC_DELREF(orig_obj) == 0) {
17700 zend_objects_store_del(orig_obj);
17701 }
17702 }
17703 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
17704 init_func_run_time_cache(&fbc->op_array);
17705 }
17706 }
17707
17708 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17709 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17710 }
17711
17712 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
17713 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
17714 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
17715 zend_objects_store_del(obj);
17716 if (UNEXPECTED(EG(exception))) {
17717 HANDLE_EXCEPTION();
17718 }
17719 }
17720 /* call static method */
17721 obj = (zend_object*)called_scope;
17722 call_info = ZEND_CALL_NESTED_FUNCTION;
17723 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
17724 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
17725 GC_ADDREF(obj); /* For $this pointer */
17726 }
17727 /* CV may be changed indirectly (e.g. when it's a reference) */
17728 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
17729 }
17730
17731 call = zend_vm_stack_push_call_frame(call_info,
17732 fbc, opline->extended_value, obj);
17733 call->prev_execute_data = EX(call);
17734 EX(call) = call;
17735
17736 ZEND_VM_NEXT_OPCODE();
17737 }
17738
ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17739 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17740 {
17741 USE_OPLINE
17742 zval *op1, *op2;
17743 double d1, d2;
17744
17745 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17746 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17747 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
17748 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17749 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
17750 case_true:
17751 ZEND_VM_SMART_BRANCH_TRUE();
17752 } else {
17753 case_false:
17754 ZEND_VM_SMART_BRANCH_FALSE();
17755 }
17756 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17757 d1 = (double)Z_LVAL_P(op1);
17758 d2 = Z_DVAL_P(op2);
17759 goto case_double;
17760 }
17761 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
17762 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
17763 d1 = Z_DVAL_P(op1);
17764 d2 = Z_DVAL_P(op2);
17765 case_double:
17766 if (d1 == d2) {
17767 goto case_true;
17768 } else {
17769 goto case_false;
17770 }
17771 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
17772 d1 = Z_DVAL_P(op1);
17773 d2 = (double)Z_LVAL_P(op2);
17774 goto case_double;
17775 }
17776 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
17777 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
17778 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
17779 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17780 if (result) {
17781 goto case_true;
17782 } else {
17783 goto case_false;
17784 }
17785 }
17786 }
17787 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
17788 }
17789
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17790 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17791 {
17792 USE_OPLINE
17793 zval *container;
17794 bool result;
17795 zend_ulong hval;
17796 zval *offset;
17797
17798 SAVE_OPLINE();
17799 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17800 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17801
17802 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17803 HashTable *ht;
17804 zval *value;
17805 zend_string *str;
17806
17807 isset_dim_obj_array:
17808 ht = Z_ARRVAL_P(container);
17809 isset_again:
17810 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
17811 str = Z_STR_P(offset);
17812 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17813 if (ZEND_HANDLE_NUMERIC(str, hval)) {
17814 goto num_index_prop;
17815 }
17816 }
17817 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
17818 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
17819 hval = Z_LVAL_P(offset);
17820 num_index_prop:
17821 value = zend_hash_index_find(ht, hval);
17822 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
17823 offset = Z_REFVAL_P(offset);
17824 goto isset_again;
17825 } else {
17826 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
17827 if (UNEXPECTED(EG(exception))) {
17828 result = 0;
17829 goto isset_dim_obj_exit;
17830 }
17831 }
17832
17833 if (!(opline->extended_value & ZEND_ISEMPTY)) {
17834 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
17835 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
17836 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
17837
17838 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
17839 /* avoid exception check */
17840 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17841 ZEND_VM_SMART_BRANCH(result, 0);
17842 }
17843 } else {
17844 result = (value == NULL || !i_zend_is_true(value));
17845 }
17846 goto isset_dim_obj_exit;
17847 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
17848 container = Z_REFVAL_P(container);
17849 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
17850 goto isset_dim_obj_array;
17851 }
17852 }
17853
17854 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
17855 offset++;
17856 }
17857 if (!(opline->extended_value & ZEND_ISEMPTY)) {
17858 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
17859 } else {
17860 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
17861 }
17862
17863 isset_dim_obj_exit:
17864 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17865 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17866 ZEND_VM_SMART_BRANCH(result, 1);
17867 }
17868
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17869 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17870 {
17871 USE_OPLINE
17872 zval *container;
17873 int result;
17874 zval *offset;
17875 zend_string *name, *tmp_name;
17876
17877 SAVE_OPLINE();
17878 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17879 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17880
17881 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
17882 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
17883 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
17884 container = Z_REFVAL_P(container);
17885 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
17886 result = (opline->extended_value & ZEND_ISEMPTY);
17887 goto isset_object_finish;
17888 }
17889 } else {
17890 result = (opline->extended_value & ZEND_ISEMPTY);
17891 goto isset_object_finish;
17892 }
17893 }
17894
17895 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
17896 name = Z_STR_P(offset);
17897 } else {
17898 name = zval_try_get_tmp_string(offset, &tmp_name);
17899 if (UNEXPECTED(!name)) {
17900 result = 0;
17901 goto isset_object_finish;
17902 }
17903 }
17904
17905 result =
17906 (opline->extended_value & ZEND_ISEMPTY) ^
17907 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));
17908
17909 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
17910 zend_tmp_string_release(tmp_name);
17911 }
17912
17913 isset_object_finish:
17914 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17915 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17916 ZEND_VM_SMART_BRANCH(result, 1);
17917 }
17918
ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17919 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17920 {
17921 USE_OPLINE
17922
17923 zval *key, *subject;
17924 HashTable *ht;
17925 bool result;
17926
17927 SAVE_OPLINE();
17928
17929 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17930 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
17931
17932 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
17933 array_key_exists_array:
17934 ht = Z_ARRVAL_P(subject);
17935 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
17936 } else {
17937 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
17938 subject = Z_REFVAL_P(subject);
17939 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
17940 goto array_key_exists_array;
17941 }
17942 }
17943 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
17944 result = 0;
17945 }
17946
17947 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
17948 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17949 ZEND_VM_SMART_BRANCH(result, 1);
17950 }
17951
17952 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)17953 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
17954 {
17955 USE_OPLINE
17956 zval *expr;
17957 bool result;
17958
17959 SAVE_OPLINE();
17960 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
17961
17962 try_instanceof:
17963 if (Z_TYPE_P(expr) == IS_OBJECT) {
17964 zend_class_entry *ce;
17965
17966 if (IS_VAR == IS_CONST) {
17967 ce = CACHED_PTR(opline->extended_value);
17968 if (UNEXPECTED(ce == NULL)) {
17969 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);
17970 if (EXPECTED(ce)) {
17971 CACHE_PTR(opline->extended_value, ce);
17972 }
17973 }
17974 } else if (IS_VAR == IS_UNUSED) {
17975 ce = zend_fetch_class(NULL, opline->op2.num);
17976 if (UNEXPECTED(ce == NULL)) {
17977 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17978 ZVAL_UNDEF(EX_VAR(opline->result.var));
17979 HANDLE_EXCEPTION();
17980 }
17981 } else {
17982 ce = Z_CE_P(EX_VAR(opline->op2.var));
17983 }
17984 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
17985 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
17986 expr = Z_REFVAL_P(expr);
17987 goto try_instanceof;
17988 } else {
17989 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
17990 ZVAL_UNDEFINED_OP1();
17991 }
17992 result = 0;
17993 }
17994 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
17995 ZEND_VM_SMART_BRANCH(result, 1);
17996 }
17997
zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)17998 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)
17999 {
18000 USE_OPLINE
18001 zval *varname;
18002 zval *retval;
18003 zend_string *name, *tmp_name;
18004 HashTable *target_symbol_table;
18005
18006 SAVE_OPLINE();
18007 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18008
18009 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18010 name = Z_STR_P(varname);
18011 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18012 name = Z_STR_P(varname);
18013 tmp_name = NULL;
18014 } else {
18015 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18016 ZVAL_UNDEFINED_OP1();
18017 }
18018 name = zval_try_get_tmp_string(varname, &tmp_name);
18019 if (UNEXPECTED(!name)) {
18020 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18021 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18022 }
18023 ZVAL_UNDEF(EX_VAR(opline->result.var));
18024 HANDLE_EXCEPTION();
18025 }
18026 }
18027
18028 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18029 retval = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18030 if (retval == NULL) {
18031 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18032 fetch_this:
18033 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
18034 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18035 zend_tmp_string_release(tmp_name);
18036 }
18037 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18038 }
18039 if (type == BP_VAR_W) {
18040 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
18041 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18042 retval = &EG(uninitialized_zval);
18043 } else {
18044 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18045 /* Keep name alive in case an error handler tries to free it. */
18046 zend_string_addref(name);
18047 }
18048 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18049 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18050 if (type == BP_VAR_RW && !EG(exception)) {
18051 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
18052 } else {
18053 retval = &EG(uninitialized_zval);
18054 }
18055 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
18056 zend_string_release(name);
18057 }
18058 }
18059 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
18060 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
18061 retval = Z_INDIRECT_P(retval);
18062 if (Z_TYPE_P(retval) == IS_UNDEF) {
18063 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
18064 goto fetch_this;
18065 }
18066 if (type == BP_VAR_W) {
18067 ZVAL_NULL(retval);
18068 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
18069 retval = &EG(uninitialized_zval);
18070 } else {
18071 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
18072 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
18073 if (type == BP_VAR_RW && !EG(exception)) {
18074 ZVAL_NULL(retval);
18075 } else {
18076 retval = &EG(uninitialized_zval);
18077 }
18078 }
18079 }
18080 }
18081
18082 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
18083 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18084 }
18085
18086 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18087 zend_tmp_string_release(tmp_name);
18088 }
18089
18090 ZEND_ASSERT(retval != NULL);
18091 if (type == BP_VAR_R || type == BP_VAR_IS) {
18092 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18093 } else {
18094 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
18095 }
18096 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18097 }
18098
ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18099 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18100 {
18101 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18102 }
18103
ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18104 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18105 {
18106 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18107 }
18108
ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18109 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18110 {
18111 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18112 }
18113
ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18114 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18115 {
18116 int fetch_type =
18117 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
18118 BP_VAR_W : BP_VAR_R;
18119 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18120 }
18121
ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18122 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18123 {
18124 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18125 }
18126
ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18127 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18128 {
18129 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
18130 }
18131
18132 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18133 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18134 {
18135 USE_OPLINE
18136 zval *value, *arg;
18137
18138 if (IS_UNUSED == IS_CONST) {
18139 SAVE_OPLINE();
18140 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
18141 uint32_t arg_num;
18142 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
18143 if (UNEXPECTED(!arg)) {
18144 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18145 HANDLE_EXCEPTION();
18146 }
18147 } else {
18148 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
18149 }
18150
18151 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18152 ZVAL_COPY_VALUE(arg, value);
18153 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18154 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
18155 Z_ADDREF_P(arg);
18156 }
18157 }
18158 ZEND_VM_NEXT_OPCODE();
18159 }
18160
ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18161 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18162 {
18163 USE_OPLINE
18164 zval *varname;
18165 zend_string *name, *tmp_name;
18166 HashTable *target_symbol_table;
18167
18168 SAVE_OPLINE();
18169
18170 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18171
18172 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18173 name = Z_STR_P(varname);
18174 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
18175 name = Z_STR_P(varname);
18176 tmp_name = NULL;
18177 } else {
18178 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
18179 varname = ZVAL_UNDEFINED_OP1();
18180 }
18181 name = zval_try_get_tmp_string(varname, &tmp_name);
18182 if (UNEXPECTED(!name)) {
18183 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18184 HANDLE_EXCEPTION();
18185 }
18186 }
18187
18188 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18189 zend_hash_del_ind(target_symbol_table, name);
18190
18191 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18192 zend_tmp_string_release(tmp_name);
18193 }
18194 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18195 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18196 }
18197
18198 /* 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)18199 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18200 {
18201 USE_OPLINE
18202 zval *value;
18203 /* Should be bool result? as below got: result = (opline->extended_value & ZEND_ISEMPTY) */
18204 int result;
18205 zval *varname;
18206 zend_string *name, *tmp_name;
18207 HashTable *target_symbol_table;
18208
18209 SAVE_OPLINE();
18210 varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18211 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18212 name = Z_STR_P(varname);
18213 } else {
18214 name = zval_get_tmp_string(varname, &tmp_name);
18215 }
18216
18217 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
18218 value = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST);
18219
18220 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18221 zend_tmp_string_release(tmp_name);
18222 }
18223 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18224
18225 if (!value) {
18226 result = (opline->extended_value & ZEND_ISEMPTY);
18227 } else {
18228 if (Z_TYPE_P(value) == IS_INDIRECT) {
18229 value = Z_INDIRECT_P(value);
18230 }
18231 if (!(opline->extended_value & ZEND_ISEMPTY)) {
18232 if (Z_ISREF_P(value)) {
18233 value = Z_REFVAL_P(value);
18234 }
18235 result = Z_TYPE_P(value) > IS_NULL;
18236 } else {
18237 result = !i_zend_is_true(value);
18238 }
18239 }
18240
18241 ZEND_VM_SMART_BRANCH(result, 1);
18242 }
18243
18244 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18245 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18246 {
18247 USE_OPLINE
18248 zval *expr;
18249 bool result;
18250
18251 SAVE_OPLINE();
18252 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18253
18254 try_instanceof:
18255 if (Z_TYPE_P(expr) == IS_OBJECT) {
18256 zend_class_entry *ce;
18257
18258 if (IS_UNUSED == IS_CONST) {
18259 ce = CACHED_PTR(opline->extended_value);
18260 if (UNEXPECTED(ce == NULL)) {
18261 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);
18262 if (EXPECTED(ce)) {
18263 CACHE_PTR(opline->extended_value, ce);
18264 }
18265 }
18266 } else if (IS_UNUSED == IS_UNUSED) {
18267 ce = zend_fetch_class(NULL, opline->op2.num);
18268 if (UNEXPECTED(ce == NULL)) {
18269 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18270 ZVAL_UNDEF(EX_VAR(opline->result.var));
18271 HANDLE_EXCEPTION();
18272 }
18273 } else {
18274 ce = Z_CE_P(EX_VAR(opline->op2.var));
18275 }
18276 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
18277 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
18278 expr = Z_REFVAL_P(expr);
18279 goto try_instanceof;
18280 } else {
18281 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
18282 ZVAL_UNDEFINED_OP1();
18283 }
18284 result = 0;
18285 }
18286 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18287 ZEND_VM_SMART_BRANCH(result, 1);
18288 }
18289
ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18290 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18291 {
18292 USE_OPLINE
18293 zval *op1;
18294 zend_long count;
18295
18296 SAVE_OPLINE();
18297 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18298
18299 while (1) {
18300 if (Z_TYPE_P(op1) == IS_ARRAY) {
18301 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
18302 break;
18303 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
18304 zend_object *zobj = Z_OBJ_P(op1);
18305
18306 /* first, we check if the handler is defined */
18307 if (zobj->handlers->count_elements) {
18308 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
18309 break;
18310 }
18311 if (UNEXPECTED(EG(exception))) {
18312 count = 0;
18313 break;
18314 }
18315 }
18316
18317 /* if not and the object implements Countable we call its count() method */
18318 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
18319 zval retval;
18320
18321 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
18322 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
18323 count = zval_get_long(&retval);
18324 zval_ptr_dtor(&retval);
18325 break;
18326 }
18327
18328 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
18329 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
18330 op1 = Z_REFVAL_P(op1);
18331 continue;
18332 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18333 ZVAL_UNDEFINED_OP1();
18334 }
18335 count = 0;
18336 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));
18337 break;
18338 }
18339
18340 ZVAL_LONG(EX_VAR(opline->result.var), count);
18341 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18342 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18343 }
18344
ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18345 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18346 {
18347 USE_OPLINE
18348 zend_array *ht = Z_ARRVAL_P(_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC));
18349 ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
18350 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
18351 SAVE_OPLINE();
18352 zend_array_destroy(ht);
18353 if (EG(exception)) {
18354 HANDLE_EXCEPTION();
18355 }
18356 }
18357 ZEND_VM_NEXT_OPCODE();
18358 }
18359
ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18360 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18361 {
18362 USE_OPLINE
18363
18364 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
18365 SAVE_OPLINE();
18366 if (UNEXPECTED(!EX(func)->common.scope)) {
18367 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
18368 ZVAL_UNDEF(EX_VAR(opline->result.var));
18369 HANDLE_EXCEPTION();
18370 } else {
18371 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
18372 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
18373 if (UNEXPECTED(EG(exception))) {
18374 HANDLE_EXCEPTION();
18375 }
18376 ZEND_VM_NEXT_OPCODE();
18377 }
18378 } else {
18379 zval *op1;
18380
18381 SAVE_OPLINE();
18382 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18383 while (1) {
18384 if (Z_TYPE_P(op1) == IS_OBJECT) {
18385 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
18386 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
18387 op1 = Z_REFVAL_P(op1);
18388 continue;
18389 } else {
18390 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18391 ZVAL_UNDEFINED_OP1();
18392 }
18393 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
18394 ZVAL_UNDEF(EX_VAR(opline->result.var));
18395 }
18396 break;
18397 }
18398 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18399 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18400 }
18401 }
18402
ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18403 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18404 {
18405 USE_OPLINE
18406 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18407 zval *result = EX_VAR(opline->result.var);
18408 ZVAL_COPY(result, value);
18409 ZEND_VM_NEXT_OPCODE();
18410 }
18411
ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18412 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18413 {
18414 USE_OPLINE
18415 zval *op1, *op2;
18416
18417 SAVE_OPLINE();
18418 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18419 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
18420 div_function(EX_VAR(opline->result.var), op1, op2);
18421 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18422
18423 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18424 }
18425
ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18426 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18427 {
18428 USE_OPLINE
18429 zval *op1, *op2;
18430
18431 SAVE_OPLINE();
18432 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18433 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
18434 pow_function(EX_VAR(opline->result.var), op1, op2);
18435 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18436
18437 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18438 }
18439
ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18440 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18441 {
18442 USE_OPLINE
18443 zval *op1, *op2;
18444
18445 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18446 op2 = EX_VAR(opline->op2.var);
18447
18448 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
18449 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
18450 zend_string *op1_str = Z_STR_P(op1);
18451 zend_string *op2_str = Z_STR_P(op2);
18452 zend_string *str;
18453 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
18454
18455 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18456 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
18457 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
18458 } else {
18459 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18460 }
18461 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18462 zend_string_release_ex(op1_str, 0);
18463 }
18464 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18465 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
18466 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
18467 } else {
18468 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18469 }
18470 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18471 zend_string_release_ex(op2_str, 0);
18472 }
18473 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
18474 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
18475 size_t len = ZSTR_LEN(op1_str);
18476
18477 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
18478 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
18479 }
18480 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
18481 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18482 GC_ADD_FLAGS(str, flags);
18483 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18484 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18485 zend_string_release_ex(op2_str, 0);
18486 }
18487 } else {
18488 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18489 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18490 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18491 GC_ADD_FLAGS(str, flags);
18492 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18493 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18494 zend_string_release_ex(op1_str, 0);
18495 }
18496 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18497 zend_string_release_ex(op2_str, 0);
18498 }
18499 }
18500 ZEND_VM_NEXT_OPCODE();
18501 } else {
18502 SAVE_OPLINE();
18503
18504 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18505 op1 = ZVAL_UNDEFINED_OP1();
18506 }
18507 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
18508 op2 = ZVAL_UNDEFINED_OP2();
18509 }
18510 concat_function(EX_VAR(opline->result.var), op1, op2);
18511 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18512
18513 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18514 }
18515 }
18516
ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18517 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18518 {
18519 USE_OPLINE
18520 zval *op1, *op2;
18521
18522 SAVE_OPLINE();
18523 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18524 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
18525 compare_function(EX_VAR(opline->result.var), op1, op2);
18526 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18527
18528 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18529 }
18530
ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18531 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18532 {
18533 USE_OPLINE
18534 zval *container, *dim, *value;
18535
18536 SAVE_OPLINE();
18537 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18538 dim = EX_VAR(opline->op2.var);
18539 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18540 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18541 fetch_dim_r_array:
18542 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
18543 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
18544 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
18545 container = Z_REFVAL_P(container);
18546 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
18547 goto fetch_dim_r_array;
18548 } else {
18549 goto fetch_dim_r_slow;
18550 }
18551 } else {
18552 fetch_dim_r_slow:
18553 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
18554 dim++;
18555 }
18556 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
18557 }
18558 } else {
18559 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
18560 }
18561
18562 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18563 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18564 }
18565
ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18566 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18567 {
18568 USE_OPLINE
18569 zval *container;
18570
18571 SAVE_OPLINE();
18572 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18573 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
18574
18575 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18576 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18577 }
18578
ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18579 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18580 {
18581 USE_OPLINE
18582 zval *container;
18583 void **cache_slot = NULL;
18584
18585 SAVE_OPLINE();
18586 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18587
18588 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
18589 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
18590 do {
18591 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
18592 container = Z_REFVAL_P(container);
18593 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
18594 break;
18595 }
18596 }
18597 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
18598 ZVAL_UNDEFINED_OP1();
18599 }
18600 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
18601 ZVAL_NULL(EX_VAR(opline->result.var));
18602 goto fetch_obj_r_finish;
18603 } while (0);
18604 }
18605
18606 /* here we are sure we are dealing with an object */
18607 do {
18608 zend_object *zobj = Z_OBJ_P(container);
18609 zend_string *name, *tmp_name;
18610 zval *retval;
18611
18612 if (IS_CV == IS_CONST) {
18613 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
18614
18615 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
18616 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
18617
18618 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
18619 retval = OBJ_PROP(zobj, prop_offset);
18620 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
18621 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18622 goto fetch_obj_r_copy;
18623 } else {
18624 fetch_obj_r_fast_copy:
18625 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18626 ZEND_VM_NEXT_OPCODE();
18627 }
18628 }
18629 } else if (EXPECTED(zobj->properties != NULL)) {
18630 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
18631 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
18632 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
18633
18634 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
18635 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
18636
18637 if (EXPECTED(p->key == name) ||
18638 (EXPECTED(p->h == ZSTR_H(name)) &&
18639 EXPECTED(p->key != NULL) &&
18640 EXPECTED(zend_string_equal_content(p->key, name)))) {
18641 retval = &p->val;
18642 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18643 goto fetch_obj_r_copy;
18644 } else {
18645 goto fetch_obj_r_fast_copy;
18646 }
18647 }
18648 }
18649 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
18650 }
18651 retval = zend_hash_find_known_hash(zobj->properties, name);
18652 if (EXPECTED(retval)) {
18653 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
18654 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
18655 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18656 goto fetch_obj_r_copy;
18657 } else {
18658 goto fetch_obj_r_fast_copy;
18659 }
18660 }
18661 }
18662 }
18663 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
18664 } else {
18665 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
18666 if (UNEXPECTED(!name)) {
18667 ZVAL_UNDEF(EX_VAR(opline->result.var));
18668 break;
18669 }
18670 }
18671
18672 #if ZEND_DEBUG
18673 /* For non-standard object handlers, verify a declared property type in debug builds.
18674 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
18675 zend_property_info *prop_info = NULL;
18676 if (zobj->handlers->read_property != zend_std_read_property) {
18677 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
18678 }
18679 #endif
18680 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
18681 #if ZEND_DEBUG
18682 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
18683 && ZEND_TYPE_IS_SET(prop_info->type)) {
18684 ZVAL_OPT_DEREF(retval);
18685 zend_verify_property_type(prop_info, retval, /* strict */ true);
18686 }
18687 #endif
18688
18689 if (IS_CV != IS_CONST) {
18690 zend_tmp_string_release(tmp_name);
18691 }
18692
18693 if (retval != EX_VAR(opline->result.var)) {
18694 fetch_obj_r_copy:
18695 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18696 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
18697 zend_unwrap_reference(retval);
18698 }
18699 } while (0);
18700
18701 fetch_obj_r_finish:
18702
18703 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18704 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18705 }
18706
ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18707 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18708 {
18709 USE_OPLINE
18710 zval *container;
18711 void **cache_slot = NULL;
18712
18713 SAVE_OPLINE();
18714 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18715
18716 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
18717 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
18718 do {
18719 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
18720 container = Z_REFVAL_P(container);
18721 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
18722 break;
18723 }
18724 }
18725 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
18726 ZVAL_UNDEFINED_OP2();
18727 }
18728 ZVAL_NULL(EX_VAR(opline->result.var));
18729 goto fetch_obj_is_finish;
18730 } while (0);
18731 }
18732
18733 /* here we are sure we are dealing with an object */
18734 do {
18735 zend_object *zobj = Z_OBJ_P(container);
18736 zend_string *name, *tmp_name;
18737 zval *retval;
18738
18739 if (IS_CV == IS_CONST) {
18740 cache_slot = CACHE_ADDR(opline->extended_value);
18741
18742 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
18743 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
18744
18745 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
18746 retval = OBJ_PROP(zobj, prop_offset);
18747 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
18748 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18749 goto fetch_obj_is_copy;
18750 } else {
18751 fetch_obj_is_fast_copy:
18752 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18753 ZEND_VM_NEXT_OPCODE();
18754 }
18755 }
18756 } else if (EXPECTED(zobj->properties != NULL)) {
18757 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
18758 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
18759 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
18760
18761 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
18762 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
18763
18764 if (EXPECTED(p->key == name) ||
18765 (EXPECTED(p->h == ZSTR_H(name)) &&
18766 EXPECTED(p->key != NULL) &&
18767 EXPECTED(zend_string_equal_content(p->key, name)))) {
18768 retval = &p->val;
18769 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18770 goto fetch_obj_is_copy;
18771 } else {
18772 goto fetch_obj_is_fast_copy;
18773 }
18774 }
18775 }
18776 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
18777 }
18778 retval = zend_hash_find_known_hash(zobj->properties, name);
18779 if (EXPECTED(retval)) {
18780 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
18781 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
18782 if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
18783 goto fetch_obj_is_copy;
18784 } else {
18785 goto fetch_obj_is_fast_copy;
18786 }
18787 }
18788 }
18789 }
18790 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
18791 } else {
18792 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
18793 if (UNEXPECTED(!name)) {
18794 ZVAL_UNDEF(EX_VAR(opline->result.var));
18795 break;
18796 }
18797 }
18798
18799 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
18800
18801 if (IS_CV != IS_CONST) {
18802 zend_tmp_string_release(tmp_name);
18803 }
18804
18805 if (retval != EX_VAR(opline->result.var)) {
18806 fetch_obj_is_copy:
18807 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
18808 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
18809 zend_unwrap_reference(retval);
18810 }
18811 } while (0);
18812
18813 fetch_obj_is_finish:
18814
18815 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18816 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18817 }
18818
ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18819 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18820 {
18821 USE_OPLINE
18822 zval *op1, *op2;
18823 zend_string *op1_str, *op2_str, *str;
18824
18825
18826 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18827 op2 = EX_VAR(opline->op2.var);
18828 if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
18829 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
18830 zend_string *op1_str = Z_STR_P(op1);
18831 zend_string *op2_str = Z_STR_P(op2);
18832 zend_string *str;
18833 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
18834
18835 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18836 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
18837 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
18838 } else {
18839 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18840 }
18841 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18842 zend_string_release_ex(op1_str, 0);
18843 }
18844 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18845 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
18846 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
18847 } else {
18848 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18849 }
18850 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18851 zend_string_release_ex(op2_str, 0);
18852 }
18853 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
18854 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
18855 size_t len = ZSTR_LEN(op1_str);
18856
18857 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
18858 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18859 GC_ADD_FLAGS(str, flags);
18860 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18861 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18862 zend_string_release_ex(op2_str, 0);
18863 }
18864 } else {
18865 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18866 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18867 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18868 GC_ADD_FLAGS(str, flags);
18869 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18870 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
18871 zend_string_release_ex(op1_str, 0);
18872 }
18873 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
18874 zend_string_release_ex(op2_str, 0);
18875 }
18876 }
18877 ZEND_VM_NEXT_OPCODE();
18878 }
18879
18880 SAVE_OPLINE();
18881 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18882 op1_str = Z_STR_P(op1);
18883 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
18884 op1_str = zend_string_copy(Z_STR_P(op1));
18885 } else {
18886 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
18887 ZVAL_UNDEFINED_OP1();
18888 }
18889 op1_str = zval_get_string_func(op1);
18890 }
18891 if (IS_CV == IS_CONST) {
18892 op2_str = Z_STR_P(op2);
18893 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
18894 op2_str = zend_string_copy(Z_STR_P(op2));
18895 } else {
18896 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
18897 ZVAL_UNDEFINED_OP2();
18898 }
18899 op2_str = zval_get_string_func(op2);
18900 }
18901 do {
18902 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18903 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
18904 if (IS_CV == IS_CONST) {
18905 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
18906 GC_ADDREF(op2_str);
18907 }
18908 }
18909 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
18910 zend_string_release_ex(op1_str, 0);
18911 break;
18912 }
18913 }
18914 if (IS_CV != IS_CONST) {
18915 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
18916 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
18917 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
18918 GC_ADDREF(op1_str);
18919 }
18920 }
18921 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
18922 zend_string_release_ex(op2_str, 0);
18923 break;
18924 }
18925 }
18926 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
18927 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
18928 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
18929
18930 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
18931 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
18932 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
18933 zend_string_release_ex(op1_str, 0);
18934 }
18935 if (IS_CV != IS_CONST) {
18936 zend_string_release_ex(op2_str, 0);
18937 }
18938 } while (0);
18939 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18940
18941 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
18942 }
18943
ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)18944 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
18945 {
18946 USE_OPLINE
18947 zval *function_name;
18948 zval *object;
18949 zend_function *fbc;
18950 zend_class_entry *called_scope;
18951 zend_object *obj;
18952 zend_execute_data *call;
18953 uint32_t call_info;
18954
18955 SAVE_OPLINE();
18956
18957 object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
18958
18959 if (IS_CV != IS_CONST) {
18960 function_name = EX_VAR(opline->op2.var);
18961 }
18962
18963 if (IS_CV != IS_CONST &&
18964 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
18965 do {
18966 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
18967 function_name = Z_REFVAL_P(function_name);
18968 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
18969 break;
18970 }
18971 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
18972 ZVAL_UNDEFINED_OP2();
18973 if (UNEXPECTED(EG(exception) != NULL)) {
18974 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18975 HANDLE_EXCEPTION();
18976 }
18977 }
18978 zend_throw_error(NULL, "Method name must be a string");
18979
18980 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
18981 HANDLE_EXCEPTION();
18982 } while (0);
18983 }
18984
18985 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
18986 obj = Z_OBJ_P(object);
18987 } else {
18988 do {
18989 if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
18990 obj = Z_OBJ_P(object);
18991 } else {
18992 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
18993 zend_reference *ref = Z_REF_P(object);
18994
18995 object = &ref->val;
18996 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
18997 obj = Z_OBJ_P(object);
18998 if ((IS_TMP_VAR|IS_VAR) & IS_VAR) {
18999 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19000 efree_size(ref, sizeof(zend_reference));
19001 } else {
19002 Z_ADDREF_P(object);
19003 }
19004 }
19005 break;
19006 }
19007 }
19008 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
19009 object = ZVAL_UNDEFINED_OP1();
19010 if (UNEXPECTED(EG(exception) != NULL)) {
19011 if (IS_CV != IS_CONST) {
19012
19013 }
19014 HANDLE_EXCEPTION();
19015 }
19016 }
19017 if (IS_CV == IS_CONST) {
19018 function_name = EX_VAR(opline->op2.var);
19019 }
19020 zend_invalid_method_call(object, function_name);
19021
19022 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19023 HANDLE_EXCEPTION();
19024 }
19025 } while (0);
19026 }
19027
19028 called_scope = obj->ce;
19029
19030 if (IS_CV == IS_CONST &&
19031 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
19032 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
19033 } else {
19034 zend_object *orig_obj = obj;
19035
19036 if (IS_CV == IS_CONST) {
19037 function_name = EX_VAR(opline->op2.var);
19038 }
19039
19040 /* First, locate the function. */
19041 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
19042 if (UNEXPECTED(fbc == NULL)) {
19043 if (EXPECTED(!EG(exception))) {
19044 zend_undefined_method(obj->ce, Z_STR_P(function_name));
19045 }
19046
19047 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
19048 zend_objects_store_del(orig_obj);
19049 }
19050 HANDLE_EXCEPTION();
19051 }
19052 if (IS_CV == IS_CONST &&
19053 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
19054 EXPECTED(obj == orig_obj)) {
19055 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
19056 }
19057 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
19058 GC_ADDREF(obj); /* For $this pointer */
19059 if (GC_DELREF(orig_obj) == 0) {
19060 zend_objects_store_del(orig_obj);
19061 }
19062 }
19063 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
19064 init_func_run_time_cache(&fbc->op_array);
19065 }
19066 }
19067
19068 if (IS_CV != IS_CONST) {
19069
19070 }
19071
19072 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
19073 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
19074 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
19075 zend_objects_store_del(obj);
19076 if (UNEXPECTED(EG(exception))) {
19077 HANDLE_EXCEPTION();
19078 }
19079 }
19080 /* call static method */
19081 obj = (zend_object*)called_scope;
19082 call_info = ZEND_CALL_NESTED_FUNCTION;
19083 } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) {
19084 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
19085 GC_ADDREF(obj); /* For $this pointer */
19086 }
19087 /* CV may be changed indirectly (e.g. when it's a reference) */
19088 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
19089 }
19090
19091 call = zend_vm_stack_push_call_frame(call_info,
19092 fbc, opline->extended_value, obj);
19093 call->prev_execute_data = EX(call);
19094 EX(call) = call;
19095
19096 ZEND_VM_NEXT_OPCODE();
19097 }
19098
ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19099 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19100 {
19101 USE_OPLINE
19102 zval *op1, *op2;
19103 double d1, d2;
19104
19105 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19106 op2 = EX_VAR(opline->op2.var);
19107 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
19108 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19109 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
19110 case_true:
19111 ZEND_VM_SMART_BRANCH_TRUE();
19112 } else {
19113 case_false:
19114 ZEND_VM_SMART_BRANCH_FALSE();
19115 }
19116 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19117 d1 = (double)Z_LVAL_P(op1);
19118 d2 = Z_DVAL_P(op2);
19119 goto case_double;
19120 }
19121 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
19122 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
19123 d1 = Z_DVAL_P(op1);
19124 d2 = Z_DVAL_P(op2);
19125 case_double:
19126 if (d1 == d2) {
19127 goto case_true;
19128 } else {
19129 goto case_false;
19130 }
19131 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
19132 d1 = Z_DVAL_P(op1);
19133 d2 = (double)Z_LVAL_P(op2);
19134 goto case_double;
19135 }
19136 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
19137 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
19138 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
19139
19140 if (result) {
19141 goto case_true;
19142 } else {
19143 goto case_false;
19144 }
19145 }
19146 }
19147 ZEND_VM_TAIL_CALL(zend_case_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
19148 }
19149
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19150 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19151 {
19152 USE_OPLINE
19153 zval *container;
19154 bool result;
19155 zend_ulong hval;
19156 zval *offset;
19157
19158 SAVE_OPLINE();
19159 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19160 offset = EX_VAR(opline->op2.var);
19161
19162 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19163 HashTable *ht;
19164 zval *value;
19165 zend_string *str;
19166
19167 isset_dim_obj_array:
19168 ht = Z_ARRVAL_P(container);
19169 isset_again:
19170 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
19171 str = Z_STR_P(offset);
19172 if (IS_CV != IS_CONST) {
19173 if (ZEND_HANDLE_NUMERIC(str, hval)) {
19174 goto num_index_prop;
19175 }
19176 }
19177 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
19178 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
19179 hval = Z_LVAL_P(offset);
19180 num_index_prop:
19181 value = zend_hash_index_find(ht, hval);
19182 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
19183 offset = Z_REFVAL_P(offset);
19184 goto isset_again;
19185 } else {
19186 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
19187 if (UNEXPECTED(EG(exception))) {
19188 result = 0;
19189 goto isset_dim_obj_exit;
19190 }
19191 }
19192
19193 if (!(opline->extended_value & ZEND_ISEMPTY)) {
19194 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
19195 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
19196 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
19197
19198 if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) {
19199 /* avoid exception check */
19200
19201 ZEND_VM_SMART_BRANCH(result, 0);
19202 }
19203 } else {
19204 result = (value == NULL || !i_zend_is_true(value));
19205 }
19206 goto isset_dim_obj_exit;
19207 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
19208 container = Z_REFVAL_P(container);
19209 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
19210 goto isset_dim_obj_array;
19211 }
19212 }
19213
19214 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
19215 offset++;
19216 }
19217 if (!(opline->extended_value & ZEND_ISEMPTY)) {
19218 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
19219 } else {
19220 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
19221 }
19222
19223 isset_dim_obj_exit:
19224
19225 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19226 ZEND_VM_SMART_BRANCH(result, 1);
19227 }
19228
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19229 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19230 {
19231 USE_OPLINE
19232 zval *container;
19233 int result;
19234 zval *offset;
19235 zend_string *name, *tmp_name;
19236
19237 SAVE_OPLINE();
19238 container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19239 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
19240
19241 if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
19242 ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
19243 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
19244 container = Z_REFVAL_P(container);
19245 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
19246 result = (opline->extended_value & ZEND_ISEMPTY);
19247 goto isset_object_finish;
19248 }
19249 } else {
19250 result = (opline->extended_value & ZEND_ISEMPTY);
19251 goto isset_object_finish;
19252 }
19253 }
19254
19255 if (IS_CV == IS_CONST) {
19256 name = Z_STR_P(offset);
19257 } else {
19258 name = zval_try_get_tmp_string(offset, &tmp_name);
19259 if (UNEXPECTED(!name)) {
19260 result = 0;
19261 goto isset_object_finish;
19262 }
19263 }
19264
19265 result =
19266 (opline->extended_value & ZEND_ISEMPTY) ^
19267 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));
19268
19269 if (IS_CV != IS_CONST) {
19270 zend_tmp_string_release(tmp_name);
19271 }
19272
19273 isset_object_finish:
19274
19275 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19276 ZEND_VM_SMART_BRANCH(result, 1);
19277 }
19278
ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19279 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19280 {
19281 USE_OPLINE
19282
19283 zval *key, *subject;
19284 HashTable *ht;
19285 bool result;
19286
19287 SAVE_OPLINE();
19288
19289 key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
19290 subject = EX_VAR(opline->op2.var);
19291
19292 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
19293 array_key_exists_array:
19294 ht = Z_ARRVAL_P(subject);
19295 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
19296 } else {
19297 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
19298 subject = Z_REFVAL_P(subject);
19299 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
19300 goto array_key_exists_array;
19301 }
19302 }
19303 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
19304 result = 0;
19305 }
19306
19307 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19308 ZEND_VM_SMART_BRANCH(result, 1);
19309 }
19310
19311 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19312 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19313 {
19314 USE_OPLINE
19315 zval *retval_ptr;
19316 zval *return_value;
19317
19318 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19319 return_value = EX(return_value);
19320
19321 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
19322 SAVE_OPLINE();
19323 retval_ptr = ZVAL_UNDEFINED_OP1();
19324 if (return_value) {
19325 ZVAL_NULL(return_value);
19326 }
19327 } else if (!return_value) {
19328 if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
19329 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
19330 SAVE_OPLINE();
19331 rc_dtor_func(Z_COUNTED_P(retval_ptr));
19332 }
19333 }
19334 } else {
19335 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
19336 ZVAL_COPY_VALUE(return_value, retval_ptr);
19337 if (IS_TMP_VAR == IS_CONST) {
19338 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
19339 Z_ADDREF_P(return_value);
19340 }
19341 }
19342 } else if (IS_TMP_VAR == IS_CV) {
19343 do {
19344 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19345 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
19346 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
19347 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
19348 ZVAL_COPY_VALUE(return_value, retval_ptr);
19349 if (GC_MAY_LEAK(ref)) {
19350 SAVE_OPLINE();
19351 gc_possible_root(ref);
19352 }
19353 ZVAL_NULL(retval_ptr);
19354 break;
19355 } else {
19356 Z_ADDREF_P(retval_ptr);
19357 }
19358 } else {
19359 retval_ptr = Z_REFVAL_P(retval_ptr);
19360 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19361 Z_ADDREF_P(retval_ptr);
19362 }
19363 }
19364 }
19365 ZVAL_COPY_VALUE(return_value, retval_ptr);
19366 } while (0);
19367 } else /* if (IS_TMP_VAR == IS_VAR) */ {
19368 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
19369 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
19370
19371 retval_ptr = Z_REFVAL_P(retval_ptr);
19372 ZVAL_COPY_VALUE(return_value, retval_ptr);
19373 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19374 efree_size(ref, sizeof(zend_reference));
19375 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
19376 Z_ADDREF_P(retval_ptr);
19377 }
19378 } else {
19379 ZVAL_COPY_VALUE(return_value, retval_ptr);
19380 }
19381 }
19382 }
19383
19384
19385
19386 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
19387 }
19388
ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19389 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19390 {
19391 USE_OPLINE
19392 zval *retval_ptr;
19393 zval *return_value;
19394
19395 SAVE_OPLINE();
19396
19397 return_value = EX(return_value);
19398
19399 do {
19400 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) ||
19401 (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
19402 /* Not supposed to happen, but we'll allow it */
19403 zend_error(E_NOTICE, "Only variable references should be returned by reference");
19404
19405 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19406 if (!return_value) {
19407 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19408 } else {
19409 if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
19410 ZVAL_COPY_VALUE(return_value, retval_ptr);
19411 break;
19412 }
19413
19414 ZVAL_NEW_REF(return_value, retval_ptr);
19415 if (IS_TMP_VAR == IS_CONST) {
19416 Z_TRY_ADDREF_P(retval_ptr);
19417 }
19418 }
19419 break;
19420 }
19421
19422 retval_ptr = zend_get_bad_ptr();
19423
19424 if (IS_TMP_VAR == IS_VAR) {
19425 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
19426 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
19427 zend_error(E_NOTICE, "Only variable references should be returned by reference");
19428 if (return_value) {
19429 ZVAL_NEW_REF(return_value, retval_ptr);
19430 } else {
19431 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19432 }
19433 break;
19434 }
19435 }
19436
19437 if (return_value) {
19438 if (Z_ISREF_P(retval_ptr)) {
19439 Z_ADDREF_P(retval_ptr);
19440 } else {
19441 ZVAL_MAKE_REF_EX(retval_ptr, 2);
19442 }
19443 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
19444 }
19445
19446 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19447 } while (0);
19448
19449
19450 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
19451 }
19452
ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19453 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19454 {
19455 USE_OPLINE
19456 zval *retval;
19457
19458 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
19459
19460 SAVE_OPLINE();
19461 retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19462
19463 /* Copy return value into generator->retval */
19464 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
19465 ZVAL_COPY_VALUE(&generator->retval, retval);
19466 if (IS_TMP_VAR == IS_CONST) {
19467 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
19468 Z_ADDREF(generator->retval);
19469 }
19470 }
19471 } else if (IS_TMP_VAR == IS_CV) {
19472 ZVAL_COPY_DEREF(&generator->retval, retval);
19473 } else /* if (IS_TMP_VAR == IS_VAR) */ {
19474 if (UNEXPECTED(Z_ISREF_P(retval))) {
19475 zend_refcounted *ref = Z_COUNTED_P(retval);
19476
19477 retval = Z_REFVAL_P(retval);
19478 ZVAL_COPY_VALUE(&generator->retval, retval);
19479 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19480 efree_size(ref, sizeof(zend_reference));
19481 } else if (Z_OPT_REFCOUNTED_P(retval)) {
19482 Z_ADDREF_P(retval);
19483 }
19484 } else {
19485 ZVAL_COPY_VALUE(&generator->retval, retval);
19486 }
19487 }
19488
19489 EG(current_execute_data) = EX(prev_execute_data);
19490
19491 /* Close the generator to free up resources */
19492 zend_generator_close(generator, 1);
19493
19494 /* Pass execution back to handling code */
19495 ZEND_VM_RETURN();
19496 }
19497
ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19498 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19499 {
19500 USE_OPLINE
19501 zval *arg, *param;
19502
19503 SAVE_OPLINE();
19504
19505 arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19506 param = ZEND_CALL_VAR(EX(call), opline->result.var);
19507 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
19508 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
19509 Z_TRY_ADDREF_P(arg);
19510 ZVAL_NEW_REF(param, arg);
19511 } else {
19512 ZVAL_COPY(param, arg);
19513 }
19514
19515 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19516 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19517 }
19518
ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19519 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19520 {
19521 USE_OPLINE
19522 zval *expr;
19523 zval *result = EX_VAR(opline->result.var);
19524 HashTable *ht;
19525
19526 SAVE_OPLINE();
19527 expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19528
19529 switch (opline->extended_value) {
19530 case IS_LONG:
19531 ZVAL_LONG(result, zval_get_long(expr));
19532 break;
19533 case IS_DOUBLE:
19534 ZVAL_DOUBLE(result, zval_get_double(expr));
19535 break;
19536 case IS_STRING:
19537 ZVAL_STR(result, zval_get_string(expr));
19538 break;
19539 default:
19540 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
19541 if (IS_TMP_VAR & (IS_VAR|IS_CV)) {
19542 ZVAL_DEREF(expr);
19543 }
19544 /* If value is already of correct type, return it directly */
19545 if (Z_TYPE_P(expr) == opline->extended_value) {
19546 ZVAL_COPY_VALUE(result, expr);
19547 if (IS_TMP_VAR == IS_CONST) {
19548 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
19549 } else if (IS_TMP_VAR != IS_TMP_VAR) {
19550 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
19551 }
19552
19553 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19554 }
19555
19556 if (opline->extended_value == IS_ARRAY) {
19557 if (IS_TMP_VAR == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
19558 if (Z_TYPE_P(expr) != IS_NULL) {
19559 ZVAL_ARR(result, zend_new_array(1));
19560 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
19561 if (IS_TMP_VAR == IS_CONST) {
19562 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
19563 } else {
19564 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
19565 }
19566 } else {
19567 ZVAL_EMPTY_ARRAY(result);
19568 }
19569 } else if (Z_OBJ_P(expr)->properties == NULL
19570 && Z_OBJ_HT_P(expr)->get_properties_for == NULL
19571 && Z_OBJ_HT_P(expr)->get_properties == zend_std_get_properties) {
19572 /* Optimized version without rebuilding properties HashTable */
19573 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
19574 } else {
19575 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
19576 if (obj_ht) {
19577 /* fast copy */
19578 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
19579 (Z_OBJCE_P(expr)->default_properties_count ||
19580 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
19581 GC_IS_RECURSIVE(obj_ht))));
19582 zend_release_properties(obj_ht);
19583 } else {
19584 ZVAL_EMPTY_ARRAY(result);
19585 }
19586 }
19587 } else {
19588 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
19589 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
19590 if (Z_TYPE_P(expr) == IS_ARRAY) {
19591 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
19592 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
19593 /* TODO: try not to duplicate immutable arrays as well ??? */
19594 ht = zend_array_dup(ht);
19595 }
19596 Z_OBJ_P(result)->properties = ht;
19597 } else if (Z_TYPE_P(expr) != IS_NULL) {
19598 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
19599 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
19600 if (IS_TMP_VAR == IS_CONST) {
19601 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
19602 } else {
19603 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
19604 }
19605 }
19606 }
19607 }
19608
19609 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19610 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19611 }
19612
ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19613 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19614 {
19615 USE_OPLINE
19616 zval *array_ptr, *result;
19617
19618 SAVE_OPLINE();
19619
19620 array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19621 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
19622 result = EX_VAR(opline->result.var);
19623 ZVAL_COPY_VALUE(result, array_ptr);
19624 if (IS_TMP_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
19625 Z_ADDREF_P(array_ptr);
19626 }
19627 Z_FE_POS_P(result) = 0;
19628
19629 ZEND_VM_NEXT_OPCODE();
19630 } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
19631 zend_object *zobj = Z_OBJ_P(array_ptr);
19632 if (!zobj->ce->get_iterator) {
19633 HashTable *properties = zobj->properties;
19634 if (properties) {
19635 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
19636 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
19637 GC_DELREF(properties);
19638 }
19639 properties = zobj->properties = zend_array_dup(properties);
19640 }
19641 } else {
19642 properties = zobj->handlers->get_properties(zobj);
19643 }
19644
19645 result = EX_VAR(opline->result.var);
19646 ZVAL_COPY_VALUE(result, array_ptr);
19647 if (IS_TMP_VAR != IS_TMP_VAR) {
19648 Z_ADDREF_P(array_ptr);
19649 }
19650
19651 if (zend_hash_num_elements(properties) == 0) {
19652 Z_FE_ITER_P(result) = (uint32_t) -1;
19653
19654 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
19655 }
19656
19657 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
19658
19659 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19660 } else {
19661 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
19662
19663 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19664 if (UNEXPECTED(EG(exception))) {
19665 HANDLE_EXCEPTION();
19666 } else if (is_empty) {
19667 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
19668 } else {
19669 ZEND_VM_NEXT_OPCODE();
19670 }
19671 }
19672 } else {
19673 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
19674 ZVAL_UNDEF(EX_VAR(opline->result.var));
19675 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
19676 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19677 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
19678 }
19679 }
19680
ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19681 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19682 {
19683 USE_OPLINE
19684 zval *array_ptr, *array_ref;
19685
19686 SAVE_OPLINE();
19687
19688 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
19689 array_ref = array_ptr = zend_get_bad_ptr();
19690 if (Z_ISREF_P(array_ref)) {
19691 array_ptr = Z_REFVAL_P(array_ref);
19692 }
19693 } else {
19694 array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19695 }
19696
19697 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
19698 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
19699 if (array_ptr == array_ref) {
19700 ZVAL_NEW_REF(array_ref, array_ref);
19701 array_ptr = Z_REFVAL_P(array_ref);
19702 }
19703 Z_ADDREF_P(array_ref);
19704 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
19705 } else {
19706 array_ref = EX_VAR(opline->result.var);
19707 ZVAL_NEW_REF(array_ref, array_ptr);
19708 array_ptr = Z_REFVAL_P(array_ref);
19709 }
19710 if (IS_TMP_VAR == IS_CONST) {
19711 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
19712 } else {
19713 SEPARATE_ARRAY(array_ptr);
19714 }
19715 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
19716
19717 ZEND_VM_NEXT_OPCODE();
19718 } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
19719 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
19720 HashTable *properties;
19721 if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
19722 if (array_ptr == array_ref) {
19723 ZVAL_NEW_REF(array_ref, array_ref);
19724 array_ptr = Z_REFVAL_P(array_ref);
19725 }
19726 Z_ADDREF_P(array_ref);
19727 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
19728 } else {
19729 array_ptr = EX_VAR(opline->result.var);
19730 ZVAL_COPY_VALUE(array_ptr, array_ref);
19731 }
19732 if (Z_OBJ_P(array_ptr)->properties
19733 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
19734 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
19735 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
19736 }
19737 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
19738 }
19739
19740 properties = Z_OBJPROP_P(array_ptr);
19741 if (zend_hash_num_elements(properties) == 0) {
19742 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
19743
19744 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
19745 }
19746
19747 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
19748
19749 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19750 } else {
19751 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
19752 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19753 if (UNEXPECTED(EG(exception))) {
19754 HANDLE_EXCEPTION();
19755 } else if (is_empty) {
19756 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
19757 } else {
19758 ZEND_VM_NEXT_OPCODE();
19759 }
19760 }
19761 } else {
19762 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
19763 ZVAL_UNDEF(EX_VAR(opline->result.var));
19764 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
19765 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19766 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
19767 }
19768 }
19769
ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19770 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19771 {
19772 USE_OPLINE
19773
19774 if (E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))
19775 && !E_HAS_ONLY_FATAL_ERRORS(Z_LVAL_P(EX_VAR(opline->op1.var)))) {
19776 EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var));
19777 }
19778 ZEND_VM_NEXT_OPCODE();
19779 }
19780
ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19781 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19782 {
19783 USE_OPLINE
19784 zval *value;
19785 zend_reference *ref = NULL;
19786 bool ret;
19787
19788 SAVE_OPLINE();
19789 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19790
19791 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) {
19792 if (IS_TMP_VAR == IS_VAR) {
19793 ref = Z_REF_P(value);
19794 }
19795 value = Z_REFVAL_P(value);
19796 }
19797
19798 ret = i_zend_is_true(value);
19799
19800 if (UNEXPECTED(EG(exception))) {
19801 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19802 ZVAL_UNDEF(EX_VAR(opline->result.var));
19803 HANDLE_EXCEPTION();
19804 }
19805
19806 if (ret) {
19807 zval *result = EX_VAR(opline->result.var);
19808
19809 ZVAL_COPY_VALUE(result, value);
19810 if (IS_TMP_VAR == IS_CONST) {
19811 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
19812 } else if (IS_TMP_VAR == IS_CV) {
19813 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
19814 } else if (IS_TMP_VAR == IS_VAR && ref) {
19815 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19816 efree_size(ref, sizeof(zend_reference));
19817 } else if (Z_OPT_REFCOUNTED_P(result)) {
19818 Z_ADDREF_P(result);
19819 }
19820 }
19821 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
19822 }
19823
19824 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19825 ZEND_VM_NEXT_OPCODE();
19826 }
19827
ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19828 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19829 {
19830 USE_OPLINE
19831 zval *value;
19832 zend_reference *ref = NULL;
19833
19834 SAVE_OPLINE();
19835 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19836
19837 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
19838 if (IS_TMP_VAR & IS_VAR) {
19839 ref = Z_REF_P(value);
19840 }
19841 value = Z_REFVAL_P(value);
19842 }
19843
19844 if (Z_TYPE_P(value) > IS_NULL) {
19845 zval *result = EX_VAR(opline->result.var);
19846 ZVAL_COPY_VALUE(result, value);
19847 if (IS_TMP_VAR == IS_CONST) {
19848 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
19849 } else if (IS_TMP_VAR == IS_CV) {
19850 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
19851 } else if ((IS_TMP_VAR & IS_VAR) && ref) {
19852 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19853 efree_size(ref, sizeof(zend_reference));
19854 } else if (Z_OPT_REFCOUNTED_P(result)) {
19855 Z_ADDREF_P(result);
19856 }
19857 }
19858 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
19859 }
19860
19861 if ((IS_TMP_VAR & IS_VAR) && ref) {
19862 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
19863 efree_size(ref, sizeof(zend_reference));
19864 }
19865 }
19866 ZEND_VM_NEXT_OPCODE();
19867 }
19868
ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19869 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19870 {
19871 USE_OPLINE
19872 zval *val, *result;
19873
19874 val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19875
19876 if (Z_TYPE_P(val) > IS_NULL) {
19877 do {
19878 if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
19879 val = Z_REFVAL_P(val);
19880 if (Z_TYPE_P(val) <= IS_NULL) {
19881 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19882 break;
19883 }
19884 }
19885 ZEND_VM_NEXT_OPCODE();
19886 } while (0);
19887 }
19888
19889 result = EX_VAR(opline->result.var);
19890 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
19891 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
19892 ZVAL_NULL(result);
19893 if (IS_TMP_VAR == IS_CV
19894 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
19895 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
19896 ) {
19897 SAVE_OPLINE();
19898 ZVAL_UNDEFINED_OP1();
19899 if (UNEXPECTED(EG(exception) != NULL)) {
19900 HANDLE_EXCEPTION();
19901 }
19902 }
19903 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
19904 ZVAL_FALSE(result);
19905 } else {
19906 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
19907 ZVAL_TRUE(result);
19908 }
19909
19910 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
19911 }
19912
ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19913 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19914 {
19915 USE_OPLINE
19916 zval *value;
19917 zval *result = EX_VAR(opline->result.var);
19918
19919 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19920 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
19921 SAVE_OPLINE();
19922 ZVAL_UNDEFINED_OP1();
19923 ZVAL_NULL(result);
19924 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
19925 }
19926
19927 if (IS_TMP_VAR == IS_CV) {
19928 ZVAL_COPY_DEREF(result, value);
19929 } else if (IS_TMP_VAR == IS_VAR) {
19930 if (UNEXPECTED(Z_ISREF_P(value))) {
19931 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
19932 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
19933 efree_size(Z_REF_P(value), sizeof(zend_reference));
19934 } else if (Z_OPT_REFCOUNTED_P(result)) {
19935 Z_ADDREF_P(result);
19936 }
19937 } else {
19938 ZVAL_COPY_VALUE(result, value);
19939 }
19940 } else {
19941 ZVAL_COPY_VALUE(result, value);
19942 if (IS_TMP_VAR == IS_CONST) {
19943 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
19944 Z_ADDREF_P(result);
19945 }
19946 }
19947 }
19948 ZEND_VM_NEXT_OPCODE();
19949 }
19950
ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19951 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19952 {
19953 USE_OPLINE
19954 zval *op1, *op2;
19955 bool result;
19956
19957 SAVE_OPLINE();
19958 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19959 op2 = RT_CONSTANT(opline, opline->op2);
19960 result = fast_is_identical_function(op1, op2);
19961 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19962
19963 ZEND_VM_SMART_BRANCH(result, 1);
19964 }
19965
ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19966 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19967 {
19968 USE_OPLINE
19969 zval *op1, *op2;
19970 bool result;
19971
19972 SAVE_OPLINE();
19973 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19974 op2 = RT_CONSTANT(opline, opline->op2);
19975 result = fast_is_identical_function(op1, op2);
19976
19977 ZEND_VM_SMART_BRANCH(result, 1);
19978 }
19979
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19980 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19981 {
19982 USE_OPLINE
19983 zval *op1, *op2;
19984 bool result;
19985
19986 SAVE_OPLINE();
19987 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
19988 op2 = RT_CONSTANT(opline, opline->op2);
19989 result = fast_is_not_identical_function(op1, op2);
19990 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
19991
19992 ZEND_VM_SMART_BRANCH(result, 1);
19993 }
19994
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)19995 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
19996 {
19997 #if 0
19998 USE_OPLINE
19999 #endif
20000
20001 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20002 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20003 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20004 }
20005 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20006 } else {
20007 if (IS_CONST == IS_UNUSED) {
20008 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20009 }
20010 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20011 }
20012 }
20013
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20014 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20015 {
20016 #if 0
20017 USE_OPLINE
20018 #endif
20019
20020 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20021 /* Behave like FETCH_OBJ_W */
20022 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20023 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20024 }
20025 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20026 } else {
20027 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20028 }
20029 }
20030
ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20031 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20032 {
20033 USE_OPLINE
20034 zend_string **rope;
20035 zval *var;
20036
20037 /* op1 and result are the same */
20038 rope = (zend_string**)EX_VAR(opline->op1.var);
20039 if (IS_CONST == IS_CONST) {
20040 var = RT_CONSTANT(opline, opline->op2);
20041 rope[opline->extended_value] = Z_STR_P(var);
20042 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20043 Z_ADDREF_P(var);
20044 }
20045 } else {
20046 var = RT_CONSTANT(opline, opline->op2);
20047 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20048 if (IS_CONST == IS_CV) {
20049 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20050 } else {
20051 rope[opline->extended_value] = Z_STR_P(var);
20052 }
20053 } else {
20054 SAVE_OPLINE();
20055 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20056 ZVAL_UNDEFINED_OP2();
20057 }
20058 rope[opline->extended_value] = zval_get_string_func(var);
20059
20060 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20061 }
20062 }
20063 ZEND_VM_NEXT_OPCODE();
20064 }
20065
ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20066 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20067 {
20068 USE_OPLINE
20069 zend_string **rope;
20070 zval *var, *ret;
20071 uint32_t i;
20072
20073 rope = (zend_string**)EX_VAR(opline->op1.var);
20074 if (IS_CONST == IS_CONST) {
20075 var = RT_CONSTANT(opline, opline->op2);
20076 rope[opline->extended_value] = Z_STR_P(var);
20077 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20078 Z_ADDREF_P(var);
20079 }
20080 } else {
20081 var = RT_CONSTANT(opline, opline->op2);
20082 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20083 if (IS_CONST == IS_CV) {
20084 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20085 } else {
20086 rope[opline->extended_value] = Z_STR_P(var);
20087 }
20088 } else {
20089 SAVE_OPLINE();
20090 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20091 ZVAL_UNDEFINED_OP2();
20092 }
20093 rope[opline->extended_value] = zval_get_string_func(var);
20094
20095 if (UNEXPECTED(EG(exception))) {
20096 for (i = 0; i <= opline->extended_value; i++) {
20097 zend_string_release_ex(rope[i], 0);
20098 }
20099 ZVAL_UNDEF(EX_VAR(opline->result.var));
20100 HANDLE_EXCEPTION();
20101 }
20102 }
20103 }
20104
20105 size_t len = 0;
20106 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
20107 for (i = 0; i <= opline->extended_value; i++) {
20108 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
20109 len += ZSTR_LEN(rope[i]);
20110 }
20111 ret = EX_VAR(opline->result.var);
20112 ZVAL_STR(ret, zend_string_alloc(len, 0));
20113 GC_ADD_FLAGS(Z_STR_P(ret), flags);
20114
20115 char *target = Z_STRVAL_P(ret);
20116 for (i = 0; i <= opline->extended_value; i++) {
20117 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
20118 target += ZSTR_LEN(rope[i]);
20119 zend_string_release_ex(rope[i], 0);
20120 }
20121 *target = '\0';
20122
20123 ZEND_VM_NEXT_OPCODE();
20124 }
20125
ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20126 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20127 {
20128 USE_OPLINE
20129 zval *value, *arg;
20130 uint32_t arg_num;
20131
20132 if (IS_CONST == IS_CONST) {
20133 SAVE_OPLINE();
20134 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
20135 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
20136 if (UNEXPECTED(!arg)) {
20137 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20138 HANDLE_EXCEPTION();
20139 }
20140 } else {
20141 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
20142 arg_num = opline->op2.num;
20143 }
20144
20145 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
20146 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20147 goto send_val_by_ref;
20148 }
20149 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
20150 send_val_by_ref:
20151 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
20152 }
20153 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20154 ZVAL_COPY_VALUE(arg, value);
20155 if (IS_TMP_VAR == IS_CONST) {
20156 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
20157 Z_ADDREF_P(arg);
20158 }
20159 }
20160 ZEND_VM_NEXT_OPCODE();
20161 }
20162
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20163 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20164 {
20165 USE_OPLINE
20166 zval *expr_ptr, new_expr;
20167
20168 SAVE_OPLINE();
20169 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
20170 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
20171 expr_ptr = zend_get_bad_ptr();
20172 if (Z_ISREF_P(expr_ptr)) {
20173 Z_ADDREF_P(expr_ptr);
20174 } else {
20175 ZVAL_MAKE_REF_EX(expr_ptr, 2);
20176 }
20177 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20178 } else {
20179 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20180 if (IS_TMP_VAR == IS_TMP_VAR) {
20181 /* pass */
20182 } else if (IS_TMP_VAR == IS_CONST) {
20183 Z_TRY_ADDREF_P(expr_ptr);
20184 } else if (IS_TMP_VAR == IS_CV) {
20185 ZVAL_DEREF(expr_ptr);
20186 Z_TRY_ADDREF_P(expr_ptr);
20187 } else /* if (IS_TMP_VAR == IS_VAR) */ {
20188 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
20189 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
20190
20191 expr_ptr = Z_REFVAL_P(expr_ptr);
20192 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20193 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
20194 expr_ptr = &new_expr;
20195 efree_size(ref, sizeof(zend_reference));
20196 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
20197 Z_ADDREF_P(expr_ptr);
20198 }
20199 }
20200 }
20201 }
20202
20203 if (IS_CONST != IS_UNUSED) {
20204 zval *offset = RT_CONSTANT(opline, opline->op2);
20205 zend_string *str;
20206 zend_ulong hval;
20207
20208 add_again:
20209 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
20210 str = Z_STR_P(offset);
20211 if (IS_CONST != IS_CONST) {
20212 if (ZEND_HANDLE_NUMERIC(str, hval)) {
20213 goto num_index;
20214 }
20215 }
20216 str_index:
20217 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
20218 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
20219 hval = Z_LVAL_P(offset);
20220 num_index:
20221 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
20222 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
20223 offset = Z_REFVAL_P(offset);
20224 goto add_again;
20225 } else if (Z_TYPE_P(offset) == IS_NULL) {
20226 str = ZSTR_EMPTY_ALLOC();
20227 goto str_index;
20228 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
20229 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
20230 goto num_index;
20231 } else if (Z_TYPE_P(offset) == IS_FALSE) {
20232 hval = 0;
20233 goto num_index;
20234 } else if (Z_TYPE_P(offset) == IS_TRUE) {
20235 hval = 1;
20236 goto num_index;
20237 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
20238 zend_use_resource_as_offset(offset);
20239 hval = Z_RES_HANDLE_P(offset);
20240 goto num_index;
20241 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
20242 ZVAL_UNDEFINED_OP2();
20243 str = ZSTR_EMPTY_ALLOC();
20244 goto str_index;
20245 } else {
20246 zend_illegal_array_offset_access(offset);
20247 zval_ptr_dtor_nogc(expr_ptr);
20248 }
20249
20250 } else {
20251 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
20252 zend_cannot_add_element();
20253 zval_ptr_dtor_nogc(expr_ptr);
20254 }
20255 }
20256 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20257 }
20258
ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20259 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20260 {
20261 zval *array;
20262 uint32_t size;
20263 USE_OPLINE
20264
20265 array = EX_VAR(opline->result.var);
20266 if (IS_TMP_VAR != IS_UNUSED) {
20267 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
20268 ZVAL_ARR(array, zend_new_array(size));
20269 /* Explicitly initialize array as not-packed if flag is set */
20270 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
20271 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
20272 }
20273 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20274 } else {
20275 ZVAL_ARR(array, zend_new_array(0));
20276 ZEND_VM_NEXT_OPCODE();
20277 }
20278 }
20279
ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20280 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20281 {
20282 USE_OPLINE
20283
20284 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
20285
20286 SAVE_OPLINE();
20287 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
20288 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20289 }
20290
20291 /* Destroy the previously yielded value */
20292 zval_ptr_dtor(&generator->value);
20293
20294 /* Destroy the previously yielded key */
20295 zval_ptr_dtor(&generator->key);
20296
20297 /* Set the new yielded value */
20298 if (IS_TMP_VAR != IS_UNUSED) {
20299 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
20300 /* Constants and temporary variables aren't yieldable by reference,
20301 * but we still allow them with a notice. */
20302 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
20303 zval *value;
20304
20305 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20306
20307 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20308 ZVAL_COPY_VALUE(&generator->value, value);
20309 if (IS_TMP_VAR == IS_CONST) {
20310 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20311 Z_ADDREF(generator->value);
20312 }
20313 }
20314 } else {
20315 zval *value_ptr = zend_get_bad_ptr();
20316
20317 /* If a function call result is yielded and the function did
20318 * not return by reference we throw a notice. */
20319 do {
20320 if (IS_TMP_VAR == IS_VAR) {
20321 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
20322 if (opline->extended_value == ZEND_RETURNS_FUNCTION
20323 && !Z_ISREF_P(value_ptr)) {
20324 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20325 ZVAL_COPY(&generator->value, value_ptr);
20326 break;
20327 }
20328 }
20329 if (Z_ISREF_P(value_ptr)) {
20330 Z_ADDREF_P(value_ptr);
20331 } else {
20332 ZVAL_MAKE_REF_EX(value_ptr, 2);
20333 }
20334 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
20335 } while (0);
20336
20337 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20338 }
20339 } else {
20340 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20341
20342 /* Consts, temporary variables and references need copying */
20343 if (IS_TMP_VAR == IS_CONST) {
20344 ZVAL_COPY_VALUE(&generator->value, value);
20345 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20346 Z_ADDREF(generator->value);
20347 }
20348 } else if (IS_TMP_VAR == IS_TMP_VAR) {
20349 ZVAL_COPY_VALUE(&generator->value, value);
20350 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
20351 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
20352
20353 } else {
20354 ZVAL_COPY_VALUE(&generator->value, value);
20355 if (IS_TMP_VAR == IS_CV) {
20356 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
20357 }
20358 }
20359 }
20360 } else {
20361 /* If no value was specified yield null */
20362 ZVAL_NULL(&generator->value);
20363 }
20364
20365 /* Set the new yielded key */
20366 if (IS_CONST != IS_UNUSED) {
20367 zval *key = RT_CONSTANT(opline, opline->op2);
20368 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
20369 key = Z_REFVAL_P(key);
20370 }
20371 ZVAL_COPY(&generator->key, key);
20372
20373 if (Z_TYPE(generator->key) == IS_LONG
20374 && Z_LVAL(generator->key) > generator->largest_used_integer_key
20375 ) {
20376 generator->largest_used_integer_key = Z_LVAL(generator->key);
20377 }
20378 } else {
20379 /* If no key was specified we use auto-increment keys */
20380 generator->largest_used_integer_key++;
20381 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
20382 }
20383
20384 if (RETURN_VALUE_USED(opline)) {
20385 /* If the return value of yield is used set the send
20386 * target and initialize it to NULL */
20387 generator->send_target = EX_VAR(opline->result.var);
20388 ZVAL_NULL(generator->send_target);
20389 } else {
20390 generator->send_target = NULL;
20391 }
20392
20393 /* We increment to the next op, so we are at the correct position when the
20394 * generator is resumed. */
20395 ZEND_VM_INC_OPCODE();
20396
20397 /* The GOTO VM uses a local opline variable. We need to set the opline
20398 * variable in execute_data so we don't resume at an old position. */
20399 SAVE_OPLINE();
20400
20401 ZEND_VM_RETURN();
20402 }
20403
ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20404 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20405 {
20406 USE_OPLINE
20407 zval *op1;
20408 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
20409 zval *result;
20410
20411 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20412 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
20413 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_TMP_VAR == IS_CONST);
20414 if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) {
20415 zval_ptr_dtor_str(op1);
20416 }
20417 ZEND_VM_SMART_BRANCH(result, 0);
20418 }
20419
20420 if (opline->extended_value) {
20421 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
20422 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
20423 ZEND_VM_SMART_BRANCH(result, 0);
20424 }
20425 SAVE_OPLINE();
20426 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
20427 op1 = Z_REFVAL_P(op1);
20428 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
20429 result = zend_hash_find(ht, Z_STR_P(op1));
20430 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20431 ZEND_VM_SMART_BRANCH(result, 0);
20432 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
20433 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
20434 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20435 ZEND_VM_SMART_BRANCH(result, 0);
20436 }
20437 } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
20438 ZVAL_UNDEFINED_OP1();
20439 }
20440 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
20441 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
20442 SAVE_OPLINE();
20443 ZVAL_UNDEFINED_OP1();
20444 if (UNEXPECTED(EG(exception) != NULL)) {
20445 HANDLE_EXCEPTION();
20446 }
20447 }
20448 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
20449 ZEND_VM_SMART_BRANCH(result, 0);
20450 } else {
20451 zend_string *key;
20452 zval key_tmp;
20453
20454 if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
20455 op1 = Z_REFVAL_P(op1);
20456 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
20457 result = zend_hash_find(ht, Z_STR_P(op1));
20458 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20459 ZEND_VM_SMART_BRANCH(result, 0);
20460 }
20461 }
20462
20463 SAVE_OPLINE();
20464 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
20465 ZVAL_STR(&key_tmp, key);
20466 if (zend_compare(op1, &key_tmp) == 0) {
20467 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20468 ZEND_VM_SMART_BRANCH(1, 1);
20469 }
20470 } ZEND_HASH_FOREACH_END();
20471 }
20472 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20473 ZEND_VM_SMART_BRANCH(0, 1);
20474 }
20475
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20476 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20477 {
20478 #if 0
20479 USE_OPLINE
20480 #endif
20481
20482 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20483 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20484 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20485 }
20486 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20487 } else {
20488 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
20489 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20490 }
20491 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20492 }
20493 }
20494
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20495 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20496 {
20497 #if 0
20498 USE_OPLINE
20499 #endif
20500
20501 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20502 /* Behave like FETCH_OBJ_W */
20503 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20504 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20505 }
20506 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20507 } else {
20508 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20509 }
20510 }
20511
ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20512 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20513 {
20514 USE_OPLINE
20515 zend_string **rope;
20516 zval *var;
20517
20518 /* op1 and result are the same */
20519 rope = (zend_string**)EX_VAR(opline->op1.var);
20520 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
20521 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20522 rope[opline->extended_value] = Z_STR_P(var);
20523 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20524 Z_ADDREF_P(var);
20525 }
20526 } else {
20527 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20528 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20529 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
20530 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20531 } else {
20532 rope[opline->extended_value] = Z_STR_P(var);
20533 }
20534 } else {
20535 SAVE_OPLINE();
20536 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20537 ZVAL_UNDEFINED_OP2();
20538 }
20539 rope[opline->extended_value] = zval_get_string_func(var);
20540 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20541 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20542 }
20543 }
20544 ZEND_VM_NEXT_OPCODE();
20545 }
20546
ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20547 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20548 {
20549 USE_OPLINE
20550 zend_string **rope;
20551 zval *var, *ret;
20552 uint32_t i;
20553
20554 rope = (zend_string**)EX_VAR(opline->op1.var);
20555 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
20556 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20557 rope[opline->extended_value] = Z_STR_P(var);
20558 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
20559 Z_ADDREF_P(var);
20560 }
20561 } else {
20562 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20563 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
20564 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
20565 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
20566 } else {
20567 rope[opline->extended_value] = Z_STR_P(var);
20568 }
20569 } else {
20570 SAVE_OPLINE();
20571 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
20572 ZVAL_UNDEFINED_OP2();
20573 }
20574 rope[opline->extended_value] = zval_get_string_func(var);
20575 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20576 if (UNEXPECTED(EG(exception))) {
20577 for (i = 0; i <= opline->extended_value; i++) {
20578 zend_string_release_ex(rope[i], 0);
20579 }
20580 ZVAL_UNDEF(EX_VAR(opline->result.var));
20581 HANDLE_EXCEPTION();
20582 }
20583 }
20584 }
20585
20586 size_t len = 0;
20587 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
20588 for (i = 0; i <= opline->extended_value; i++) {
20589 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
20590 len += ZSTR_LEN(rope[i]);
20591 }
20592 ret = EX_VAR(opline->result.var);
20593 ZVAL_STR(ret, zend_string_alloc(len, 0));
20594 GC_ADD_FLAGS(Z_STR_P(ret), flags);
20595
20596 char *target = Z_STRVAL_P(ret);
20597 for (i = 0; i <= opline->extended_value; i++) {
20598 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
20599 target += ZSTR_LEN(rope[i]);
20600 zend_string_release_ex(rope[i], 0);
20601 }
20602 *target = '\0';
20603
20604 ZEND_VM_NEXT_OPCODE();
20605 }
20606
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20607 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20608 {
20609 USE_OPLINE
20610 zval *expr_ptr, new_expr;
20611
20612 SAVE_OPLINE();
20613 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
20614 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
20615 expr_ptr = zend_get_bad_ptr();
20616 if (Z_ISREF_P(expr_ptr)) {
20617 Z_ADDREF_P(expr_ptr);
20618 } else {
20619 ZVAL_MAKE_REF_EX(expr_ptr, 2);
20620 }
20621 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20622 } else {
20623 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20624 if (IS_TMP_VAR == IS_TMP_VAR) {
20625 /* pass */
20626 } else if (IS_TMP_VAR == IS_CONST) {
20627 Z_TRY_ADDREF_P(expr_ptr);
20628 } else if (IS_TMP_VAR == IS_CV) {
20629 ZVAL_DEREF(expr_ptr);
20630 Z_TRY_ADDREF_P(expr_ptr);
20631 } else /* if (IS_TMP_VAR == IS_VAR) */ {
20632 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
20633 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
20634
20635 expr_ptr = Z_REFVAL_P(expr_ptr);
20636 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
20637 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
20638 expr_ptr = &new_expr;
20639 efree_size(ref, sizeof(zend_reference));
20640 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
20641 Z_ADDREF_P(expr_ptr);
20642 }
20643 }
20644 }
20645 }
20646
20647 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
20648 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20649 zend_string *str;
20650 zend_ulong hval;
20651
20652 add_again:
20653 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
20654 str = Z_STR_P(offset);
20655 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
20656 if (ZEND_HANDLE_NUMERIC(str, hval)) {
20657 goto num_index;
20658 }
20659 }
20660 str_index:
20661 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
20662 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
20663 hval = Z_LVAL_P(offset);
20664 num_index:
20665 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
20666 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
20667 offset = Z_REFVAL_P(offset);
20668 goto add_again;
20669 } else if (Z_TYPE_P(offset) == IS_NULL) {
20670 str = ZSTR_EMPTY_ALLOC();
20671 goto str_index;
20672 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
20673 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
20674 goto num_index;
20675 } else if (Z_TYPE_P(offset) == IS_FALSE) {
20676 hval = 0;
20677 goto num_index;
20678 } else if (Z_TYPE_P(offset) == IS_TRUE) {
20679 hval = 1;
20680 goto num_index;
20681 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
20682 zend_use_resource_as_offset(offset);
20683 hval = Z_RES_HANDLE_P(offset);
20684 goto num_index;
20685 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
20686 ZVAL_UNDEFINED_OP2();
20687 str = ZSTR_EMPTY_ALLOC();
20688 goto str_index;
20689 } else {
20690 zend_illegal_array_offset_access(offset);
20691 zval_ptr_dtor_nogc(expr_ptr);
20692 }
20693 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20694 } else {
20695 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
20696 zend_cannot_add_element();
20697 zval_ptr_dtor_nogc(expr_ptr);
20698 }
20699 }
20700 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
20701 }
20702
ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20703 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20704 {
20705 zval *array;
20706 uint32_t size;
20707 USE_OPLINE
20708
20709 array = EX_VAR(opline->result.var);
20710 if (IS_TMP_VAR != IS_UNUSED) {
20711 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
20712 ZVAL_ARR(array, zend_new_array(size));
20713 /* Explicitly initialize array as not-packed if flag is set */
20714 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
20715 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
20716 }
20717 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20718 } else {
20719 ZVAL_ARR(array, zend_new_array(0));
20720 ZEND_VM_NEXT_OPCODE();
20721 }
20722 }
20723
ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20724 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20725 {
20726 USE_OPLINE
20727
20728 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
20729
20730 SAVE_OPLINE();
20731 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
20732 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20733 }
20734
20735 /* Destroy the previously yielded value */
20736 zval_ptr_dtor(&generator->value);
20737
20738 /* Destroy the previously yielded key */
20739 zval_ptr_dtor(&generator->key);
20740
20741 /* Set the new yielded value */
20742 if (IS_TMP_VAR != IS_UNUSED) {
20743 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
20744 /* Constants and temporary variables aren't yieldable by reference,
20745 * but we still allow them with a notice. */
20746 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
20747 zval *value;
20748
20749 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20750
20751 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20752 ZVAL_COPY_VALUE(&generator->value, value);
20753 if (IS_TMP_VAR == IS_CONST) {
20754 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20755 Z_ADDREF(generator->value);
20756 }
20757 }
20758 } else {
20759 zval *value_ptr = zend_get_bad_ptr();
20760
20761 /* If a function call result is yielded and the function did
20762 * not return by reference we throw a notice. */
20763 do {
20764 if (IS_TMP_VAR == IS_VAR) {
20765 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
20766 if (opline->extended_value == ZEND_RETURNS_FUNCTION
20767 && !Z_ISREF_P(value_ptr)) {
20768 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
20769 ZVAL_COPY(&generator->value, value_ptr);
20770 break;
20771 }
20772 }
20773 if (Z_ISREF_P(value_ptr)) {
20774 Z_ADDREF_P(value_ptr);
20775 } else {
20776 ZVAL_MAKE_REF_EX(value_ptr, 2);
20777 }
20778 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
20779 } while (0);
20780
20781 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20782 }
20783 } else {
20784 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20785
20786 /* Consts, temporary variables and references need copying */
20787 if (IS_TMP_VAR == IS_CONST) {
20788 ZVAL_COPY_VALUE(&generator->value, value);
20789 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
20790 Z_ADDREF(generator->value);
20791 }
20792 } else if (IS_TMP_VAR == IS_TMP_VAR) {
20793 ZVAL_COPY_VALUE(&generator->value, value);
20794 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
20795 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
20796
20797 } else {
20798 ZVAL_COPY_VALUE(&generator->value, value);
20799 if (IS_TMP_VAR == IS_CV) {
20800 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
20801 }
20802 }
20803 }
20804 } else {
20805 /* If no value was specified yield null */
20806 ZVAL_NULL(&generator->value);
20807 }
20808
20809 /* Set the new yielded key */
20810 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
20811 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
20812 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
20813 key = Z_REFVAL_P(key);
20814 }
20815 ZVAL_COPY(&generator->key, key);
20816 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20817
20818 if (Z_TYPE(generator->key) == IS_LONG
20819 && Z_LVAL(generator->key) > generator->largest_used_integer_key
20820 ) {
20821 generator->largest_used_integer_key = Z_LVAL(generator->key);
20822 }
20823 } else {
20824 /* If no key was specified we use auto-increment keys */
20825 generator->largest_used_integer_key++;
20826 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
20827 }
20828
20829 if (RETURN_VALUE_USED(opline)) {
20830 /* If the return value of yield is used set the send
20831 * target and initialize it to NULL */
20832 generator->send_target = EX_VAR(opline->result.var);
20833 ZVAL_NULL(generator->send_target);
20834 } else {
20835 generator->send_target = NULL;
20836 }
20837
20838 /* We increment to the next op, so we are at the correct position when the
20839 * generator is resumed. */
20840 ZEND_VM_INC_OPCODE();
20841
20842 /* The GOTO VM uses a local opline variable. We need to set the opline
20843 * variable in execute_data so we don't resume at an old position. */
20844 SAVE_OPLINE();
20845
20846 ZEND_VM_RETURN();
20847 }
20848
ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20849 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20850 {
20851 USE_OPLINE
20852 zval *op1, *op2;
20853 bool result;
20854
20855 SAVE_OPLINE();
20856 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20857 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
20858 result = fast_is_identical_function(op1, op2);
20859 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20860 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20861 ZEND_VM_SMART_BRANCH(result, 1);
20862 }
20863
ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20864 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20865 {
20866 USE_OPLINE
20867 zval *op1, *op2;
20868 bool result;
20869
20870 SAVE_OPLINE();
20871 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20872 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
20873 result = fast_is_identical_function(op1, op2);
20874 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20875 ZEND_VM_SMART_BRANCH(result, 1);
20876 }
20877
ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20878 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20879 {
20880 USE_OPLINE
20881 zval *op1, *op2;
20882 bool result;
20883
20884 SAVE_OPLINE();
20885 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20886 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
20887 result = fast_is_not_identical_function(op1, op2);
20888 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
20889 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20890 ZEND_VM_SMART_BRANCH(result, 1);
20891 }
20892
ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20893 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20894 {
20895 USE_OPLINE
20896 zval *op1, *op2;
20897 bool result;
20898
20899 SAVE_OPLINE();
20900 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20901 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
20902 result = fast_is_identical_function(op1, op2);
20903 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
20904 ZEND_VM_SMART_BRANCH(result, 1);
20905 }
20906
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20907 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20908 {
20909 #if 0
20910 USE_OPLINE
20911 #endif
20912
20913 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
20914 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
20915 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20916 }
20917 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20918 } else {
20919 if (IS_UNUSED == IS_UNUSED) {
20920 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20921 }
20922 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
20923 }
20924 }
20925
ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20926 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20927 {
20928 if (IS_TMP_VAR == IS_UNUSED) {
20929 SAVE_OPLINE();
20930 zend_verify_missing_return_type(EX(func));
20931 HANDLE_EXCEPTION();
20932 } else {
20933 /* prevents "undefined variable opline" errors */
20934 #if 0 || (IS_TMP_VAR != IS_UNUSED)
20935 USE_OPLINE
20936 zval *retval_ref, *retval_ptr;
20937 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
20938 retval_ref = retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
20939
20940 if (IS_TMP_VAR == IS_CONST) {
20941 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
20942 retval_ref = retval_ptr = EX_VAR(opline->result.var);
20943 } else if (IS_TMP_VAR == IS_VAR) {
20944 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
20945 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
20946 }
20947 ZVAL_DEREF(retval_ptr);
20948 } else if (IS_TMP_VAR == IS_CV) {
20949 ZVAL_DEREF(retval_ptr);
20950 }
20951
20952 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
20953 ZEND_VM_NEXT_OPCODE();
20954 }
20955
20956 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
20957 SAVE_OPLINE();
20958 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
20959 if (UNEXPECTED(EG(exception))) {
20960 HANDLE_EXCEPTION();
20961 }
20962 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
20963 ZEND_VM_NEXT_OPCODE();
20964 }
20965 }
20966
20967 zend_reference *ref = NULL;
20968 void *cache_slot = CACHE_ADDR(opline->op2.num);
20969 if (UNEXPECTED(retval_ref != retval_ptr)) {
20970 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
20971 ref = Z_REF_P(retval_ref);
20972 } else {
20973 /* A cast might happen - unwrap the reference if this is a by-value return */
20974 if (Z_REFCOUNT_P(retval_ref) == 1) {
20975 ZVAL_UNREF(retval_ref);
20976 } else {
20977 Z_DELREF_P(retval_ref);
20978 ZVAL_COPY(retval_ref, retval_ptr);
20979 }
20980 retval_ptr = retval_ref;
20981 }
20982 }
20983
20984 SAVE_OPLINE();
20985 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
20986 zend_verify_return_error(EX(func), retval_ptr);
20987 HANDLE_EXCEPTION();
20988 }
20989 ZEND_VM_NEXT_OPCODE();
20990 #endif
20991 }
20992 }
20993
ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)20994 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
20995 {
20996 USE_OPLINE
20997 zval *value, *arg;
20998 uint32_t arg_num;
20999
21000 if (IS_UNUSED == IS_CONST) {
21001 SAVE_OPLINE();
21002 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21003 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21004 if (UNEXPECTED(!arg)) {
21005 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21006 HANDLE_EXCEPTION();
21007 }
21008 } else {
21009 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21010 arg_num = opline->op2.num;
21011 }
21012
21013 if (EXPECTED(0)) {
21014 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21015 goto send_val_by_ref;
21016 }
21017 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21018 send_val_by_ref:
21019 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
21020 }
21021 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21022 ZVAL_COPY_VALUE(arg, value);
21023 if (IS_TMP_VAR == IS_CONST) {
21024 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21025 Z_ADDREF_P(arg);
21026 }
21027 }
21028 ZEND_VM_NEXT_OPCODE();
21029 }
21030
ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21031 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21032 {
21033 USE_OPLINE
21034 zval *value, *arg;
21035 uint32_t arg_num;
21036
21037 if (IS_UNUSED == IS_CONST) {
21038 SAVE_OPLINE();
21039 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
21040 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
21041 if (UNEXPECTED(!arg)) {
21042 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21043 HANDLE_EXCEPTION();
21044 }
21045 } else {
21046 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
21047 arg_num = opline->op2.num;
21048 }
21049
21050 if (EXPECTED(1)) {
21051 if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21052 goto send_val_by_ref;
21053 }
21054 } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
21055 send_val_by_ref:
21056 ZEND_VM_TAIL_CALL(zend_cannot_pass_by_ref_helper_SPEC(arg_num, arg ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
21057 }
21058 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21059 ZVAL_COPY_VALUE(arg, value);
21060 if (IS_TMP_VAR == IS_CONST) {
21061 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) {
21062 Z_ADDREF_P(arg);
21063 }
21064 }
21065 ZEND_VM_NEXT_OPCODE();
21066 }
21067
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21068 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21069 {
21070 USE_OPLINE
21071 zval *expr_ptr, new_expr;
21072
21073 SAVE_OPLINE();
21074 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21075 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21076 expr_ptr = zend_get_bad_ptr();
21077 if (Z_ISREF_P(expr_ptr)) {
21078 Z_ADDREF_P(expr_ptr);
21079 } else {
21080 ZVAL_MAKE_REF_EX(expr_ptr, 2);
21081 }
21082 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21083 } else {
21084 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21085 if (IS_TMP_VAR == IS_TMP_VAR) {
21086 /* pass */
21087 } else if (IS_TMP_VAR == IS_CONST) {
21088 Z_TRY_ADDREF_P(expr_ptr);
21089 } else if (IS_TMP_VAR == IS_CV) {
21090 ZVAL_DEREF(expr_ptr);
21091 Z_TRY_ADDREF_P(expr_ptr);
21092 } else /* if (IS_TMP_VAR == IS_VAR) */ {
21093 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21094 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21095
21096 expr_ptr = Z_REFVAL_P(expr_ptr);
21097 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21098 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21099 expr_ptr = &new_expr;
21100 efree_size(ref, sizeof(zend_reference));
21101 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21102 Z_ADDREF_P(expr_ptr);
21103 }
21104 }
21105 }
21106 }
21107
21108 if (IS_UNUSED != IS_UNUSED) {
21109 zval *offset = NULL;
21110 zend_string *str;
21111 zend_ulong hval;
21112
21113 add_again:
21114 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21115 str = Z_STR_P(offset);
21116 if (IS_UNUSED != IS_CONST) {
21117 if (ZEND_HANDLE_NUMERIC(str, hval)) {
21118 goto num_index;
21119 }
21120 }
21121 str_index:
21122 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21123 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21124 hval = Z_LVAL_P(offset);
21125 num_index:
21126 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21127 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21128 offset = Z_REFVAL_P(offset);
21129 goto add_again;
21130 } else if (Z_TYPE_P(offset) == IS_NULL) {
21131 str = ZSTR_EMPTY_ALLOC();
21132 goto str_index;
21133 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21134 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21135 goto num_index;
21136 } else if (Z_TYPE_P(offset) == IS_FALSE) {
21137 hval = 0;
21138 goto num_index;
21139 } else if (Z_TYPE_P(offset) == IS_TRUE) {
21140 hval = 1;
21141 goto num_index;
21142 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21143 zend_use_resource_as_offset(offset);
21144 hval = Z_RES_HANDLE_P(offset);
21145 goto num_index;
21146 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21147 ZVAL_UNDEFINED_OP2();
21148 str = ZSTR_EMPTY_ALLOC();
21149 goto str_index;
21150 } else {
21151 zend_illegal_array_offset_access(offset);
21152 zval_ptr_dtor_nogc(expr_ptr);
21153 }
21154
21155 } else {
21156 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21157 zend_cannot_add_element();
21158 zval_ptr_dtor_nogc(expr_ptr);
21159 }
21160 }
21161 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21162 }
21163
ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21164 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21165 {
21166 zval *array;
21167 uint32_t size;
21168 USE_OPLINE
21169
21170 array = EX_VAR(opline->result.var);
21171 if (IS_TMP_VAR != IS_UNUSED) {
21172 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21173 ZVAL_ARR(array, zend_new_array(size));
21174 /* Explicitly initialize array as not-packed if flag is set */
21175 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21176 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21177 }
21178 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21179 } else {
21180 ZVAL_ARR(array, zend_new_array(0));
21181 ZEND_VM_NEXT_OPCODE();
21182 }
21183 }
21184
ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21185 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21186 {
21187 USE_OPLINE
21188
21189 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21190
21191 SAVE_OPLINE();
21192 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21193 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21194 }
21195
21196 /* Destroy the previously yielded value */
21197 zval_ptr_dtor(&generator->value);
21198
21199 /* Destroy the previously yielded key */
21200 zval_ptr_dtor(&generator->key);
21201
21202 /* Set the new yielded value */
21203 if (IS_TMP_VAR != IS_UNUSED) {
21204 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21205 /* Constants and temporary variables aren't yieldable by reference,
21206 * but we still allow them with a notice. */
21207 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21208 zval *value;
21209
21210 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21211
21212 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21213 ZVAL_COPY_VALUE(&generator->value, value);
21214 if (IS_TMP_VAR == IS_CONST) {
21215 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21216 Z_ADDREF(generator->value);
21217 }
21218 }
21219 } else {
21220 zval *value_ptr = zend_get_bad_ptr();
21221
21222 /* If a function call result is yielded and the function did
21223 * not return by reference we throw a notice. */
21224 do {
21225 if (IS_TMP_VAR == IS_VAR) {
21226 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21227 if (opline->extended_value == ZEND_RETURNS_FUNCTION
21228 && !Z_ISREF_P(value_ptr)) {
21229 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21230 ZVAL_COPY(&generator->value, value_ptr);
21231 break;
21232 }
21233 }
21234 if (Z_ISREF_P(value_ptr)) {
21235 Z_ADDREF_P(value_ptr);
21236 } else {
21237 ZVAL_MAKE_REF_EX(value_ptr, 2);
21238 }
21239 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21240 } while (0);
21241
21242 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21243 }
21244 } else {
21245 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21246
21247 /* Consts, temporary variables and references need copying */
21248 if (IS_TMP_VAR == IS_CONST) {
21249 ZVAL_COPY_VALUE(&generator->value, value);
21250 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21251 Z_ADDREF(generator->value);
21252 }
21253 } else if (IS_TMP_VAR == IS_TMP_VAR) {
21254 ZVAL_COPY_VALUE(&generator->value, value);
21255 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21256 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21257
21258 } else {
21259 ZVAL_COPY_VALUE(&generator->value, value);
21260 if (IS_TMP_VAR == IS_CV) {
21261 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21262 }
21263 }
21264 }
21265 } else {
21266 /* If no value was specified yield null */
21267 ZVAL_NULL(&generator->value);
21268 }
21269
21270 /* Set the new yielded key */
21271 if (IS_UNUSED != IS_UNUSED) {
21272 zval *key = NULL;
21273 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21274 key = Z_REFVAL_P(key);
21275 }
21276 ZVAL_COPY(&generator->key, key);
21277
21278 if (Z_TYPE(generator->key) == IS_LONG
21279 && Z_LVAL(generator->key) > generator->largest_used_integer_key
21280 ) {
21281 generator->largest_used_integer_key = Z_LVAL(generator->key);
21282 }
21283 } else {
21284 /* If no key was specified we use auto-increment keys */
21285 generator->largest_used_integer_key++;
21286 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21287 }
21288
21289 if (RETURN_VALUE_USED(opline)) {
21290 /* If the return value of yield is used set the send
21291 * target and initialize it to NULL */
21292 generator->send_target = EX_VAR(opline->result.var);
21293 ZVAL_NULL(generator->send_target);
21294 } else {
21295 generator->send_target = NULL;
21296 }
21297
21298 /* We increment to the next op, so we are at the correct position when the
21299 * generator is resumed. */
21300 ZEND_VM_INC_OPCODE();
21301
21302 /* The GOTO VM uses a local opline variable. We need to set the opline
21303 * variable in execute_data so we don't resume at an old position. */
21304 SAVE_OPLINE();
21305
21306 ZEND_VM_RETURN();
21307 }
21308
ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21309 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21310 {
21311 USE_OPLINE
21312 zval *op1;
21313 zend_string *type;
21314
21315 SAVE_OPLINE();
21316 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21317 type = zend_zval_get_legacy_type(op1);
21318 if (EXPECTED(type)) {
21319 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
21320 } else {
21321 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
21322 }
21323 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21324 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21325 }
21326
ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21327 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21328 {
21329 USE_OPLINE
21330 zval *op1, *op2;
21331 bool result;
21332
21333 SAVE_OPLINE();
21334 op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21335 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21336 result = fast_is_identical_function(op1, op2);
21337
21338 ZEND_VM_SMART_BRANCH(result, 1);
21339 }
21340
ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21341 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21342 {
21343 #if 0
21344 USE_OPLINE
21345 #endif
21346
21347 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21348 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21349 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21350 }
21351 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21352 } else {
21353 if (IS_CV == IS_UNUSED) {
21354 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21355 }
21356 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21357 }
21358 }
21359
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21360 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21361 {
21362 #if 0
21363 USE_OPLINE
21364 #endif
21365
21366 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
21367 /* Behave like FETCH_OBJ_W */
21368 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
21369 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21370 }
21371 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21372 } else {
21373 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21374 }
21375 }
21376
ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21377 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21378 {
21379 USE_OPLINE
21380 zend_string **rope;
21381 zval *var;
21382
21383 /* op1 and result are the same */
21384 rope = (zend_string**)EX_VAR(opline->op1.var);
21385 if (IS_CV == IS_CONST) {
21386 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21387 rope[opline->extended_value] = Z_STR_P(var);
21388 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21389 Z_ADDREF_P(var);
21390 }
21391 } else {
21392 var = EX_VAR(opline->op2.var);
21393 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21394 if (IS_CV == IS_CV) {
21395 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21396 } else {
21397 rope[opline->extended_value] = Z_STR_P(var);
21398 }
21399 } else {
21400 SAVE_OPLINE();
21401 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21402 ZVAL_UNDEFINED_OP2();
21403 }
21404 rope[opline->extended_value] = zval_get_string_func(var);
21405
21406 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21407 }
21408 }
21409 ZEND_VM_NEXT_OPCODE();
21410 }
21411
ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21412 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21413 {
21414 USE_OPLINE
21415 zend_string **rope;
21416 zval *var, *ret;
21417 uint32_t i;
21418
21419 rope = (zend_string**)EX_VAR(opline->op1.var);
21420 if (IS_CV == IS_CONST) {
21421 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21422 rope[opline->extended_value] = Z_STR_P(var);
21423 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
21424 Z_ADDREF_P(var);
21425 }
21426 } else {
21427 var = EX_VAR(opline->op2.var);
21428 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
21429 if (IS_CV == IS_CV) {
21430 rope[opline->extended_value] = zend_string_copy(Z_STR_P(var));
21431 } else {
21432 rope[opline->extended_value] = Z_STR_P(var);
21433 }
21434 } else {
21435 SAVE_OPLINE();
21436 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
21437 ZVAL_UNDEFINED_OP2();
21438 }
21439 rope[opline->extended_value] = zval_get_string_func(var);
21440
21441 if (UNEXPECTED(EG(exception))) {
21442 for (i = 0; i <= opline->extended_value; i++) {
21443 zend_string_release_ex(rope[i], 0);
21444 }
21445 ZVAL_UNDEF(EX_VAR(opline->result.var));
21446 HANDLE_EXCEPTION();
21447 }
21448 }
21449 }
21450
21451 size_t len = 0;
21452 uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES;
21453 for (i = 0; i <= opline->extended_value; i++) {
21454 flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]);
21455 len += ZSTR_LEN(rope[i]);
21456 }
21457 ret = EX_VAR(opline->result.var);
21458 ZVAL_STR(ret, zend_string_alloc(len, 0));
21459 GC_ADD_FLAGS(Z_STR_P(ret), flags);
21460
21461 char *target = Z_STRVAL_P(ret);
21462 for (i = 0; i <= opline->extended_value; i++) {
21463 memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
21464 target += ZSTR_LEN(rope[i]);
21465 zend_string_release_ex(rope[i], 0);
21466 }
21467 *target = '\0';
21468
21469 ZEND_VM_NEXT_OPCODE();
21470 }
21471
ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21472 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21473 {
21474 USE_OPLINE
21475 zval *expr_ptr, new_expr;
21476
21477 SAVE_OPLINE();
21478 if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
21479 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
21480 expr_ptr = zend_get_bad_ptr();
21481 if (Z_ISREF_P(expr_ptr)) {
21482 Z_ADDREF_P(expr_ptr);
21483 } else {
21484 ZVAL_MAKE_REF_EX(expr_ptr, 2);
21485 }
21486 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21487 } else {
21488 expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21489 if (IS_TMP_VAR == IS_TMP_VAR) {
21490 /* pass */
21491 } else if (IS_TMP_VAR == IS_CONST) {
21492 Z_TRY_ADDREF_P(expr_ptr);
21493 } else if (IS_TMP_VAR == IS_CV) {
21494 ZVAL_DEREF(expr_ptr);
21495 Z_TRY_ADDREF_P(expr_ptr);
21496 } else /* if (IS_TMP_VAR == IS_VAR) */ {
21497 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
21498 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
21499
21500 expr_ptr = Z_REFVAL_P(expr_ptr);
21501 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
21502 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
21503 expr_ptr = &new_expr;
21504 efree_size(ref, sizeof(zend_reference));
21505 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
21506 Z_ADDREF_P(expr_ptr);
21507 }
21508 }
21509 }
21510 }
21511
21512 if (IS_CV != IS_UNUSED) {
21513 zval *offset = EX_VAR(opline->op2.var);
21514 zend_string *str;
21515 zend_ulong hval;
21516
21517 add_again:
21518 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
21519 str = Z_STR_P(offset);
21520 if (IS_CV != IS_CONST) {
21521 if (ZEND_HANDLE_NUMERIC(str, hval)) {
21522 goto num_index;
21523 }
21524 }
21525 str_index:
21526 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
21527 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
21528 hval = Z_LVAL_P(offset);
21529 num_index:
21530 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
21531 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
21532 offset = Z_REFVAL_P(offset);
21533 goto add_again;
21534 } else if (Z_TYPE_P(offset) == IS_NULL) {
21535 str = ZSTR_EMPTY_ALLOC();
21536 goto str_index;
21537 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
21538 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
21539 goto num_index;
21540 } else if (Z_TYPE_P(offset) == IS_FALSE) {
21541 hval = 0;
21542 goto num_index;
21543 } else if (Z_TYPE_P(offset) == IS_TRUE) {
21544 hval = 1;
21545 goto num_index;
21546 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
21547 zend_use_resource_as_offset(offset);
21548 hval = Z_RES_HANDLE_P(offset);
21549 goto num_index;
21550 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
21551 ZVAL_UNDEFINED_OP2();
21552 str = ZSTR_EMPTY_ALLOC();
21553 goto str_index;
21554 } else {
21555 zend_illegal_array_offset_access(offset);
21556 zval_ptr_dtor_nogc(expr_ptr);
21557 }
21558
21559 } else {
21560 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
21561 zend_cannot_add_element();
21562 zval_ptr_dtor_nogc(expr_ptr);
21563 }
21564 }
21565 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21566 }
21567
ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21568 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21569 {
21570 zval *array;
21571 uint32_t size;
21572 USE_OPLINE
21573
21574 array = EX_VAR(opline->result.var);
21575 if (IS_TMP_VAR != IS_UNUSED) {
21576 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
21577 ZVAL_ARR(array, zend_new_array(size));
21578 /* Explicitly initialize array as not-packed if flag is set */
21579 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
21580 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
21581 }
21582 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21583 } else {
21584 ZVAL_ARR(array, zend_new_array(0));
21585 ZEND_VM_NEXT_OPCODE();
21586 }
21587 }
21588
ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21589 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21590 {
21591 USE_OPLINE
21592
21593 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
21594
21595 SAVE_OPLINE();
21596 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
21597 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21598 }
21599
21600 /* Destroy the previously yielded value */
21601 zval_ptr_dtor(&generator->value);
21602
21603 /* Destroy the previously yielded key */
21604 zval_ptr_dtor(&generator->key);
21605
21606 /* Set the new yielded value */
21607 if (IS_TMP_VAR != IS_UNUSED) {
21608 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
21609 /* Constants and temporary variables aren't yieldable by reference,
21610 * but we still allow them with a notice. */
21611 if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) {
21612 zval *value;
21613
21614 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21615
21616 value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21617 ZVAL_COPY_VALUE(&generator->value, value);
21618 if (IS_TMP_VAR == IS_CONST) {
21619 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21620 Z_ADDREF(generator->value);
21621 }
21622 }
21623 } else {
21624 zval *value_ptr = zend_get_bad_ptr();
21625
21626 /* If a function call result is yielded and the function did
21627 * not return by reference we throw a notice. */
21628 do {
21629 if (IS_TMP_VAR == IS_VAR) {
21630 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
21631 if (opline->extended_value == ZEND_RETURNS_FUNCTION
21632 && !Z_ISREF_P(value_ptr)) {
21633 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
21634 ZVAL_COPY(&generator->value, value_ptr);
21635 break;
21636 }
21637 }
21638 if (Z_ISREF_P(value_ptr)) {
21639 Z_ADDREF_P(value_ptr);
21640 } else {
21641 ZVAL_MAKE_REF_EX(value_ptr, 2);
21642 }
21643 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
21644 } while (0);
21645
21646 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21647 }
21648 } else {
21649 zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21650
21651 /* Consts, temporary variables and references need copying */
21652 if (IS_TMP_VAR == IS_CONST) {
21653 ZVAL_COPY_VALUE(&generator->value, value);
21654 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
21655 Z_ADDREF(generator->value);
21656 }
21657 } else if (IS_TMP_VAR == IS_TMP_VAR) {
21658 ZVAL_COPY_VALUE(&generator->value, value);
21659 } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
21660 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
21661
21662 } else {
21663 ZVAL_COPY_VALUE(&generator->value, value);
21664 if (IS_TMP_VAR == IS_CV) {
21665 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
21666 }
21667 }
21668 }
21669 } else {
21670 /* If no value was specified yield null */
21671 ZVAL_NULL(&generator->value);
21672 }
21673
21674 /* Set the new yielded key */
21675 if (IS_CV != IS_UNUSED) {
21676 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
21677 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
21678 key = Z_REFVAL_P(key);
21679 }
21680 ZVAL_COPY(&generator->key, key);
21681
21682 if (Z_TYPE(generator->key) == IS_LONG
21683 && Z_LVAL(generator->key) > generator->largest_used_integer_key
21684 ) {
21685 generator->largest_used_integer_key = Z_LVAL(generator->key);
21686 }
21687 } else {
21688 /* If no key was specified we use auto-increment keys */
21689 generator->largest_used_integer_key++;
21690 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
21691 }
21692
21693 if (RETURN_VALUE_USED(opline)) {
21694 /* If the return value of yield is used set the send
21695 * target and initialize it to NULL */
21696 generator->send_target = EX_VAR(opline->result.var);
21697 ZVAL_NULL(generator->send_target);
21698 } else {
21699 generator->send_target = NULL;
21700 }
21701
21702 /* We increment to the next op, so we are at the correct position when the
21703 * generator is resumed. */
21704 ZEND_VM_INC_OPCODE();
21705
21706 /* The GOTO VM uses a local opline variable. We need to set the opline
21707 * variable in execute_data so we don't resume at an old position. */
21708 SAVE_OPLINE();
21709
21710 ZEND_VM_RETURN();
21711 }
21712
ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21713 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21714 {
21715 USE_OPLINE
21716 zval *closure, *var;
21717
21718 closure = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
21719 if (opline->extended_value & ZEND_BIND_REF) {
21720 /* By-ref binding */
21721 var = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
21722 if (Z_ISREF_P(var)) {
21723 Z_ADDREF_P(var);
21724 } else {
21725 ZVAL_MAKE_REF_EX(var, 2);
21726 }
21727 } else {
21728 var = EX_VAR(opline->op2.var);
21729 if (UNEXPECTED(Z_ISUNDEF_P(var)) && !(opline->extended_value & ZEND_BIND_IMPLICIT)) {
21730 SAVE_OPLINE();
21731 var = ZVAL_UNDEFINED_OP2();
21732 if (UNEXPECTED(EG(exception))) {
21733 HANDLE_EXCEPTION();
21734 }
21735 }
21736 ZVAL_DEREF(var);
21737 Z_TRY_ADDREF_P(var);
21738 }
21739
21740 zend_closure_bind_var_ex(closure,
21741 (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT)), var);
21742 ZEND_VM_NEXT_OPCODE();
21743 }
21744
zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)21745 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
21746 {
21747 USE_OPLINE
21748 zval *var_ptr;
21749
21750 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21751
21752 SAVE_OPLINE();
21753 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
21754 ZVAL_UNDEFINED_OP1();
21755 ZVAL_NULL(var_ptr);
21756 }
21757
21758 do {
21759 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
21760 zend_reference *ref = Z_REF_P(var_ptr);
21761 var_ptr = Z_REFVAL_P(var_ptr);
21762 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
21763 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
21764 break;
21765 }
21766 }
21767 increment_function(var_ptr);
21768 } while (0);
21769
21770 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
21771 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
21772 }
21773
21774 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21775 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21776 }
21777
ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21778 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21779 {
21780 USE_OPLINE
21781 zval *var_ptr;
21782
21783 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21784
21785 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
21786 fast_long_increment_function(var_ptr);
21787 if (UNEXPECTED(0)) {
21788 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
21789 }
21790 ZEND_VM_NEXT_OPCODE();
21791 }
21792
21793 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21794 }
21795
ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21796 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21797 {
21798 USE_OPLINE
21799 zval *var_ptr;
21800
21801 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21802
21803 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
21804 fast_long_increment_function(var_ptr);
21805 if (UNEXPECTED(1)) {
21806 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
21807 }
21808 ZEND_VM_NEXT_OPCODE();
21809 }
21810
21811 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21812 }
21813
zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)21814 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
21815 {
21816 USE_OPLINE
21817 zval *var_ptr;
21818
21819 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21820
21821 SAVE_OPLINE();
21822 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
21823 ZVAL_UNDEFINED_OP1();
21824 ZVAL_NULL(var_ptr);
21825 }
21826
21827 do {
21828 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
21829 zend_reference *ref = Z_REF_P(var_ptr);
21830 var_ptr = Z_REFVAL_P(var_ptr);
21831
21832 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
21833 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
21834 break;
21835 }
21836 }
21837 decrement_function(var_ptr);
21838 } while (0);
21839
21840 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
21841 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
21842 }
21843
21844 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21845 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21846 }
21847
ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21848 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21849 {
21850 USE_OPLINE
21851 zval *var_ptr;
21852
21853 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21854
21855 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
21856 fast_long_decrement_function(var_ptr);
21857 if (UNEXPECTED(0)) {
21858 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
21859 }
21860 ZEND_VM_NEXT_OPCODE();
21861 }
21862
21863 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21864 }
21865
ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21866 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21867 {
21868 USE_OPLINE
21869 zval *var_ptr;
21870
21871 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21872
21873 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
21874 fast_long_decrement_function(var_ptr);
21875 if (UNEXPECTED(1)) {
21876 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
21877 }
21878 ZEND_VM_NEXT_OPCODE();
21879 }
21880
21881 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21882 }
21883
zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)21884 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
21885 {
21886 USE_OPLINE
21887 zval *var_ptr;
21888
21889 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21890
21891 SAVE_OPLINE();
21892 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
21893 ZVAL_UNDEFINED_OP1();
21894 ZVAL_NULL(var_ptr);
21895 }
21896
21897 do {
21898 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
21899 zend_reference *ref = Z_REF_P(var_ptr);
21900 var_ptr = Z_REFVAL_P(var_ptr);
21901
21902 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
21903 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
21904 break;
21905 }
21906 }
21907 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
21908
21909 increment_function(var_ptr);
21910 } while (0);
21911
21912 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21913 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21914 }
21915
ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21916 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21917 {
21918 USE_OPLINE
21919 zval *var_ptr;
21920
21921 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21922
21923 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
21924 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
21925 fast_long_increment_function(var_ptr);
21926 ZEND_VM_NEXT_OPCODE();
21927 }
21928
21929 ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21930 }
21931
zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)21932 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
21933 {
21934 USE_OPLINE
21935 zval *var_ptr;
21936
21937 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21938
21939 SAVE_OPLINE();
21940 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
21941 ZVAL_UNDEFINED_OP1();
21942 ZVAL_NULL(var_ptr);
21943 }
21944
21945 do {
21946 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
21947 zend_reference *ref = Z_REF_P(var_ptr);
21948 var_ptr = Z_REFVAL_P(var_ptr);
21949
21950 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
21951 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
21952 break;
21953 }
21954 }
21955 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
21956
21957 decrement_function(var_ptr);
21958 } while (0);
21959
21960 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
21961 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
21962 }
21963
ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21964 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21965 {
21966 USE_OPLINE
21967 zval *var_ptr;
21968
21969 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21970
21971 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
21972 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
21973 fast_long_decrement_function(var_ptr);
21974 ZEND_VM_NEXT_OPCODE();
21975 }
21976
21977 ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
21978 }
21979
ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)21980 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
21981 {
21982 USE_OPLINE
21983 zval *retval_ptr;
21984 zval *return_value;
21985
21986 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
21987 return_value = EX(return_value);
21988
21989 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
21990 SAVE_OPLINE();
21991 retval_ptr = ZVAL_UNDEFINED_OP1();
21992 if (return_value) {
21993 ZVAL_NULL(return_value);
21994 }
21995 } else if (!return_value) {
21996 if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
21997 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
21998 SAVE_OPLINE();
21999 rc_dtor_func(Z_COUNTED_P(retval_ptr));
22000 }
22001 }
22002 } else {
22003 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22004 ZVAL_COPY_VALUE(return_value, retval_ptr);
22005 if (IS_VAR == IS_CONST) {
22006 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
22007 Z_ADDREF_P(return_value);
22008 }
22009 }
22010 } else if (IS_VAR == IS_CV) {
22011 do {
22012 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22013 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
22014 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
22015 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22016 ZVAL_COPY_VALUE(return_value, retval_ptr);
22017 if (GC_MAY_LEAK(ref)) {
22018 SAVE_OPLINE();
22019 gc_possible_root(ref);
22020 }
22021 ZVAL_NULL(retval_ptr);
22022 break;
22023 } else {
22024 Z_ADDREF_P(retval_ptr);
22025 }
22026 } else {
22027 retval_ptr = Z_REFVAL_P(retval_ptr);
22028 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22029 Z_ADDREF_P(retval_ptr);
22030 }
22031 }
22032 }
22033 ZVAL_COPY_VALUE(return_value, retval_ptr);
22034 } while (0);
22035 } else /* if (IS_VAR == IS_VAR) */ {
22036 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22037 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
22038
22039 retval_ptr = Z_REFVAL_P(retval_ptr);
22040 ZVAL_COPY_VALUE(return_value, retval_ptr);
22041 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22042 efree_size(ref, sizeof(zend_reference));
22043 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
22044 Z_ADDREF_P(retval_ptr);
22045 }
22046 } else {
22047 ZVAL_COPY_VALUE(return_value, retval_ptr);
22048 }
22049 }
22050 }
22051
22052
22053
22054 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22055 }
22056
ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22057 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22058 {
22059 USE_OPLINE
22060 zval *retval_ptr;
22061 zval *return_value;
22062
22063 SAVE_OPLINE();
22064
22065 return_value = EX(return_value);
22066
22067 do {
22068 if ((IS_VAR & (IS_CONST|IS_TMP_VAR)) ||
22069 (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
22070 /* Not supposed to happen, but we'll allow it */
22071 zend_error(E_NOTICE, "Only variable references should be returned by reference");
22072
22073 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22074 if (!return_value) {
22075 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22076 } else {
22077 if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
22078 ZVAL_COPY_VALUE(return_value, retval_ptr);
22079 break;
22080 }
22081
22082 ZVAL_NEW_REF(return_value, retval_ptr);
22083 if (IS_VAR == IS_CONST) {
22084 Z_TRY_ADDREF_P(retval_ptr);
22085 }
22086 }
22087 break;
22088 }
22089
22090 retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22091
22092 if (IS_VAR == IS_VAR) {
22093 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
22094 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
22095 zend_error(E_NOTICE, "Only variable references should be returned by reference");
22096 if (return_value) {
22097 ZVAL_NEW_REF(return_value, retval_ptr);
22098 } else {
22099 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22100 }
22101 break;
22102 }
22103 }
22104
22105 if (return_value) {
22106 if (Z_ISREF_P(retval_ptr)) {
22107 Z_ADDREF_P(retval_ptr);
22108 } else {
22109 ZVAL_MAKE_REF_EX(retval_ptr, 2);
22110 }
22111 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
22112 }
22113
22114 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22115 } while (0);
22116
22117
22118 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22119 }
22120
ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22121 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22122 {
22123 USE_OPLINE
22124 zval *retval;
22125
22126 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
22127
22128 SAVE_OPLINE();
22129 retval = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22130
22131 /* Copy return value into generator->retval */
22132 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
22133 ZVAL_COPY_VALUE(&generator->retval, retval);
22134 if (IS_VAR == IS_CONST) {
22135 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
22136 Z_ADDREF(generator->retval);
22137 }
22138 }
22139 } else if (IS_VAR == IS_CV) {
22140 ZVAL_COPY_DEREF(&generator->retval, retval);
22141 } else /* if (IS_VAR == IS_VAR) */ {
22142 if (UNEXPECTED(Z_ISREF_P(retval))) {
22143 zend_refcounted *ref = Z_COUNTED_P(retval);
22144
22145 retval = Z_REFVAL_P(retval);
22146 ZVAL_COPY_VALUE(&generator->retval, retval);
22147 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22148 efree_size(ref, sizeof(zend_reference));
22149 } else if (Z_OPT_REFCOUNTED_P(retval)) {
22150 Z_ADDREF_P(retval);
22151 }
22152 } else {
22153 ZVAL_COPY_VALUE(&generator->retval, retval);
22154 }
22155 }
22156
22157 EG(current_execute_data) = EX(prev_execute_data);
22158
22159 /* Close the generator to free up resources */
22160 zend_generator_close(generator, 1);
22161
22162 /* Pass execution back to handling code */
22163 ZEND_VM_RETURN();
22164 }
22165
ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22166 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22167 {
22168 USE_OPLINE
22169 zval *arg, *param;
22170
22171 SAVE_OPLINE();
22172
22173 arg = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22174 param = ZEND_CALL_VAR(EX(call), opline->result.var);
22175 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
22176 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
22177 Z_TRY_ADDREF_P(arg);
22178 ZVAL_NEW_REF(param, arg);
22179 } else {
22180 ZVAL_COPY(param, arg);
22181 }
22182
22183 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22184 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22185 }
22186
ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22187 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22188 {
22189 USE_OPLINE
22190 zval *expr;
22191 zval *result = EX_VAR(opline->result.var);
22192 HashTable *ht;
22193
22194 SAVE_OPLINE();
22195 expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22196
22197 switch (opline->extended_value) {
22198 case IS_LONG:
22199 ZVAL_LONG(result, zval_get_long(expr));
22200 break;
22201 case IS_DOUBLE:
22202 ZVAL_DOUBLE(result, zval_get_double(expr));
22203 break;
22204 case IS_STRING:
22205 ZVAL_STR(result, zval_get_string(expr));
22206 break;
22207 default:
22208 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
22209 if (IS_VAR & (IS_VAR|IS_CV)) {
22210 ZVAL_DEREF(expr);
22211 }
22212 /* If value is already of correct type, return it directly */
22213 if (Z_TYPE_P(expr) == opline->extended_value) {
22214 ZVAL_COPY_VALUE(result, expr);
22215 if (IS_VAR == IS_CONST) {
22216 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
22217 } else if (IS_VAR != IS_TMP_VAR) {
22218 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
22219 }
22220
22221 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22222 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22223 }
22224
22225 if (opline->extended_value == IS_ARRAY) {
22226 if (IS_VAR == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
22227 if (Z_TYPE_P(expr) != IS_NULL) {
22228 ZVAL_ARR(result, zend_new_array(1));
22229 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
22230 if (IS_VAR == IS_CONST) {
22231 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
22232 } else {
22233 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
22234 }
22235 } else {
22236 ZVAL_EMPTY_ARRAY(result);
22237 }
22238 } else if (Z_OBJ_P(expr)->properties == NULL
22239 && Z_OBJ_HT_P(expr)->get_properties_for == NULL
22240 && Z_OBJ_HT_P(expr)->get_properties == zend_std_get_properties) {
22241 /* Optimized version without rebuilding properties HashTable */
22242 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
22243 } else {
22244 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
22245 if (obj_ht) {
22246 /* fast copy */
22247 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
22248 (Z_OBJCE_P(expr)->default_properties_count ||
22249 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
22250 GC_IS_RECURSIVE(obj_ht))));
22251 zend_release_properties(obj_ht);
22252 } else {
22253 ZVAL_EMPTY_ARRAY(result);
22254 }
22255 }
22256 } else {
22257 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
22258 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
22259 if (Z_TYPE_P(expr) == IS_ARRAY) {
22260 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
22261 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
22262 /* TODO: try not to duplicate immutable arrays as well ??? */
22263 ht = zend_array_dup(ht);
22264 }
22265 Z_OBJ_P(result)->properties = ht;
22266 } else if (Z_TYPE_P(expr) != IS_NULL) {
22267 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
22268 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
22269 if (IS_VAR == IS_CONST) {
22270 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
22271 } else {
22272 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
22273 }
22274 }
22275 }
22276 }
22277
22278 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22279 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22280 }
22281
ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22282 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22283 {
22284 USE_OPLINE
22285 zval *array_ptr, *result;
22286
22287 SAVE_OPLINE();
22288
22289 array_ptr = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22290 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
22291 result = EX_VAR(opline->result.var);
22292 ZVAL_COPY_VALUE(result, array_ptr);
22293 if (IS_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
22294 Z_ADDREF_P(array_ptr);
22295 }
22296 Z_FE_POS_P(result) = 0;
22297
22298 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22299 ZEND_VM_NEXT_OPCODE();
22300 } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
22301 zend_object *zobj = Z_OBJ_P(array_ptr);
22302 if (!zobj->ce->get_iterator) {
22303 HashTable *properties = zobj->properties;
22304 if (properties) {
22305 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
22306 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
22307 GC_DELREF(properties);
22308 }
22309 properties = zobj->properties = zend_array_dup(properties);
22310 }
22311 } else {
22312 properties = zobj->handlers->get_properties(zobj);
22313 }
22314
22315 result = EX_VAR(opline->result.var);
22316 ZVAL_COPY_VALUE(result, array_ptr);
22317 if (IS_VAR != IS_TMP_VAR) {
22318 Z_ADDREF_P(array_ptr);
22319 }
22320
22321 if (zend_hash_num_elements(properties) == 0) {
22322 Z_FE_ITER_P(result) = (uint32_t) -1;
22323 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22324 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22325 }
22326
22327 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
22328 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22329 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22330 } else {
22331 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
22332
22333 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22334 if (UNEXPECTED(EG(exception))) {
22335 HANDLE_EXCEPTION();
22336 } else if (is_empty) {
22337 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22338 } else {
22339 ZEND_VM_NEXT_OPCODE();
22340 }
22341 }
22342 } else {
22343 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
22344 ZVAL_UNDEF(EX_VAR(opline->result.var));
22345 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
22346 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22347 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22348 }
22349 }
22350
ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22351 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22352 {
22353 USE_OPLINE
22354 zval *array_ptr, *array_ref;
22355
22356 SAVE_OPLINE();
22357
22358 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22359 array_ref = array_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22360 if (Z_ISREF_P(array_ref)) {
22361 array_ptr = Z_REFVAL_P(array_ref);
22362 }
22363 } else {
22364 array_ref = array_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22365 }
22366
22367 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
22368 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22369 if (array_ptr == array_ref) {
22370 ZVAL_NEW_REF(array_ref, array_ref);
22371 array_ptr = Z_REFVAL_P(array_ref);
22372 }
22373 Z_ADDREF_P(array_ref);
22374 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
22375 } else {
22376 array_ref = EX_VAR(opline->result.var);
22377 ZVAL_NEW_REF(array_ref, array_ptr);
22378 array_ptr = Z_REFVAL_P(array_ref);
22379 }
22380 if (IS_VAR == IS_CONST) {
22381 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
22382 } else {
22383 SEPARATE_ARRAY(array_ptr);
22384 }
22385 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
22386
22387 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22388 ZEND_VM_NEXT_OPCODE();
22389 } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
22390 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
22391 HashTable *properties;
22392 if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
22393 if (array_ptr == array_ref) {
22394 ZVAL_NEW_REF(array_ref, array_ref);
22395 array_ptr = Z_REFVAL_P(array_ref);
22396 }
22397 Z_ADDREF_P(array_ref);
22398 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
22399 } else {
22400 array_ptr = EX_VAR(opline->result.var);
22401 ZVAL_COPY_VALUE(array_ptr, array_ref);
22402 }
22403 if (Z_OBJ_P(array_ptr)->properties
22404 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
22405 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
22406 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
22407 }
22408 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
22409 }
22410
22411 properties = Z_OBJPROP_P(array_ptr);
22412 if (zend_hash_num_elements(properties) == 0) {
22413 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
22414 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22415 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22416 }
22417
22418 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
22419 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22420 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22421 } else {
22422 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
22423 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22424 if (UNEXPECTED(EG(exception))) {
22425 HANDLE_EXCEPTION();
22426 } else if (is_empty) {
22427 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22428 } else {
22429 ZEND_VM_NEXT_OPCODE();
22430 }
22431 }
22432 } else {
22433 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
22434 ZVAL_UNDEF(EX_VAR(opline->result.var));
22435 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
22436 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22437 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
22438 }
22439 }
22440
ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22441 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22442 {
22443 USE_OPLINE
22444 zval *array;
22445 zval *value;
22446 uint32_t value_type;
22447 HashTable *fe_ht;
22448 HashPosition pos;
22449
22450 array = EX_VAR(opline->op1.var);
22451 if (UNEXPECTED(Z_TYPE_P(array) != IS_ARRAY)) {
22452 ZEND_VM_TAIL_CALL(zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
22453 }
22454 fe_ht = Z_ARRVAL_P(array);
22455 pos = Z_FE_POS_P(array);
22456 if (HT_IS_PACKED(fe_ht)) {
22457 value = fe_ht->arPacked + pos;
22458 while (1) {
22459 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
22460 /* reached end of iteration */
22461 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
22462 ZEND_VM_CONTINUE();
22463 }
22464 value_type = Z_TYPE_INFO_P(value);
22465 ZEND_ASSERT(value_type != IS_INDIRECT);
22466 if (EXPECTED(value_type != IS_UNDEF)) {
22467 break;
22468 }
22469 pos++;
22470 value++;
22471 }
22472 Z_FE_POS_P(array) = pos + 1;
22473 if (RETURN_VALUE_USED(opline)) {
22474 ZVAL_LONG(EX_VAR(opline->result.var), pos);
22475 }
22476 } else {
22477 Bucket *p;
22478
22479 p = fe_ht->arData + pos;
22480 while (1) {
22481 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
22482 /* reached end of iteration */
22483 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
22484 ZEND_VM_CONTINUE();
22485 }
22486 pos++;
22487 value = &p->val;
22488 value_type = Z_TYPE_INFO_P(value);
22489 ZEND_ASSERT(value_type != IS_INDIRECT);
22490 if (EXPECTED(value_type != IS_UNDEF)) {
22491 break;
22492 }
22493 p++;
22494 }
22495 Z_FE_POS_P(array) = pos;
22496 if (RETURN_VALUE_USED(opline)) {
22497 if (!p->key) {
22498 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
22499 } else {
22500 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
22501 }
22502 }
22503 }
22504 if (EXPECTED(opline->op2_type == IS_CV)) {
22505 zval *variable_ptr = EX_VAR(opline->op2.var);
22506 SAVE_OPLINE();
22507 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
22508 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22509 } else {
22510 zval *res = EX_VAR(opline->op2.var);
22511 zend_refcounted *gc = Z_COUNTED_P(value);
22512
22513 ZVAL_COPY_VALUE_EX(res, value, gc, value_type);
22514 if (Z_TYPE_INFO_REFCOUNTED(value_type)) {
22515 GC_ADDREF(gc);
22516 }
22517 ZEND_VM_NEXT_OPCODE();
22518 }
22519 }
22520
ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22521 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22522 {
22523 USE_OPLINE
22524 zval *array;
22525 zval *value;
22526 uint32_t value_type;
22527 HashTable *fe_ht;
22528 HashPosition pos;
22529 Bucket *p;
22530
22531 array = EX_VAR(opline->op1.var);
22532 SAVE_OPLINE();
22533
22534 ZVAL_DEREF(array);
22535 if (EXPECTED(Z_TYPE_P(array) == IS_ARRAY)) {
22536 pos = zend_hash_iterator_pos_ex(Z_FE_ITER_P(EX_VAR(opline->op1.var)), array);
22537 fe_ht = Z_ARRVAL_P(array);
22538 if (HT_IS_PACKED(fe_ht)) {
22539 value = fe_ht->arPacked + pos;
22540 while (1) {
22541 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
22542 /* reached end of iteration */
22543 goto fe_fetch_w_exit;
22544 }
22545 value_type = Z_TYPE_INFO_P(value);
22546 ZEND_ASSERT(value_type != IS_INDIRECT);
22547 if (EXPECTED(value_type != IS_UNDEF)) {
22548 break;
22549 }
22550 pos++;
22551 value++;
22552 }
22553 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos + 1;
22554 if (RETURN_VALUE_USED(opline)) {
22555 ZVAL_LONG(EX_VAR(opline->result.var), pos);
22556 }
22557 } else {
22558 p = fe_ht->arData + pos;
22559 while (1) {
22560 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
22561 /* reached end of iteration */
22562 goto fe_fetch_w_exit;
22563 }
22564 pos++;
22565 value = &p->val;
22566 value_type = Z_TYPE_INFO_P(value);
22567 ZEND_ASSERT(value_type != IS_INDIRECT);
22568 if (EXPECTED(value_type != IS_UNDEF)) {
22569 break;
22570 }
22571 p++;
22572 }
22573 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
22574 if (RETURN_VALUE_USED(opline)) {
22575 if (!p->key) {
22576 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
22577 } else {
22578 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
22579 }
22580 }
22581 }
22582 } else if (EXPECTED(Z_TYPE_P(array) == IS_OBJECT)) {
22583 zend_object_iterator *iter;
22584
22585 if ((iter = zend_iterator_unwrap(array)) == NULL) {
22586 /* plain object */
22587
22588 fe_ht = Z_OBJPROP_P(array);
22589 pos = zend_hash_iterator_pos(Z_FE_ITER_P(EX_VAR(opline->op1.var)), fe_ht);
22590 p = fe_ht->arData + pos;
22591 while (1) {
22592 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
22593 /* reached end of iteration */
22594 goto fe_fetch_w_exit;
22595 }
22596 pos++;
22597 value = &p->val;
22598 value_type = Z_TYPE_INFO_P(value);
22599 if (EXPECTED(value_type != IS_UNDEF)) {
22600 if (UNEXPECTED(value_type == IS_INDIRECT)) {
22601 value = Z_INDIRECT_P(value);
22602 value_type = Z_TYPE_INFO_P(value);
22603 if (EXPECTED(value_type != IS_UNDEF)
22604 && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
22605 if ((value_type & Z_TYPE_MASK) != IS_REFERENCE) {
22606 zend_property_info *prop_info =
22607 zend_get_property_info_for_slot(Z_OBJ_P(array), value);
22608 if (prop_info) {
22609 if (UNEXPECTED(prop_info->flags & ZEND_ACC_READONLY)) {
22610 zend_throw_error(NULL,
22611 "Cannot acquire reference to readonly property %s::$%s",
22612 ZSTR_VAL(prop_info->ce->name), ZSTR_VAL(p->key));
22613 UNDEF_RESULT();
22614 HANDLE_EXCEPTION();
22615 }
22616 if (ZEND_TYPE_IS_SET(prop_info->type)) {
22617 ZVAL_NEW_REF(value, value);
22618 ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(value), prop_info);
22619 value_type = IS_REFERENCE_EX;
22620 }
22621 }
22622 }
22623 break;
22624 }
22625 } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
22626 || !p->key
22627 || zend_check_property_access(Z_OBJ_P(array), p->key, 1) == SUCCESS) {
22628 break;
22629 }
22630 }
22631 p++;
22632 }
22633 EG(ht_iterators)[Z_FE_ITER_P(EX_VAR(opline->op1.var))].pos = pos;
22634 if (RETURN_VALUE_USED(opline)) {
22635 if (UNEXPECTED(!p->key)) {
22636 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
22637 } else if (ZSTR_VAL(p->key)[0]) {
22638 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
22639 } else {
22640 const char *class_name, *prop_name;
22641 size_t prop_name_len;
22642 zend_unmangle_property_name_ex(
22643 p->key, &class_name, &prop_name, &prop_name_len);
22644 ZVAL_STRINGL(EX_VAR(opline->result.var), prop_name, prop_name_len);
22645 }
22646 }
22647 } else {
22648 const zend_object_iterator_funcs *funcs = iter->funcs;
22649 if (++iter->index > 0) {
22650 /* This could cause an endless loop if index becomes zero again.
22651 * In case that ever happens we need an additional flag. */
22652 funcs->move_forward(iter);
22653 if (UNEXPECTED(EG(exception) != NULL)) {
22654 UNDEF_RESULT();
22655 HANDLE_EXCEPTION();
22656 }
22657 if (UNEXPECTED(funcs->valid(iter) == FAILURE)) {
22658 /* reached end of iteration */
22659 if (UNEXPECTED(EG(exception) != NULL)) {
22660 UNDEF_RESULT();
22661 HANDLE_EXCEPTION();
22662 }
22663 goto fe_fetch_w_exit;
22664 }
22665 }
22666 value = funcs->get_current_data(iter);
22667 if (UNEXPECTED(EG(exception) != NULL)) {
22668 UNDEF_RESULT();
22669 HANDLE_EXCEPTION();
22670 }
22671 if (!value) {
22672 /* failure in get_current_data */
22673 goto fe_fetch_w_exit;
22674 }
22675 if (RETURN_VALUE_USED(opline)) {
22676 if (funcs->get_current_key) {
22677 funcs->get_current_key(iter, EX_VAR(opline->result.var));
22678 if (UNEXPECTED(EG(exception) != NULL)) {
22679 UNDEF_RESULT();
22680 HANDLE_EXCEPTION();
22681 }
22682 } else {
22683 ZVAL_LONG(EX_VAR(opline->result.var), iter->index);
22684 }
22685 }
22686 value_type = Z_TYPE_INFO_P(value);
22687 }
22688 } else {
22689 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array));
22690 if (UNEXPECTED(EG(exception))) {
22691 UNDEF_RESULT();
22692 HANDLE_EXCEPTION();
22693 }
22694 fe_fetch_w_exit:
22695 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
22696 ZEND_VM_CONTINUE();
22697 }
22698
22699 if (EXPECTED((value_type & Z_TYPE_MASK) != IS_REFERENCE)) {
22700 zend_refcounted *gc = Z_COUNTED_P(value);
22701 zval *ref;
22702 ZVAL_NEW_EMPTY_REF(value);
22703 ref = Z_REFVAL_P(value);
22704 ZVAL_COPY_VALUE_EX(ref, value, gc, value_type);
22705 }
22706 if (EXPECTED(opline->op2_type == IS_CV)) {
22707 zval *variable_ptr = EX_VAR(opline->op2.var);
22708 if (EXPECTED(variable_ptr != value)) {
22709 zend_reference *ref;
22710
22711 ref = Z_REF_P(value);
22712 GC_ADDREF(ref);
22713 i_zval_ptr_dtor(variable_ptr);
22714 ZVAL_REF(variable_ptr, ref);
22715 }
22716 } else {
22717 Z_ADDREF_P(value);
22718 ZVAL_REF(EX_VAR(opline->op2.var), Z_REF_P(value));
22719 }
22720 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22721 }
22722
ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22723 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22724 {
22725 USE_OPLINE
22726 zval *value;
22727 zend_reference *ref = NULL;
22728 bool ret;
22729
22730 SAVE_OPLINE();
22731 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22732
22733 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && Z_ISREF_P(value)) {
22734 if (IS_VAR == IS_VAR) {
22735 ref = Z_REF_P(value);
22736 }
22737 value = Z_REFVAL_P(value);
22738 }
22739
22740 ret = i_zend_is_true(value);
22741
22742 if (UNEXPECTED(EG(exception))) {
22743 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22744 ZVAL_UNDEF(EX_VAR(opline->result.var));
22745 HANDLE_EXCEPTION();
22746 }
22747
22748 if (ret) {
22749 zval *result = EX_VAR(opline->result.var);
22750
22751 ZVAL_COPY_VALUE(result, value);
22752 if (IS_VAR == IS_CONST) {
22753 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
22754 } else if (IS_VAR == IS_CV) {
22755 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
22756 } else if (IS_VAR == IS_VAR && ref) {
22757 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22758 efree_size(ref, sizeof(zend_reference));
22759 } else if (Z_OPT_REFCOUNTED_P(result)) {
22760 Z_ADDREF_P(result);
22761 }
22762 }
22763 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22764 }
22765
22766 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22767 ZEND_VM_NEXT_OPCODE();
22768 }
22769
ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22770 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22771 {
22772 USE_OPLINE
22773 zval *value;
22774 zend_reference *ref = NULL;
22775
22776 SAVE_OPLINE();
22777 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22778
22779 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
22780 if (IS_VAR & IS_VAR) {
22781 ref = Z_REF_P(value);
22782 }
22783 value = Z_REFVAL_P(value);
22784 }
22785
22786 if (Z_TYPE_P(value) > IS_NULL) {
22787 zval *result = EX_VAR(opline->result.var);
22788 ZVAL_COPY_VALUE(result, value);
22789 if (IS_VAR == IS_CONST) {
22790 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
22791 } else if (IS_VAR == IS_CV) {
22792 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
22793 } else if ((IS_VAR & IS_VAR) && ref) {
22794 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22795 efree_size(ref, sizeof(zend_reference));
22796 } else if (Z_OPT_REFCOUNTED_P(result)) {
22797 Z_ADDREF_P(result);
22798 }
22799 }
22800 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22801 }
22802
22803 if ((IS_VAR & IS_VAR) && ref) {
22804 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
22805 efree_size(ref, sizeof(zend_reference));
22806 }
22807 }
22808 ZEND_VM_NEXT_OPCODE();
22809 }
22810
ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22811 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22812 {
22813 USE_OPLINE
22814 zval *val, *result;
22815
22816 val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22817
22818 if (Z_TYPE_P(val) > IS_NULL) {
22819 do {
22820 if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
22821 val = Z_REFVAL_P(val);
22822 if (Z_TYPE_P(val) <= IS_NULL) {
22823 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22824 break;
22825 }
22826 }
22827 ZEND_VM_NEXT_OPCODE();
22828 } while (0);
22829 }
22830
22831 result = EX_VAR(opline->result.var);
22832 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
22833 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
22834 ZVAL_NULL(result);
22835 if (IS_VAR == IS_CV
22836 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
22837 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
22838 ) {
22839 SAVE_OPLINE();
22840 ZVAL_UNDEFINED_OP1();
22841 if (UNEXPECTED(EG(exception) != NULL)) {
22842 HANDLE_EXCEPTION();
22843 }
22844 }
22845 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
22846 ZVAL_FALSE(result);
22847 } else {
22848 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
22849 ZVAL_TRUE(result);
22850 }
22851
22852 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
22853 }
22854
ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22855 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22856 {
22857 USE_OPLINE
22858 zval *value;
22859 zval *result = EX_VAR(opline->result.var);
22860
22861 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22862 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
22863 SAVE_OPLINE();
22864 ZVAL_UNDEFINED_OP1();
22865 ZVAL_NULL(result);
22866 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
22867 }
22868
22869 if (IS_VAR == IS_CV) {
22870 ZVAL_COPY_DEREF(result, value);
22871 } else if (IS_VAR == IS_VAR) {
22872 if (UNEXPECTED(Z_ISREF_P(value))) {
22873 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
22874 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
22875 efree_size(Z_REF_P(value), sizeof(zend_reference));
22876 } else if (Z_OPT_REFCOUNTED_P(result)) {
22877 Z_ADDREF_P(result);
22878 }
22879 } else {
22880 ZVAL_COPY_VALUE(result, value);
22881 }
22882 } else {
22883 ZVAL_COPY_VALUE(result, value);
22884 if (IS_VAR == IS_CONST) {
22885 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
22886 Z_ADDREF_P(result);
22887 }
22888 }
22889 }
22890 ZEND_VM_NEXT_OPCODE();
22891 }
22892
ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22893 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22894 {
22895 USE_OPLINE
22896 zval *varptr, *arg;
22897
22898 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22899 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
22900
22901 if (IS_VAR == IS_CV) {
22902 ZVAL_COPY(arg, varptr);
22903 } else /* if (IS_VAR == IS_VAR) */ {
22904 ZVAL_COPY_VALUE(arg, varptr);
22905 }
22906
22907 ZEND_VM_NEXT_OPCODE();
22908 }
22909
ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22910 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22911 {
22912 USE_OPLINE
22913 zval *op1, *op2;
22914 bool result;
22915
22916 SAVE_OPLINE();
22917 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22918 op2 = RT_CONSTANT(opline, opline->op2);
22919 result = fast_is_identical_function(op1, op2);
22920 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22921
22922 ZEND_VM_SMART_BRANCH(result, 1);
22923 }
22924
ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22925 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22926 {
22927 USE_OPLINE
22928 zval *op1, *op2;
22929 bool result;
22930
22931 SAVE_OPLINE();
22932 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22933 op2 = RT_CONSTANT(opline, opline->op2);
22934 result = fast_is_identical_function(op1, op2);
22935
22936 ZEND_VM_SMART_BRANCH(result, 1);
22937 }
22938
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22939 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22940 {
22941 USE_OPLINE
22942 zval *op1, *op2;
22943 bool result;
22944
22945 SAVE_OPLINE();
22946 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
22947 op2 = RT_CONSTANT(opline, opline->op2);
22948 result = fast_is_not_identical_function(op1, op2);
22949 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
22950
22951 ZEND_VM_SMART_BRANCH(result, 1);
22952 }
22953
ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)22954 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
22955 {
22956 USE_OPLINE
22957 zval *object;
22958 zval *property;
22959 zval *value;
22960 zval *zptr;
22961 void **cache_slot;
22962 zend_property_info *prop_info;
22963 zend_object *zobj;
22964 zend_string *name, *tmp_name;
22965
22966 SAVE_OPLINE();
22967 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
22968 property = RT_CONSTANT(opline, opline->op2);
22969
22970 do {
22971 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
22972
22973 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
22974 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
22975 object = Z_REFVAL_P(object);
22976 goto assign_op_object;
22977 }
22978 if (IS_VAR == IS_CV
22979 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
22980 ZVAL_UNDEFINED_OP1();
22981 }
22982 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
22983 break;
22984 }
22985
22986 assign_op_object:
22987 /* here we are sure we are dealing with an object */
22988 zobj = Z_OBJ_P(object);
22989 if (IS_CONST == IS_CONST) {
22990 name = Z_STR_P(property);
22991 } else {
22992 name = zval_try_get_tmp_string(property, &tmp_name);
22993 if (UNEXPECTED(!name)) {
22994 UNDEF_RESULT();
22995 break;
22996 }
22997 }
22998 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
22999 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23000 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23001 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23002 ZVAL_NULL(EX_VAR(opline->result.var));
23003 }
23004 } else {
23005 zval *orig_zptr = zptr;
23006 zend_reference *ref;
23007
23008 do {
23009 if (UNEXPECTED(Z_ISREF_P(zptr))) {
23010 ref = Z_REF_P(zptr);
23011 zptr = Z_REFVAL_P(zptr);
23012 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23013 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23014 break;
23015 }
23016 }
23017
23018 if (IS_CONST == IS_CONST) {
23019 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23020 } else {
23021 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
23022 }
23023 if (prop_info) {
23024 /* special case for typed properties */
23025 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
23026 } else {
23027 zend_binary_op(zptr, zptr, value OPLINE_CC);
23028 }
23029 } while (0);
23030
23031 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23032 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
23033 }
23034 }
23035 } else {
23036 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
23037 }
23038 if (IS_CONST != IS_CONST) {
23039 zend_tmp_string_release(tmp_name);
23040 }
23041 } while (0);
23042
23043 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23044
23045 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23046 /* assign_obj has two opcodes! */
23047 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23048 }
23049
23050 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23051 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23052 {
23053 USE_OPLINE
23054 zval *var_ptr;
23055 zval *value, *container, *dim;
23056 HashTable *ht;
23057
23058 SAVE_OPLINE();
23059 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23060
23061 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23062 assign_dim_op_array:
23063 SEPARATE_ARRAY(container);
23064 ht = Z_ARRVAL_P(container);
23065 assign_dim_op_new_array:
23066 dim = RT_CONSTANT(opline, opline->op2);
23067 if (IS_CONST == IS_UNUSED) {
23068 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
23069 if (UNEXPECTED(!var_ptr)) {
23070 zend_cannot_add_element();
23071 goto assign_dim_op_ret_null;
23072 }
23073 } else {
23074 if (IS_CONST == IS_CONST) {
23075 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
23076 } else {
23077 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
23078 }
23079 if (UNEXPECTED(!var_ptr)) {
23080 goto assign_dim_op_ret_null;
23081 }
23082 }
23083
23084 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
23085
23086 do {
23087 if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
23088 zend_reference *ref = Z_REF_P(var_ptr);
23089 var_ptr = Z_REFVAL_P(var_ptr);
23090 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23091 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23092 break;
23093 }
23094 }
23095 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23096 } while (0);
23097
23098 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23099 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23100 }
23101 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23102 } else {
23103 if (EXPECTED(Z_ISREF_P(container))) {
23104 container = Z_REFVAL_P(container);
23105 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
23106 goto assign_dim_op_array;
23107 }
23108 }
23109
23110 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
23111 zend_object *obj = Z_OBJ_P(container);
23112
23113 dim = RT_CONSTANT(opline, opline->op2);
23114 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
23115 dim++;
23116 }
23117 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
23118 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
23119 uint8_t old_type;
23120
23121 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
23122 ZVAL_UNDEFINED_OP1();
23123 }
23124 ht = zend_new_array(8);
23125 old_type = Z_TYPE_P(container);
23126 ZVAL_ARR(container, ht);
23127 if (UNEXPECTED(old_type == IS_FALSE)) {
23128 GC_ADDREF(ht);
23129 zend_false_to_array_deprecated();
23130 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
23131 zend_array_destroy(ht);
23132 goto assign_dim_op_ret_null;
23133 }
23134 }
23135 goto assign_dim_op_new_array;
23136 } else {
23137 dim = RT_CONSTANT(opline, opline->op2);
23138 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
23139 assign_dim_op_ret_null:
23140 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
23141 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23142 ZVAL_NULL(EX_VAR(opline->result.var));
23143 }
23144 }
23145 }
23146
23147 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23148 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23149 }
23150
ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23151 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23152 {
23153 USE_OPLINE
23154 zval *var_ptr;
23155 zval *value;
23156
23157 SAVE_OPLINE();
23158 value = RT_CONSTANT(opline, opline->op2);
23159 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23160
23161 do {
23162 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
23163 zend_reference *ref = Z_REF_P(var_ptr);
23164 var_ptr = Z_REFVAL_P(var_ptr);
23165 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
23166 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
23167 break;
23168 }
23169 }
23170 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
23171 } while (0);
23172
23173 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23174 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
23175 }
23176
23177 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23178 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23179 }
23180
ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23181 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23182 {
23183 USE_OPLINE
23184 zval *object;
23185 zval *property;
23186 zval *zptr;
23187 void **cache_slot;
23188 zend_property_info *prop_info;
23189 zend_object *zobj;
23190 zend_string *name, *tmp_name;
23191
23192 SAVE_OPLINE();
23193 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23194 property = RT_CONSTANT(opline, opline->op2);
23195
23196 do {
23197 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23198 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23199 object = Z_REFVAL_P(object);
23200 goto pre_incdec_object;
23201 }
23202 if (IS_VAR == IS_CV
23203 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23204 ZVAL_UNDEFINED_OP1();
23205 }
23206 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23207 break;
23208 }
23209
23210 pre_incdec_object:
23211 /* here we are sure we are dealing with an object */
23212 zobj = Z_OBJ_P(object);
23213 if (IS_CONST == IS_CONST) {
23214 name = Z_STR_P(property);
23215 } else {
23216 name = zval_try_get_tmp_string(property, &tmp_name);
23217 if (UNEXPECTED(!name)) {
23218 UNDEF_RESULT();
23219 break;
23220 }
23221 }
23222 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
23223 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23224 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23225 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23226 ZVAL_NULL(EX_VAR(opline->result.var));
23227 }
23228 } else {
23229 if (IS_CONST == IS_CONST) {
23230 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
23231 } else {
23232 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
23233 }
23234 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23235 }
23236 } else {
23237 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23238 }
23239 if (IS_CONST != IS_CONST) {
23240 zend_tmp_string_release(tmp_name);
23241 }
23242 } while (0);
23243
23244 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23245 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23246 }
23247
ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23248 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23249 {
23250 USE_OPLINE
23251 zval *object;
23252 zval *property;
23253 zval *zptr;
23254 void **cache_slot;
23255 zend_property_info *prop_info;
23256 zend_object *zobj;
23257 zend_string *name, *tmp_name;
23258
23259 SAVE_OPLINE();
23260 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23261 property = RT_CONSTANT(opline, opline->op2);
23262
23263 do {
23264 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23265 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23266 object = Z_REFVAL_P(object);
23267 goto post_incdec_object;
23268 }
23269 if (IS_VAR == IS_CV
23270 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
23271 ZVAL_UNDEFINED_OP1();
23272 }
23273 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
23274 break;
23275 }
23276
23277 post_incdec_object:
23278 /* here we are sure we are dealing with an object */
23279 zobj = Z_OBJ_P(object);
23280 if (IS_CONST == IS_CONST) {
23281 name = Z_STR_P(property);
23282 } else {
23283 name = zval_try_get_tmp_string(property, &tmp_name);
23284 if (UNEXPECTED(!name)) {
23285 ZVAL_UNDEF(EX_VAR(opline->result.var));
23286 break;
23287 }
23288 }
23289 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
23290 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
23291 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
23292 ZVAL_NULL(EX_VAR(opline->result.var));
23293 } else {
23294 if (IS_CONST == IS_CONST) {
23295 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
23296 } else {
23297 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
23298 }
23299
23300 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
23301 }
23302 } else {
23303 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
23304 }
23305 if (IS_CONST != IS_CONST) {
23306 zend_tmp_string_release(tmp_name);
23307 }
23308 } while (0);
23309
23310 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23311 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23312 }
23313
ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23314 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23315 {
23316 USE_OPLINE
23317 zval *container;
23318
23319 SAVE_OPLINE();
23320 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23321 zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23322
23323 if (IS_VAR == IS_VAR) {
23324 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23325 }
23326 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23327 }
23328
ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23329 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23330 {
23331 USE_OPLINE
23332 zval *container;
23333
23334 SAVE_OPLINE();
23335 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23336 zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23337
23338 if (IS_VAR == IS_VAR) {
23339 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23340 }
23341 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23342 }
23343
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23344 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23345 {
23346 #if 0
23347 USE_OPLINE
23348 #endif
23349
23350 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
23351 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
23352 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23353 }
23354 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23355 } else {
23356 if (IS_CONST == IS_UNUSED) {
23357 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23358 }
23359 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23360 }
23361 }
23362
ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23363 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23364 {
23365 USE_OPLINE
23366 zval *container;
23367
23368 SAVE_OPLINE();
23369 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23370 zend_fetch_dimension_address_UNSET(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23371
23372 if (IS_VAR == IS_VAR) {
23373 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23374 }
23375 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23376 }
23377
ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23378 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23379 {
23380 USE_OPLINE
23381 zval *property, *container, *result;
23382
23383 SAVE_OPLINE();
23384
23385 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23386 property = RT_CONSTANT(opline, opline->op2);
23387 result = EX_VAR(opline->result.var);
23388 zend_fetch_property_address(
23389 result, container, IS_VAR, property, IS_CONST,
23390 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
23391 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
23392
23393 if (IS_VAR == IS_VAR) {
23394 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23395 }
23396 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23397 }
23398
ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23399 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23400 {
23401 USE_OPLINE
23402 zval *property, *container, *result;
23403
23404 SAVE_OPLINE();
23405 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23406 property = RT_CONSTANT(opline, opline->op2);
23407 result = EX_VAR(opline->result.var);
23408 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 OPLINE_CC EXECUTE_DATA_CC);
23409
23410 if (IS_VAR == IS_VAR) {
23411 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23412 }
23413 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23414 }
23415
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23416 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23417 {
23418 #if 0
23419 USE_OPLINE
23420 #endif
23421
23422 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
23423 /* Behave like FETCH_OBJ_W */
23424 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
23425 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23426 }
23427 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23428 } else {
23429 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
23430 }
23431 }
23432
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23433 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23434 {
23435 USE_OPLINE
23436 zval *container, *property, *result;
23437
23438 SAVE_OPLINE();
23439 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23440 property = RT_CONSTANT(opline, opline->op2);
23441 result = EX_VAR(opline->result.var);
23442 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 OPLINE_CC EXECUTE_DATA_CC);
23443
23444 if (IS_VAR == IS_VAR) {
23445 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
23446 }
23447 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23448 }
23449
ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23450 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23451 {
23452 USE_OPLINE
23453 zval *container, *dim;
23454
23455 SAVE_OPLINE();
23456 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23457 dim = RT_CONSTANT(opline, opline->op2);
23458
23459 if (IS_VAR == IS_VAR
23460 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
23461 && UNEXPECTED(!Z_ISREF_P(container))
23462 ) {
23463 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
23464 zend_fetch_dimension_address_LIST_r(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23465 } else {
23466 zend_fetch_dimension_address_W(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
23467 }
23468
23469 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
23470 }
23471
ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)23472 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23473 {
23474 USE_OPLINE
23475 zval *object, *value, tmp;
23476 zend_object *zobj;
23477 zend_string *name, *tmp_name;
23478 zend_refcounted *garbage = NULL;
23479
23480 SAVE_OPLINE();
23481 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23482 value = RT_CONSTANT((opline+1), (opline+1)->op1);
23483
23484 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23485 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23486 object = Z_REFVAL_P(object);
23487 goto assign_object;
23488 }
23489 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
23490 value = &EG(uninitialized_zval);
23491 goto free_and_exit_assign_obj;
23492 }
23493
23494 assign_object:
23495 zobj = Z_OBJ_P(object);
23496 if (IS_CONST == IS_CONST) {
23497 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
23498 void **cache_slot = CACHE_ADDR(opline->extended_value);
23499 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
23500 zval *property_val;
23501
23502 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
23503 property_val = OBJ_PROP(zobj, prop_offset);
23504 if (Z_TYPE_P(property_val) != IS_UNDEF) {
23505 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
23506
23507 if (prop_info != NULL) {
23508 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
23509 goto free_and_exit_assign_obj;
23510 } else {
23511 fast_assign_obj:
23512 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
23513 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23514 ZVAL_COPY(EX_VAR(opline->result.var), value);
23515 }
23516 goto exit_assign_obj;
23517 }
23518 }
23519 } else {
23520 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23521 if (EXPECTED(zobj->properties != NULL)) {
23522 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
23523 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
23524 GC_DELREF(zobj->properties);
23525 }
23526 zobj->properties = zend_array_dup(zobj->properties);
23527 }
23528 property_val = zend_hash_find_known_hash(zobj->properties, name);
23529 if (property_val) {
23530 goto fast_assign_obj;
23531 }
23532 }
23533
23534 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
23535 if (EXPECTED(zobj->properties == NULL)) {
23536 rebuild_object_properties(zobj);
23537 }
23538 if (IS_CONST == IS_CONST) {
23539 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
23540 Z_ADDREF_P(value);
23541 }
23542 } else if (IS_CONST != IS_TMP_VAR) {
23543 if (Z_ISREF_P(value)) {
23544 if (IS_CONST == IS_VAR) {
23545 zend_reference *ref = Z_REF_P(value);
23546 if (GC_DELREF(ref) == 0) {
23547 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
23548 efree_size(ref, sizeof(zend_reference));
23549 value = &tmp;
23550 } else {
23551 value = Z_REFVAL_P(value);
23552 Z_TRY_ADDREF_P(value);
23553 }
23554 } else {
23555 value = Z_REFVAL_P(value);
23556 Z_TRY_ADDREF_P(value);
23557 }
23558 } else if (IS_CONST == IS_CV) {
23559 Z_TRY_ADDREF_P(value);
23560 }
23561 }
23562 zend_hash_add_new(zobj->properties, name, value);
23563 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23564 ZVAL_COPY(EX_VAR(opline->result.var), value);
23565 }
23566 goto exit_assign_obj;
23567 }
23568 }
23569 }
23570 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23571 } else {
23572 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
23573 if (UNEXPECTED(!name)) {
23574
23575 UNDEF_RESULT();
23576 goto exit_assign_obj;
23577 }
23578 }
23579
23580 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
23581 ZVAL_DEREF(value);
23582 }
23583
23584 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
23585
23586 if (IS_CONST != IS_CONST) {
23587 zend_tmp_string_release(tmp_name);
23588 }
23589
23590 free_and_exit_assign_obj:
23591 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
23592 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
23593 }
23594
23595 exit_assign_obj:
23596 if (garbage) {
23597 GC_DTOR_NO_REF(garbage);
23598 }
23599
23600 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23601 /* assign_obj has two opcodes! */
23602 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23603 }
23604
23605 /* 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)23606 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23607 {
23608 USE_OPLINE
23609 zval *object, *value, tmp;
23610 zend_object *zobj;
23611 zend_string *name, *tmp_name;
23612 zend_refcounted *garbage = NULL;
23613
23614 SAVE_OPLINE();
23615 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23616 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
23617
23618 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23619 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23620 object = Z_REFVAL_P(object);
23621 goto assign_object;
23622 }
23623 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
23624 value = &EG(uninitialized_zval);
23625 goto free_and_exit_assign_obj;
23626 }
23627
23628 assign_object:
23629 zobj = Z_OBJ_P(object);
23630 if (IS_CONST == IS_CONST) {
23631 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
23632 void **cache_slot = CACHE_ADDR(opline->extended_value);
23633 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
23634 zval *property_val;
23635
23636 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
23637 property_val = OBJ_PROP(zobj, prop_offset);
23638 if (Z_TYPE_P(property_val) != IS_UNDEF) {
23639 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
23640
23641 if (prop_info != NULL) {
23642 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
23643 goto free_and_exit_assign_obj;
23644 } else {
23645 fast_assign_obj:
23646 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
23647 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23648 ZVAL_COPY(EX_VAR(opline->result.var), value);
23649 }
23650 goto exit_assign_obj;
23651 }
23652 }
23653 } else {
23654 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23655 if (EXPECTED(zobj->properties != NULL)) {
23656 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
23657 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
23658 GC_DELREF(zobj->properties);
23659 }
23660 zobj->properties = zend_array_dup(zobj->properties);
23661 }
23662 property_val = zend_hash_find_known_hash(zobj->properties, name);
23663 if (property_val) {
23664 goto fast_assign_obj;
23665 }
23666 }
23667
23668 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
23669 if (EXPECTED(zobj->properties == NULL)) {
23670 rebuild_object_properties(zobj);
23671 }
23672 if (IS_TMP_VAR == IS_CONST) {
23673 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
23674 Z_ADDREF_P(value);
23675 }
23676 } else if (IS_TMP_VAR != IS_TMP_VAR) {
23677 if (Z_ISREF_P(value)) {
23678 if (IS_TMP_VAR == IS_VAR) {
23679 zend_reference *ref = Z_REF_P(value);
23680 if (GC_DELREF(ref) == 0) {
23681 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
23682 efree_size(ref, sizeof(zend_reference));
23683 value = &tmp;
23684 } else {
23685 value = Z_REFVAL_P(value);
23686 Z_TRY_ADDREF_P(value);
23687 }
23688 } else {
23689 value = Z_REFVAL_P(value);
23690 Z_TRY_ADDREF_P(value);
23691 }
23692 } else if (IS_TMP_VAR == IS_CV) {
23693 Z_TRY_ADDREF_P(value);
23694 }
23695 }
23696 zend_hash_add_new(zobj->properties, name, value);
23697 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23698 ZVAL_COPY(EX_VAR(opline->result.var), value);
23699 }
23700 goto exit_assign_obj;
23701 }
23702 }
23703 }
23704 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23705 } else {
23706 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
23707 if (UNEXPECTED(!name)) {
23708 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
23709 UNDEF_RESULT();
23710 goto exit_assign_obj;
23711 }
23712 }
23713
23714 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
23715 ZVAL_DEREF(value);
23716 }
23717
23718 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
23719
23720 if (IS_CONST != IS_CONST) {
23721 zend_tmp_string_release(tmp_name);
23722 }
23723
23724 free_and_exit_assign_obj:
23725 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
23726 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
23727 }
23728 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
23729 exit_assign_obj:
23730 if (garbage) {
23731 GC_DTOR_NO_REF(garbage);
23732 }
23733
23734 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23735 /* assign_obj has two opcodes! */
23736 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23737 }
23738
23739 /* 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)23740 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23741 {
23742 USE_OPLINE
23743 zval *object, *value, tmp;
23744 zend_object *zobj;
23745 zend_string *name, *tmp_name;
23746 zend_refcounted *garbage = NULL;
23747
23748 SAVE_OPLINE();
23749 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23750 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
23751
23752 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23753 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23754 object = Z_REFVAL_P(object);
23755 goto assign_object;
23756 }
23757 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
23758 value = &EG(uninitialized_zval);
23759 goto free_and_exit_assign_obj;
23760 }
23761
23762 assign_object:
23763 zobj = Z_OBJ_P(object);
23764 if (IS_CONST == IS_CONST) {
23765 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
23766 void **cache_slot = CACHE_ADDR(opline->extended_value);
23767 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
23768 zval *property_val;
23769
23770 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
23771 property_val = OBJ_PROP(zobj, prop_offset);
23772 if (Z_TYPE_P(property_val) != IS_UNDEF) {
23773 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
23774
23775 if (prop_info != NULL) {
23776 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
23777 goto free_and_exit_assign_obj;
23778 } else {
23779 fast_assign_obj:
23780 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
23781 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23782 ZVAL_COPY(EX_VAR(opline->result.var), value);
23783 }
23784 goto exit_assign_obj;
23785 }
23786 }
23787 } else {
23788 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23789 if (EXPECTED(zobj->properties != NULL)) {
23790 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
23791 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
23792 GC_DELREF(zobj->properties);
23793 }
23794 zobj->properties = zend_array_dup(zobj->properties);
23795 }
23796 property_val = zend_hash_find_known_hash(zobj->properties, name);
23797 if (property_val) {
23798 goto fast_assign_obj;
23799 }
23800 }
23801
23802 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
23803 if (EXPECTED(zobj->properties == NULL)) {
23804 rebuild_object_properties(zobj);
23805 }
23806 if (IS_VAR == IS_CONST) {
23807 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
23808 Z_ADDREF_P(value);
23809 }
23810 } else if (IS_VAR != IS_TMP_VAR) {
23811 if (Z_ISREF_P(value)) {
23812 if (IS_VAR == IS_VAR) {
23813 zend_reference *ref = Z_REF_P(value);
23814 if (GC_DELREF(ref) == 0) {
23815 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
23816 efree_size(ref, sizeof(zend_reference));
23817 value = &tmp;
23818 } else {
23819 value = Z_REFVAL_P(value);
23820 Z_TRY_ADDREF_P(value);
23821 }
23822 } else {
23823 value = Z_REFVAL_P(value);
23824 Z_TRY_ADDREF_P(value);
23825 }
23826 } else if (IS_VAR == IS_CV) {
23827 Z_TRY_ADDREF_P(value);
23828 }
23829 }
23830 zend_hash_add_new(zobj->properties, name, value);
23831 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23832 ZVAL_COPY(EX_VAR(opline->result.var), value);
23833 }
23834 goto exit_assign_obj;
23835 }
23836 }
23837 }
23838 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23839 } else {
23840 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
23841 if (UNEXPECTED(!name)) {
23842 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
23843 UNDEF_RESULT();
23844 goto exit_assign_obj;
23845 }
23846 }
23847
23848 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
23849 ZVAL_DEREF(value);
23850 }
23851
23852 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
23853
23854 if (IS_CONST != IS_CONST) {
23855 zend_tmp_string_release(tmp_name);
23856 }
23857
23858 free_and_exit_assign_obj:
23859 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
23860 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
23861 }
23862 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
23863 exit_assign_obj:
23864 if (garbage) {
23865 GC_DTOR_NO_REF(garbage);
23866 }
23867
23868 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
23869 /* assign_obj has two opcodes! */
23870 ZEND_VM_NEXT_OPCODE_EX(1, 2);
23871 }
23872
23873 /* 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)23874 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
23875 {
23876 USE_OPLINE
23877 zval *object, *value, tmp;
23878 zend_object *zobj;
23879 zend_string *name, *tmp_name;
23880 zend_refcounted *garbage = NULL;
23881
23882 SAVE_OPLINE();
23883 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
23884 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
23885
23886 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
23887 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
23888 object = Z_REFVAL_P(object);
23889 goto assign_object;
23890 }
23891 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
23892 value = &EG(uninitialized_zval);
23893 goto free_and_exit_assign_obj;
23894 }
23895
23896 assign_object:
23897 zobj = Z_OBJ_P(object);
23898 if (IS_CONST == IS_CONST) {
23899 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
23900 void **cache_slot = CACHE_ADDR(opline->extended_value);
23901 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
23902 zval *property_val;
23903
23904 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
23905 property_val = OBJ_PROP(zobj, prop_offset);
23906 if (Z_TYPE_P(property_val) != IS_UNDEF) {
23907 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
23908
23909 if (prop_info != NULL) {
23910 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
23911 goto free_and_exit_assign_obj;
23912 } else {
23913 fast_assign_obj:
23914 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
23915 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23916 ZVAL_COPY(EX_VAR(opline->result.var), value);
23917 }
23918 goto exit_assign_obj;
23919 }
23920 }
23921 } else {
23922 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23923 if (EXPECTED(zobj->properties != NULL)) {
23924 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
23925 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
23926 GC_DELREF(zobj->properties);
23927 }
23928 zobj->properties = zend_array_dup(zobj->properties);
23929 }
23930 property_val = zend_hash_find_known_hash(zobj->properties, name);
23931 if (property_val) {
23932 goto fast_assign_obj;
23933 }
23934 }
23935
23936 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
23937 if (EXPECTED(zobj->properties == NULL)) {
23938 rebuild_object_properties(zobj);
23939 }
23940 if (IS_CV == IS_CONST) {
23941 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
23942 Z_ADDREF_P(value);
23943 }
23944 } else if (IS_CV != IS_TMP_VAR) {
23945 if (Z_ISREF_P(value)) {
23946 if (IS_CV == IS_VAR) {
23947 zend_reference *ref = Z_REF_P(value);
23948 if (GC_DELREF(ref) == 0) {
23949 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
23950 efree_size(ref, sizeof(zend_reference));
23951 value = &tmp;
23952 } else {
23953 value = Z_REFVAL_P(value);
23954 Z_TRY_ADDREF_P(value);
23955 }
23956 } else {
23957 value = Z_REFVAL_P(value);
23958 Z_TRY_ADDREF_P(value);
23959 }
23960 } else if (IS_CV == IS_CV) {
23961 Z_TRY_ADDREF_P(value);
23962 }
23963 }
23964 zend_hash_add_new(zobj->properties, name, value);
23965 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
23966 ZVAL_COPY(EX_VAR(opline->result.var), value);
23967 }
23968 goto exit_assign_obj;
23969 }
23970 }
23971 }
23972 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
23973 } else {
23974 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
23975 if (UNEXPECTED(!name)) {
23976
23977 UNDEF_RESULT();
23978 goto exit_assign_obj;
23979 }
23980 }
23981
23982 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
23983 ZVAL_DEREF(value);
23984 }
23985
23986 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
23987
23988 if (IS_CONST != IS_CONST) {
23989 zend_tmp_string_release(tmp_name);
23990 }
23991
23992 free_and_exit_assign_obj:
23993 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
23994 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
23995 }
23996
23997 exit_assign_obj:
23998 if (garbage) {
23999 GC_DTOR_NO_REF(garbage);
24000 }
24001
24002 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24003 /* assign_obj has two opcodes! */
24004 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24005 }
24006
24007 /* 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)24008 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24009 {
24010 USE_OPLINE
24011 zval *object_ptr, *orig_object_ptr;
24012 zval *value;
24013 zval *variable_ptr;
24014 zval *dim;
24015 zend_refcounted *garbage = NULL;
24016
24017 SAVE_OPLINE();
24018 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24019
24020 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24021 try_assign_dim_array:
24022 SEPARATE_ARRAY(object_ptr);
24023 if (IS_CONST == IS_UNUSED) {
24024 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24025 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24026 HashTable *ht = Z_ARRVAL_P(object_ptr);
24027 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24028 GC_ADDREF(ht);
24029 }
24030 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24031 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24032 zend_array_destroy(ht);
24033 goto assign_dim_error;
24034 }
24035 }
24036 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
24037 ZVAL_DEREF(value);
24038 }
24039 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24040 if (UNEXPECTED(value == NULL)) {
24041 zend_cannot_add_element();
24042 goto assign_dim_error;
24043 } else if (IS_CONST == IS_CV) {
24044 if (Z_REFCOUNTED_P(value)) {
24045 Z_ADDREF_P(value);
24046 }
24047 } else if (IS_CONST == IS_VAR) {
24048 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24049 if (Z_ISREF_P(free_op_data)) {
24050 if (Z_REFCOUNTED_P(value)) {
24051 Z_ADDREF_P(value);
24052 }
24053 zval_ptr_dtor_nogc(free_op_data);
24054 }
24055 } else if (IS_CONST == IS_CONST) {
24056 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24057 Z_ADDREF_P(value);
24058 }
24059 }
24060 } else {
24061 dim = RT_CONSTANT(opline, opline->op2);
24062 if (IS_CONST == IS_CONST) {
24063 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24064 } else {
24065 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24066 }
24067 if (UNEXPECTED(variable_ptr == NULL)) {
24068 goto assign_dim_error;
24069 }
24070 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24071 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24072 }
24073 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24074 ZVAL_COPY(EX_VAR(opline->result.var), value);
24075 }
24076 if (garbage) {
24077 GC_DTOR_NO_REF(garbage);
24078 }
24079 } else {
24080 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24081 object_ptr = Z_REFVAL_P(object_ptr);
24082 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24083 goto try_assign_dim_array;
24084 }
24085 }
24086 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24087 zend_object *obj = Z_OBJ_P(object_ptr);
24088
24089 GC_ADDREF(obj);
24090 dim = RT_CONSTANT(opline, opline->op2);
24091 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24092 dim = ZVAL_UNDEFINED_OP2();
24093 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24094 dim++;
24095 }
24096
24097 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24098 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24099 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24100 } else if (IS_CONST & (IS_CV|IS_VAR)) {
24101 ZVAL_DEREF(value);
24102 }
24103
24104 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24105
24106 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24107 zend_objects_store_del(obj);
24108 }
24109 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24110 if (IS_CONST == IS_UNUSED) {
24111 zend_use_new_element_for_string();
24112
24113 UNDEF_RESULT();
24114 } else {
24115 dim = RT_CONSTANT(opline, opline->op2);
24116 value = RT_CONSTANT((opline+1), (opline+1)->op1);
24117 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24118
24119 }
24120 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24121 if (Z_ISREF_P(orig_object_ptr)
24122 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24123 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24124 dim = RT_CONSTANT(opline, opline->op2);
24125
24126 UNDEF_RESULT();
24127 } else {
24128 HashTable *ht = zend_new_array(8);
24129 uint8_t old_type = Z_TYPE_P(object_ptr);
24130
24131 ZVAL_ARR(object_ptr, ht);
24132 if (UNEXPECTED(old_type == IS_FALSE)) {
24133 GC_ADDREF(ht);
24134 zend_false_to_array_deprecated();
24135 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24136 zend_array_destroy(ht);
24137 goto assign_dim_error;
24138 }
24139 }
24140 goto try_assign_dim_array;
24141 }
24142 } else {
24143 zend_use_scalar_as_array();
24144 dim = RT_CONSTANT(opline, opline->op2);
24145 assign_dim_error:
24146
24147 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24148 ZVAL_NULL(EX_VAR(opline->result.var));
24149 }
24150 }
24151 }
24152 if (IS_CONST != IS_UNUSED) {
24153
24154 }
24155 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24156 /* assign_dim has two opcodes! */
24157 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24158 }
24159
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24160 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24161 {
24162 USE_OPLINE
24163 zval *object_ptr, *orig_object_ptr;
24164 zval *value;
24165 zval *variable_ptr;
24166 zval *dim;
24167 zend_refcounted *garbage = NULL;
24168
24169 SAVE_OPLINE();
24170 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24171
24172 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24173 try_assign_dim_array:
24174 SEPARATE_ARRAY(object_ptr);
24175 if (IS_CONST == IS_UNUSED) {
24176 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24177 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24178 HashTable *ht = Z_ARRVAL_P(object_ptr);
24179 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24180 GC_ADDREF(ht);
24181 }
24182 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24183 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24184 zend_array_destroy(ht);
24185 goto assign_dim_error;
24186 }
24187 }
24188 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
24189 ZVAL_DEREF(value);
24190 }
24191 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24192 if (UNEXPECTED(value == NULL)) {
24193 zend_cannot_add_element();
24194 goto assign_dim_error;
24195 } else if (IS_TMP_VAR == IS_CV) {
24196 if (Z_REFCOUNTED_P(value)) {
24197 Z_ADDREF_P(value);
24198 }
24199 } else if (IS_TMP_VAR == IS_VAR) {
24200 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24201 if (Z_ISREF_P(free_op_data)) {
24202 if (Z_REFCOUNTED_P(value)) {
24203 Z_ADDREF_P(value);
24204 }
24205 zval_ptr_dtor_nogc(free_op_data);
24206 }
24207 } else if (IS_TMP_VAR == IS_CONST) {
24208 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24209 Z_ADDREF_P(value);
24210 }
24211 }
24212 } else {
24213 dim = RT_CONSTANT(opline, opline->op2);
24214 if (IS_CONST == IS_CONST) {
24215 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24216 } else {
24217 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24218 }
24219 if (UNEXPECTED(variable_ptr == NULL)) {
24220 goto assign_dim_error;
24221 }
24222 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24223 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
24224 }
24225 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24226 ZVAL_COPY(EX_VAR(opline->result.var), value);
24227 }
24228 if (garbage) {
24229 GC_DTOR_NO_REF(garbage);
24230 }
24231 } else {
24232 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24233 object_ptr = Z_REFVAL_P(object_ptr);
24234 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24235 goto try_assign_dim_array;
24236 }
24237 }
24238 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24239 zend_object *obj = Z_OBJ_P(object_ptr);
24240
24241 GC_ADDREF(obj);
24242 dim = RT_CONSTANT(opline, opline->op2);
24243 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24244 dim = ZVAL_UNDEFINED_OP2();
24245 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24246 dim++;
24247 }
24248
24249 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24250 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24251 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24252 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
24253 ZVAL_DEREF(value);
24254 }
24255
24256 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24257
24258 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24259 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24260 zend_objects_store_del(obj);
24261 }
24262 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24263 if (IS_CONST == IS_UNUSED) {
24264 zend_use_new_element_for_string();
24265 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24266 UNDEF_RESULT();
24267 } else {
24268 dim = RT_CONSTANT(opline, opline->op2);
24269 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
24270 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24271 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24272 }
24273 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24274 if (Z_ISREF_P(orig_object_ptr)
24275 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24276 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24277 dim = RT_CONSTANT(opline, opline->op2);
24278 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24279 UNDEF_RESULT();
24280 } else {
24281 HashTable *ht = zend_new_array(8);
24282 uint8_t old_type = Z_TYPE_P(object_ptr);
24283
24284 ZVAL_ARR(object_ptr, ht);
24285 if (UNEXPECTED(old_type == IS_FALSE)) {
24286 GC_ADDREF(ht);
24287 zend_false_to_array_deprecated();
24288 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24289 zend_array_destroy(ht);
24290 goto assign_dim_error;
24291 }
24292 }
24293 goto try_assign_dim_array;
24294 }
24295 } else {
24296 zend_use_scalar_as_array();
24297 dim = RT_CONSTANT(opline, opline->op2);
24298 assign_dim_error:
24299 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24300 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24301 ZVAL_NULL(EX_VAR(opline->result.var));
24302 }
24303 }
24304 }
24305 if (IS_CONST != IS_UNUSED) {
24306
24307 }
24308 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24309 /* assign_dim has two opcodes! */
24310 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24311 }
24312
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24313 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24314 {
24315 USE_OPLINE
24316 zval *object_ptr, *orig_object_ptr;
24317 zval *value;
24318 zval *variable_ptr;
24319 zval *dim;
24320 zend_refcounted *garbage = NULL;
24321
24322 SAVE_OPLINE();
24323 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24324
24325 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24326 try_assign_dim_array:
24327 SEPARATE_ARRAY(object_ptr);
24328 if (IS_CONST == IS_UNUSED) {
24329 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24330 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24331 HashTable *ht = Z_ARRVAL_P(object_ptr);
24332 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24333 GC_ADDREF(ht);
24334 }
24335 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24336 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24337 zend_array_destroy(ht);
24338 goto assign_dim_error;
24339 }
24340 }
24341 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
24342 ZVAL_DEREF(value);
24343 }
24344 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24345 if (UNEXPECTED(value == NULL)) {
24346 zend_cannot_add_element();
24347 goto assign_dim_error;
24348 } else if (IS_VAR == IS_CV) {
24349 if (Z_REFCOUNTED_P(value)) {
24350 Z_ADDREF_P(value);
24351 }
24352 } else if (IS_VAR == IS_VAR) {
24353 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24354 if (Z_ISREF_P(free_op_data)) {
24355 if (Z_REFCOUNTED_P(value)) {
24356 Z_ADDREF_P(value);
24357 }
24358 zval_ptr_dtor_nogc(free_op_data);
24359 }
24360 } else if (IS_VAR == IS_CONST) {
24361 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24362 Z_ADDREF_P(value);
24363 }
24364 }
24365 } else {
24366 dim = RT_CONSTANT(opline, opline->op2);
24367 if (IS_CONST == IS_CONST) {
24368 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24369 } else {
24370 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24371 }
24372 if (UNEXPECTED(variable_ptr == NULL)) {
24373 goto assign_dim_error;
24374 }
24375 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24376 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
24377 }
24378 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24379 ZVAL_COPY(EX_VAR(opline->result.var), value);
24380 }
24381 if (garbage) {
24382 GC_DTOR_NO_REF(garbage);
24383 }
24384 } else {
24385 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24386 object_ptr = Z_REFVAL_P(object_ptr);
24387 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24388 goto try_assign_dim_array;
24389 }
24390 }
24391 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24392 zend_object *obj = Z_OBJ_P(object_ptr);
24393
24394 GC_ADDREF(obj);
24395 dim = RT_CONSTANT(opline, opline->op2);
24396 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24397 dim = ZVAL_UNDEFINED_OP2();
24398 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24399 dim++;
24400 }
24401
24402 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24403 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24404 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24405 } else if (IS_VAR & (IS_CV|IS_VAR)) {
24406 ZVAL_DEREF(value);
24407 }
24408
24409 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24410
24411 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24412 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24413 zend_objects_store_del(obj);
24414 }
24415 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24416 if (IS_CONST == IS_UNUSED) {
24417 zend_use_new_element_for_string();
24418 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24419 UNDEF_RESULT();
24420 } else {
24421 dim = RT_CONSTANT(opline, opline->op2);
24422 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24423 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24424 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24425 }
24426 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24427 if (Z_ISREF_P(orig_object_ptr)
24428 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24429 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24430 dim = RT_CONSTANT(opline, opline->op2);
24431 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24432 UNDEF_RESULT();
24433 } else {
24434 HashTable *ht = zend_new_array(8);
24435 uint8_t old_type = Z_TYPE_P(object_ptr);
24436
24437 ZVAL_ARR(object_ptr, ht);
24438 if (UNEXPECTED(old_type == IS_FALSE)) {
24439 GC_ADDREF(ht);
24440 zend_false_to_array_deprecated();
24441 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24442 zend_array_destroy(ht);
24443 goto assign_dim_error;
24444 }
24445 }
24446 goto try_assign_dim_array;
24447 }
24448 } else {
24449 zend_use_scalar_as_array();
24450 dim = RT_CONSTANT(opline, opline->op2);
24451 assign_dim_error:
24452 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24453 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24454 ZVAL_NULL(EX_VAR(opline->result.var));
24455 }
24456 }
24457 }
24458 if (IS_CONST != IS_UNUSED) {
24459
24460 }
24461 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24462 /* assign_dim has two opcodes! */
24463 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24464 }
24465
ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24466 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24467 {
24468 USE_OPLINE
24469 zval *object_ptr, *orig_object_ptr;
24470 zval *value;
24471 zval *variable_ptr;
24472 zval *dim;
24473 zend_refcounted *garbage = NULL;
24474
24475 SAVE_OPLINE();
24476 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24477
24478 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24479 try_assign_dim_array:
24480 SEPARATE_ARRAY(object_ptr);
24481 if (IS_CONST == IS_UNUSED) {
24482 value = EX_VAR((opline+1)->op1.var);
24483 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
24484 HashTable *ht = Z_ARRVAL_P(object_ptr);
24485 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
24486 GC_ADDREF(ht);
24487 }
24488 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24489 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
24490 zend_array_destroy(ht);
24491 goto assign_dim_error;
24492 }
24493 }
24494 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
24495 ZVAL_DEREF(value);
24496 }
24497 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
24498 if (UNEXPECTED(value == NULL)) {
24499 zend_cannot_add_element();
24500 goto assign_dim_error;
24501 } else if (IS_CV == IS_CV) {
24502 if (Z_REFCOUNTED_P(value)) {
24503 Z_ADDREF_P(value);
24504 }
24505 } else if (IS_CV == IS_VAR) {
24506 zval *free_op_data = EX_VAR((opline+1)->op1.var);
24507 if (Z_ISREF_P(free_op_data)) {
24508 if (Z_REFCOUNTED_P(value)) {
24509 Z_ADDREF_P(value);
24510 }
24511 zval_ptr_dtor_nogc(free_op_data);
24512 }
24513 } else if (IS_CV == IS_CONST) {
24514 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
24515 Z_ADDREF_P(value);
24516 }
24517 }
24518 } else {
24519 dim = RT_CONSTANT(opline, opline->op2);
24520 if (IS_CONST == IS_CONST) {
24521 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24522 } else {
24523 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
24524 }
24525 if (UNEXPECTED(variable_ptr == NULL)) {
24526 goto assign_dim_error;
24527 }
24528 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
24529 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
24530 }
24531 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24532 ZVAL_COPY(EX_VAR(opline->result.var), value);
24533 }
24534 if (garbage) {
24535 GC_DTOR_NO_REF(garbage);
24536 }
24537 } else {
24538 if (EXPECTED(Z_ISREF_P(object_ptr))) {
24539 object_ptr = Z_REFVAL_P(object_ptr);
24540 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
24541 goto try_assign_dim_array;
24542 }
24543 }
24544 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
24545 zend_object *obj = Z_OBJ_P(object_ptr);
24546
24547 GC_ADDREF(obj);
24548 dim = RT_CONSTANT(opline, opline->op2);
24549 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
24550 dim = ZVAL_UNDEFINED_OP2();
24551 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
24552 dim++;
24553 }
24554
24555 value = EX_VAR((opline+1)->op1.var);
24556 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
24557 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
24558 } else if (IS_CV & (IS_CV|IS_VAR)) {
24559 ZVAL_DEREF(value);
24560 }
24561
24562 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
24563
24564 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
24565 zend_objects_store_del(obj);
24566 }
24567 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
24568 if (IS_CONST == IS_UNUSED) {
24569 zend_use_new_element_for_string();
24570
24571 UNDEF_RESULT();
24572 } else {
24573 dim = RT_CONSTANT(opline, opline->op2);
24574 value = EX_VAR((opline+1)->op1.var);
24575 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
24576
24577 }
24578 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
24579 if (Z_ISREF_P(orig_object_ptr)
24580 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
24581 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
24582 dim = RT_CONSTANT(opline, opline->op2);
24583
24584 UNDEF_RESULT();
24585 } else {
24586 HashTable *ht = zend_new_array(8);
24587 uint8_t old_type = Z_TYPE_P(object_ptr);
24588
24589 ZVAL_ARR(object_ptr, ht);
24590 if (UNEXPECTED(old_type == IS_FALSE)) {
24591 GC_ADDREF(ht);
24592 zend_false_to_array_deprecated();
24593 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
24594 zend_array_destroy(ht);
24595 goto assign_dim_error;
24596 }
24597 }
24598 goto try_assign_dim_array;
24599 }
24600 } else {
24601 zend_use_scalar_as_array();
24602 dim = RT_CONSTANT(opline, opline->op2);
24603 assign_dim_error:
24604
24605 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
24606 ZVAL_NULL(EX_VAR(opline->result.var));
24607 }
24608 }
24609 }
24610 if (IS_CONST != IS_UNUSED) {
24611
24612 }
24613 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24614 /* assign_dim has two opcodes! */
24615 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24616 }
24617
ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24618 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24619 {
24620 USE_OPLINE
24621 zval *value;
24622 zval *variable_ptr;
24623
24624 SAVE_OPLINE();
24625 value = RT_CONSTANT(opline, opline->op2);
24626 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24627
24628 if (0 || UNEXPECTED(0)) {
24629 zend_refcounted *garbage = NULL;
24630
24631 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24632 if (UNEXPECTED(0)) {
24633 ZVAL_COPY(EX_VAR(opline->result.var), value);
24634 }
24635 if (garbage) {
24636 GC_DTOR_NO_REF(garbage);
24637 }
24638 } else {
24639 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
24640 }
24641 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24642 /* zend_assign_to_variable() always takes care of op2, never free it! */
24643
24644 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24645 }
24646
ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24647 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24648 {
24649 USE_OPLINE
24650 zval *value;
24651 zval *variable_ptr;
24652
24653 SAVE_OPLINE();
24654 value = RT_CONSTANT(opline, opline->op2);
24655 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24656
24657 if (0 || UNEXPECTED(1)) {
24658 zend_refcounted *garbage = NULL;
24659
24660 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
24661 if (UNEXPECTED(1)) {
24662 ZVAL_COPY(EX_VAR(opline->result.var), value);
24663 }
24664 if (garbage) {
24665 GC_DTOR_NO_REF(garbage);
24666 }
24667 } else {
24668 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
24669 }
24670 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24671 /* zend_assign_to_variable() always takes care of op2, never free it! */
24672
24673 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24674 }
24675
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24676 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24677 {
24678 USE_OPLINE
24679 zval *property, *container, *value_ptr;
24680
24681 SAVE_OPLINE();
24682
24683 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24684 property = RT_CONSTANT(opline, opline->op2);
24685
24686 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
24687
24688 if (1) {
24689 if (IS_VAR == IS_UNUSED) {
24690 if (IS_CONST == IS_CONST) {
24691 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24692 } else {
24693 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24694 }
24695 } else {
24696 if (IS_CONST == IS_CONST) {
24697 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24698 } else {
24699 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24700 }
24701 }
24702 } else {
24703 zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24704 }
24705
24706 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24707
24708 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
24709 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24710 }
24711
24712 /* 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)24713 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24714 {
24715 USE_OPLINE
24716 zval *property, *container, *value_ptr;
24717
24718 SAVE_OPLINE();
24719
24720 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24721 property = RT_CONSTANT(opline, opline->op2);
24722
24723 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
24724
24725 if (1) {
24726 if (IS_VAR == IS_UNUSED) {
24727 if (IS_CONST == IS_CONST) {
24728 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24729 } else {
24730 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24731 }
24732 } else {
24733 if (IS_CONST == IS_CONST) {
24734 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24735 } else {
24736 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24737 }
24738 }
24739 } else {
24740 zend_assign_to_property_reference(container, IS_VAR, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
24741 }
24742
24743 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24744
24745
24746 ZEND_VM_NEXT_OPCODE_EX(1, 2);
24747 }
24748
24749 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24750 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24751 {
24752 USE_OPLINE
24753 zval *function_name;
24754 zend_class_entry *ce;
24755 uint32_t call_info;
24756 zend_function *fbc;
24757 zend_execute_data *call;
24758
24759 SAVE_OPLINE();
24760
24761 if (IS_VAR == IS_CONST) {
24762 /* no function found. try a static method in class */
24763 ce = CACHED_PTR(opline->result.num);
24764 if (UNEXPECTED(ce == NULL)) {
24765 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);
24766 if (UNEXPECTED(ce == NULL)) {
24767
24768 HANDLE_EXCEPTION();
24769 }
24770 if (IS_CONST != IS_CONST) {
24771 CACHE_PTR(opline->result.num, ce);
24772 }
24773 }
24774 } else if (IS_VAR == IS_UNUSED) {
24775 ce = zend_fetch_class(NULL, opline->op1.num);
24776 if (UNEXPECTED(ce == NULL)) {
24777
24778 HANDLE_EXCEPTION();
24779 }
24780 } else {
24781 ce = Z_CE_P(EX_VAR(opline->op1.var));
24782 }
24783
24784 if (IS_VAR == IS_CONST &&
24785 IS_CONST == IS_CONST &&
24786 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
24787 /* nothing to do */
24788 } else if (IS_VAR != IS_CONST &&
24789 IS_CONST == IS_CONST &&
24790 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
24791 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
24792 } else if (IS_CONST != IS_UNUSED) {
24793 function_name = RT_CONSTANT(opline, opline->op2);
24794 if (IS_CONST != IS_CONST) {
24795 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
24796 do {
24797 if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
24798 function_name = Z_REFVAL_P(function_name);
24799 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
24800 break;
24801 }
24802 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
24803 ZVAL_UNDEFINED_OP2();
24804 if (UNEXPECTED(EG(exception) != NULL)) {
24805 HANDLE_EXCEPTION();
24806 }
24807 }
24808 zend_throw_error(NULL, "Method name must be a string");
24809
24810 HANDLE_EXCEPTION();
24811 } while (0);
24812 }
24813 }
24814
24815 if (ce->get_static_method) {
24816 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
24817 } else {
24818 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
24819 }
24820 if (UNEXPECTED(fbc == NULL)) {
24821 if (EXPECTED(!EG(exception))) {
24822 zend_undefined_method(ce, Z_STR_P(function_name));
24823 }
24824
24825 HANDLE_EXCEPTION();
24826 }
24827 if (IS_CONST == IS_CONST &&
24828 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
24829 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
24830 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
24831 }
24832 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
24833 init_func_run_time_cache(&fbc->op_array);
24834 }
24835 if (IS_CONST != IS_CONST) {
24836
24837 }
24838 } else {
24839 if (UNEXPECTED(ce->constructor == NULL)) {
24840 zend_throw_error(NULL, "Cannot call constructor");
24841 HANDLE_EXCEPTION();
24842 }
24843 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
24844 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
24845 HANDLE_EXCEPTION();
24846 }
24847 fbc = ce->constructor;
24848 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
24849 init_func_run_time_cache(&fbc->op_array);
24850 }
24851 }
24852
24853 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
24854 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
24855 ce = (zend_class_entry*)Z_OBJ(EX(This));
24856 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
24857 } else {
24858 zend_non_static_method_call(fbc);
24859 HANDLE_EXCEPTION();
24860 }
24861 } else {
24862 /* previous opcode is ZEND_FETCH_CLASS */
24863 if (IS_VAR == IS_UNUSED
24864 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
24865 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
24866 if (Z_TYPE(EX(This)) == IS_OBJECT) {
24867 ce = Z_OBJCE(EX(This));
24868 } else {
24869 ce = Z_CE(EX(This));
24870 }
24871 }
24872 call_info = ZEND_CALL_NESTED_FUNCTION;
24873 }
24874
24875 call = zend_vm_stack_push_call_frame(call_info,
24876 fbc, opline->extended_value, ce);
24877 call->prev_execute_data = EX(call);
24878 EX(call) = call;
24879
24880 ZEND_VM_NEXT_OPCODE();
24881 }
24882
ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24883 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24884 {
24885 USE_OPLINE
24886 zval *varptr, *arg;
24887
24888 if (IS_CONST == IS_CONST) {
24889 SAVE_OPLINE();
24890 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24891 uint32_t arg_num;
24892 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
24893 if (UNEXPECTED(!arg)) {
24894 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24895 HANDLE_EXCEPTION();
24896 }
24897 } else {
24898 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
24899 }
24900
24901 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24902 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
24903 SAVE_OPLINE();
24904 ZVAL_UNDEFINED_OP1();
24905 ZVAL_NULL(arg);
24906 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24907 }
24908
24909 if (IS_VAR == IS_CV) {
24910 ZVAL_COPY_DEREF(arg, varptr);
24911 } else /* if (IS_VAR == IS_VAR) */ {
24912 if (UNEXPECTED(Z_ISREF_P(varptr))) {
24913 zend_refcounted *ref = Z_COUNTED_P(varptr);
24914
24915 varptr = Z_REFVAL_P(varptr);
24916 ZVAL_COPY_VALUE(arg, varptr);
24917 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
24918 efree_size(ref, sizeof(zend_reference));
24919 } else if (Z_OPT_REFCOUNTED_P(arg)) {
24920 Z_ADDREF_P(arg);
24921 }
24922 } else {
24923 ZVAL_COPY_VALUE(arg, varptr);
24924 }
24925 }
24926
24927 ZEND_VM_NEXT_OPCODE();
24928 }
24929
ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24930 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24931 {
24932 USE_OPLINE
24933 zval *varptr, *arg;
24934
24935 if (IS_CONST == IS_CONST) {
24936 SAVE_OPLINE();
24937 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24938 uint32_t arg_num;
24939 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
24940 if (UNEXPECTED(!arg)) {
24941 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24942 HANDLE_EXCEPTION();
24943 }
24944 } else {
24945 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
24946 }
24947
24948 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24949 ZVAL_COPY_VALUE(arg, varptr);
24950
24951 if (EXPECTED(Z_ISREF_P(varptr))) {
24952 ZEND_VM_NEXT_OPCODE();
24953 }
24954
24955 SAVE_OPLINE();
24956 ZVAL_NEW_REF(arg, arg);
24957 zend_error(E_NOTICE, "Only variables should be passed by reference");
24958 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
24959 }
24960
ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)24961 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
24962 {
24963 USE_OPLINE
24964 zval *varptr, *arg;
24965 uint32_t arg_num;
24966
24967 if (IS_CONST == IS_CONST) {
24968 SAVE_OPLINE();
24969 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
24970 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
24971 if (UNEXPECTED(!arg)) {
24972 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
24973 HANDLE_EXCEPTION();
24974 }
24975 } else {
24976 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
24977 arg_num = opline->op2.num;
24978 }
24979
24980 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
24981 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
24982 goto send_var;
24983 }
24984
24985 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24986 ZVAL_COPY_VALUE(arg, varptr);
24987
24988 if (EXPECTED(Z_ISREF_P(varptr) ||
24989 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
24990 ZEND_VM_NEXT_OPCODE();
24991 }
24992 } else {
24993 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
24994 goto send_var;
24995 }
24996
24997 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
24998 ZVAL_COPY_VALUE(arg, varptr);
24999
25000 if (EXPECTED(Z_ISREF_P(varptr) ||
25001 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
25002 ZEND_VM_NEXT_OPCODE();
25003 }
25004 }
25005
25006 SAVE_OPLINE();
25007 ZVAL_NEW_REF(arg, arg);
25008 zend_error(E_NOTICE, "Only variables should be passed by reference");
25009 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25010
25011 send_var:
25012 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25013 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25014 zend_refcounted *ref = Z_COUNTED_P(varptr);
25015
25016 varptr = Z_REFVAL_P(varptr);
25017 ZVAL_COPY_VALUE(arg, varptr);
25018 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25019 efree_size(ref, sizeof(zend_reference));
25020 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25021 Z_ADDREF_P(arg);
25022 }
25023 } else {
25024 ZVAL_COPY_VALUE(arg, varptr);
25025 }
25026 ZEND_VM_NEXT_OPCODE();
25027 }
25028
ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25029 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25030 {
25031 USE_OPLINE
25032 zval *varptr, *arg;
25033
25034 SAVE_OPLINE();
25035 if (IS_CONST == IS_CONST) {
25036 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25037 uint32_t arg_num;
25038 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25039 if (UNEXPECTED(!arg)) {
25040 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25041 HANDLE_EXCEPTION();
25042 }
25043 } else {
25044 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25045 }
25046
25047 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25048 if (Z_ISREF_P(varptr)) {
25049 Z_ADDREF_P(varptr);
25050 } else {
25051 ZVAL_MAKE_REF_EX(varptr, 2);
25052 }
25053 ZVAL_REF(arg, Z_REF_P(varptr));
25054
25055 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25056 ZEND_VM_NEXT_OPCODE();
25057 }
25058
ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25059 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25060 {
25061 USE_OPLINE
25062 zval *varptr, *arg;
25063 uint32_t arg_num;
25064
25065 if (IS_CONST == IS_CONST) {
25066 SAVE_OPLINE();
25067 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25068 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25069 if (UNEXPECTED(!arg)) {
25070 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25071 HANDLE_EXCEPTION();
25072 }
25073 } else {
25074 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25075 arg_num = opline->op2.num;
25076 }
25077
25078 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
25079 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25080 goto send_var_by_ref;
25081 }
25082 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
25083 send_var_by_ref:
25084 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25085 if (Z_ISREF_P(varptr)) {
25086 Z_ADDREF_P(varptr);
25087 } else {
25088 ZVAL_MAKE_REF_EX(varptr, 2);
25089 }
25090 ZVAL_REF(arg, Z_REF_P(varptr));
25091
25092 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25093 ZEND_VM_NEXT_OPCODE();
25094 }
25095
25096 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25097 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
25098 SAVE_OPLINE();
25099 ZVAL_UNDEFINED_OP1();
25100 ZVAL_NULL(arg);
25101 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25102 }
25103
25104 if (IS_VAR == IS_CV) {
25105 ZVAL_COPY_DEREF(arg, varptr);
25106 } else /* if (IS_VAR == IS_VAR) */ {
25107 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25108 zend_refcounted *ref = Z_COUNTED_P(varptr);
25109
25110 varptr = Z_REFVAL_P(varptr);
25111 ZVAL_COPY_VALUE(arg, varptr);
25112 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25113 efree_size(ref, sizeof(zend_reference));
25114 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25115 Z_ADDREF_P(arg);
25116 }
25117 } else {
25118 ZVAL_COPY_VALUE(arg, varptr);
25119 }
25120 }
25121
25122 ZEND_VM_NEXT_OPCODE();
25123 }
25124
ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25125 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25126 {
25127 USE_OPLINE
25128 zval *varptr, *arg;
25129
25130 if (IS_CONST == IS_CONST) {
25131 // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
25132 SAVE_OPLINE();
25133 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
25134 uint32_t arg_num;
25135 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
25136 if (UNEXPECTED(!arg)) {
25137 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25138 HANDLE_EXCEPTION();
25139 }
25140 } else {
25141 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
25142 }
25143
25144 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
25145 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25146 if (Z_ISREF_P(varptr)) {
25147 Z_ADDREF_P(varptr);
25148 } else {
25149 ZVAL_MAKE_REF_EX(varptr, 2);
25150 }
25151 ZVAL_REF(arg, Z_REF_P(varptr));
25152
25153 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25154 ZEND_VM_NEXT_OPCODE();
25155 }
25156
25157 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25158
25159 if (UNEXPECTED(Z_ISREF_P(varptr))) {
25160 zend_refcounted *ref = Z_COUNTED_P(varptr);
25161
25162 varptr = Z_REFVAL_P(varptr);
25163 ZVAL_COPY_VALUE(arg, varptr);
25164 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25165 efree_size(ref, sizeof(zend_reference));
25166 } else if (Z_OPT_REFCOUNTED_P(arg)) {
25167 Z_ADDREF_P(arg);
25168 }
25169 } else {
25170 ZVAL_COPY_VALUE(arg, varptr);
25171 }
25172
25173 ZEND_VM_NEXT_OPCODE();
25174 }
25175
ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25176 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25177 {
25178 zend_class_entry *ce, *scope;
25179 zend_class_constant *c;
25180 zval *value, *zv, *constant_zv;
25181 zend_string *constant_name;
25182 USE_OPLINE
25183
25184 SAVE_OPLINE();
25185
25186 do {
25187 if (IS_VAR == IS_CONST && IS_CONST == IS_CONST) {
25188 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
25189 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25190 break;
25191 }
25192 }
25193 if (IS_VAR == IS_CONST) {
25194 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
25195 ce = CACHED_PTR(opline->extended_value);
25196 } else {
25197 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);
25198 if (UNEXPECTED(ce == NULL)) {
25199 ZVAL_UNDEF(EX_VAR(opline->result.var));
25200
25201 HANDLE_EXCEPTION();
25202 }
25203 CACHE_PTR(opline->extended_value, ce);
25204 }
25205 } else if (IS_VAR == IS_UNUSED) {
25206 ce = zend_fetch_class(NULL, opline->op1.num);
25207 if (UNEXPECTED(ce == NULL)) {
25208 ZVAL_UNDEF(EX_VAR(opline->result.var));
25209
25210 HANDLE_EXCEPTION();
25211 }
25212 } else {
25213 ce = Z_CE_P(EX_VAR(opline->op1.var));
25214 }
25215 if (IS_VAR != IS_CONST
25216 && IS_CONST == IS_CONST
25217 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
25218 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25219 break;
25220 }
25221
25222 constant_zv = RT_CONSTANT(opline, opline->op2);
25223 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
25224 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
25225 ZVAL_UNDEF(EX_VAR(opline->result.var));
25226
25227 HANDLE_EXCEPTION();
25228 }
25229 constant_name = Z_STR_P(constant_zv);
25230 /* Magic 'class' for constant OP2 is caught at compile-time */
25231 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
25232 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
25233
25234 ZEND_VM_NEXT_OPCODE();
25235 }
25236 zv = IS_CONST == IS_CONST
25237 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
25238 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
25239
25240 if (EXPECTED(zv != NULL)) {
25241 c = Z_PTR_P(zv);
25242 scope = EX(func)->op_array.scope;
25243 if (!zend_verify_const_access(c, scope)) {
25244 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));
25245 ZVAL_UNDEF(EX_VAR(opline->result.var));
25246
25247 HANDLE_EXCEPTION();
25248 }
25249
25250 if (ce->ce_flags & ZEND_ACC_TRAIT) {
25251 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25252 ZVAL_UNDEF(EX_VAR(opline->result.var));
25253
25254 HANDLE_EXCEPTION();
25255 }
25256
25257 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
25258 if (UNEXPECTED(is_constant_deprecated)) {
25259 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25260
25261 if (EG(exception)) {
25262 ZVAL_UNDEF(EX_VAR(opline->result.var));
25263
25264 HANDLE_EXCEPTION();
25265 }
25266 }
25267
25268 value = &c->value;
25269 // Enums require loading of all class constants to build the backed enum table
25270 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)) {
25271 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
25272 ZVAL_UNDEF(EX_VAR(opline->result.var));
25273
25274 HANDLE_EXCEPTION();
25275 }
25276 }
25277 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
25278 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
25279 ZVAL_UNDEF(EX_VAR(opline->result.var));
25280
25281 HANDLE_EXCEPTION();
25282 }
25283 }
25284 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
25285 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
25286 }
25287 } else {
25288 zend_throw_error(NULL, "Undefined constant %s::%s",
25289 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25290 ZVAL_UNDEF(EX_VAR(opline->result.var));
25291
25292 HANDLE_EXCEPTION();
25293 }
25294 } while (0);
25295
25296 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
25297
25298 ZEND_VM_NEXT_OPCODE();
25299 }
25300
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25301 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25302 {
25303 USE_OPLINE
25304 zval *expr_ptr, new_expr;
25305
25306 SAVE_OPLINE();
25307 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
25308 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
25309 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25310 if (Z_ISREF_P(expr_ptr)) {
25311 Z_ADDREF_P(expr_ptr);
25312 } else {
25313 ZVAL_MAKE_REF_EX(expr_ptr, 2);
25314 }
25315 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25316 } else {
25317 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25318 if (IS_VAR == IS_TMP_VAR) {
25319 /* pass */
25320 } else if (IS_VAR == IS_CONST) {
25321 Z_TRY_ADDREF_P(expr_ptr);
25322 } else if (IS_VAR == IS_CV) {
25323 ZVAL_DEREF(expr_ptr);
25324 Z_TRY_ADDREF_P(expr_ptr);
25325 } else /* if (IS_VAR == IS_VAR) */ {
25326 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
25327 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
25328
25329 expr_ptr = Z_REFVAL_P(expr_ptr);
25330 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
25331 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
25332 expr_ptr = &new_expr;
25333 efree_size(ref, sizeof(zend_reference));
25334 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
25335 Z_ADDREF_P(expr_ptr);
25336 }
25337 }
25338 }
25339 }
25340
25341 if (IS_CONST != IS_UNUSED) {
25342 zval *offset = RT_CONSTANT(opline, opline->op2);
25343 zend_string *str;
25344 zend_ulong hval;
25345
25346 add_again:
25347 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
25348 str = Z_STR_P(offset);
25349 if (IS_CONST != IS_CONST) {
25350 if (ZEND_HANDLE_NUMERIC(str, hval)) {
25351 goto num_index;
25352 }
25353 }
25354 str_index:
25355 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
25356 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
25357 hval = Z_LVAL_P(offset);
25358 num_index:
25359 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
25360 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
25361 offset = Z_REFVAL_P(offset);
25362 goto add_again;
25363 } else if (Z_TYPE_P(offset) == IS_NULL) {
25364 str = ZSTR_EMPTY_ALLOC();
25365 goto str_index;
25366 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
25367 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
25368 goto num_index;
25369 } else if (Z_TYPE_P(offset) == IS_FALSE) {
25370 hval = 0;
25371 goto num_index;
25372 } else if (Z_TYPE_P(offset) == IS_TRUE) {
25373 hval = 1;
25374 goto num_index;
25375 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
25376 zend_use_resource_as_offset(offset);
25377 hval = Z_RES_HANDLE_P(offset);
25378 goto num_index;
25379 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
25380 ZVAL_UNDEFINED_OP2();
25381 str = ZSTR_EMPTY_ALLOC();
25382 goto str_index;
25383 } else {
25384 zend_illegal_array_offset_access(offset);
25385 zval_ptr_dtor_nogc(expr_ptr);
25386 }
25387
25388 } else {
25389 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
25390 zend_cannot_add_element();
25391 zval_ptr_dtor_nogc(expr_ptr);
25392 }
25393 }
25394 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25395 }
25396
ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25397 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25398 {
25399 zval *array;
25400 uint32_t size;
25401 USE_OPLINE
25402
25403 array = EX_VAR(opline->result.var);
25404 if (IS_VAR != IS_UNUSED) {
25405 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
25406 ZVAL_ARR(array, zend_new_array(size));
25407 /* Explicitly initialize array as not-packed if flag is set */
25408 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
25409 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
25410 }
25411 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
25412 } else {
25413 ZVAL_ARR(array, zend_new_array(0));
25414 ZEND_VM_NEXT_OPCODE();
25415 }
25416 }
25417
ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25418 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25419 {
25420 USE_OPLINE
25421 zval *container;
25422 zval *offset;
25423 zend_ulong hval;
25424 zend_string *key;
25425
25426 SAVE_OPLINE();
25427 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25428 offset = RT_CONSTANT(opline, opline->op2);
25429
25430 do {
25431 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
25432 HashTable *ht;
25433
25434 unset_dim_array:
25435 SEPARATE_ARRAY(container);
25436 ht = Z_ARRVAL_P(container);
25437 offset_again:
25438 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
25439 key = Z_STR_P(offset);
25440 if (IS_CONST != IS_CONST) {
25441 if (ZEND_HANDLE_NUMERIC(key, hval)) {
25442 goto num_index_dim;
25443 }
25444 }
25445 str_index_dim:
25446 ZEND_ASSERT(ht != &EG(symbol_table));
25447 zend_hash_del(ht, key);
25448 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
25449 hval = Z_LVAL_P(offset);
25450 num_index_dim:
25451 zend_hash_index_del(ht, hval);
25452 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
25453 offset = Z_REFVAL_P(offset);
25454 goto offset_again;
25455 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
25456 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
25457 goto num_index_dim;
25458 } else if (Z_TYPE_P(offset) == IS_NULL) {
25459 key = ZSTR_EMPTY_ALLOC();
25460 goto str_index_dim;
25461 } else if (Z_TYPE_P(offset) == IS_FALSE) {
25462 hval = 0;
25463 goto num_index_dim;
25464 } else if (Z_TYPE_P(offset) == IS_TRUE) {
25465 hval = 1;
25466 goto num_index_dim;
25467 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
25468 zend_use_resource_as_offset(offset);
25469 hval = Z_RES_HANDLE_P(offset);
25470 goto num_index_dim;
25471 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
25472 ZVAL_UNDEFINED_OP2();
25473 key = ZSTR_EMPTY_ALLOC();
25474 goto str_index_dim;
25475 } else {
25476 zend_illegal_array_offset_unset(offset);
25477 }
25478 break;
25479 } else if (Z_ISREF_P(container)) {
25480 container = Z_REFVAL_P(container);
25481 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
25482 goto unset_dim_array;
25483 }
25484 }
25485 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
25486 container = ZVAL_UNDEFINED_OP1();
25487 }
25488 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
25489 offset = ZVAL_UNDEFINED_OP2();
25490 }
25491 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
25492 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
25493 offset++;
25494 }
25495 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
25496 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
25497 zend_throw_error(NULL, "Cannot unset string offsets");
25498 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
25499 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
25500 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
25501 zend_false_to_array_deprecated();
25502 }
25503 } while (0);
25504
25505 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25506 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25507 }
25508
ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25509 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25510 {
25511 USE_OPLINE
25512 zval *container;
25513 zval *offset;
25514 zend_string *name, *tmp_name;
25515
25516 SAVE_OPLINE();
25517 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25518 offset = RT_CONSTANT(opline, opline->op2);
25519
25520 do {
25521 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
25522 if (Z_ISREF_P(container)) {
25523 container = Z_REFVAL_P(container);
25524 if (Z_TYPE_P(container) != IS_OBJECT) {
25525 if (IS_VAR == IS_CV
25526 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
25527 ZVAL_UNDEFINED_OP1();
25528 }
25529 break;
25530 }
25531 } else {
25532 break;
25533 }
25534 }
25535 if (IS_CONST == IS_CONST) {
25536 name = Z_STR_P(offset);
25537 } else {
25538 name = zval_try_get_tmp_string(offset, &tmp_name);
25539 if (UNEXPECTED(!name)) {
25540 break;
25541 }
25542 }
25543 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
25544 if (IS_CONST != IS_CONST) {
25545 zend_tmp_string_release(tmp_name);
25546 }
25547 } while (0);
25548
25549 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25550 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
25551 }
25552
ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25553 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25554 {
25555 USE_OPLINE
25556
25557 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
25558
25559 SAVE_OPLINE();
25560 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
25561 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
25562 }
25563
25564 /* Destroy the previously yielded value */
25565 zval_ptr_dtor(&generator->value);
25566
25567 /* Destroy the previously yielded key */
25568 zval_ptr_dtor(&generator->key);
25569
25570 /* Set the new yielded value */
25571 if (IS_VAR != IS_UNUSED) {
25572 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
25573 /* Constants and temporary variables aren't yieldable by reference,
25574 * but we still allow them with a notice. */
25575 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
25576 zval *value;
25577
25578 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
25579
25580 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25581 ZVAL_COPY_VALUE(&generator->value, value);
25582 if (IS_VAR == IS_CONST) {
25583 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
25584 Z_ADDREF(generator->value);
25585 }
25586 }
25587 } else {
25588 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25589
25590 /* If a function call result is yielded and the function did
25591 * not return by reference we throw a notice. */
25592 do {
25593 if (IS_VAR == IS_VAR) {
25594 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
25595 if (opline->extended_value == ZEND_RETURNS_FUNCTION
25596 && !Z_ISREF_P(value_ptr)) {
25597 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
25598 ZVAL_COPY(&generator->value, value_ptr);
25599 break;
25600 }
25601 }
25602 if (Z_ISREF_P(value_ptr)) {
25603 Z_ADDREF_P(value_ptr);
25604 } else {
25605 ZVAL_MAKE_REF_EX(value_ptr, 2);
25606 }
25607 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
25608 } while (0);
25609
25610 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25611 }
25612 } else {
25613 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25614
25615 /* Consts, temporary variables and references need copying */
25616 if (IS_VAR == IS_CONST) {
25617 ZVAL_COPY_VALUE(&generator->value, value);
25618 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
25619 Z_ADDREF(generator->value);
25620 }
25621 } else if (IS_VAR == IS_TMP_VAR) {
25622 ZVAL_COPY_VALUE(&generator->value, value);
25623 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
25624 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
25625 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25626 } else {
25627 ZVAL_COPY_VALUE(&generator->value, value);
25628 if (IS_VAR == IS_CV) {
25629 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
25630 }
25631 }
25632 }
25633 } else {
25634 /* If no value was specified yield null */
25635 ZVAL_NULL(&generator->value);
25636 }
25637
25638 /* Set the new yielded key */
25639 if (IS_CONST != IS_UNUSED) {
25640 zval *key = RT_CONSTANT(opline, opline->op2);
25641 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
25642 key = Z_REFVAL_P(key);
25643 }
25644 ZVAL_COPY(&generator->key, key);
25645
25646 if (Z_TYPE(generator->key) == IS_LONG
25647 && Z_LVAL(generator->key) > generator->largest_used_integer_key
25648 ) {
25649 generator->largest_used_integer_key = Z_LVAL(generator->key);
25650 }
25651 } else {
25652 /* If no key was specified we use auto-increment keys */
25653 generator->largest_used_integer_key++;
25654 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
25655 }
25656
25657 if (RETURN_VALUE_USED(opline)) {
25658 /* If the return value of yield is used set the send
25659 * target and initialize it to NULL */
25660 generator->send_target = EX_VAR(opline->result.var);
25661 ZVAL_NULL(generator->send_target);
25662 } else {
25663 generator->send_target = NULL;
25664 }
25665
25666 /* We increment to the next op, so we are at the correct position when the
25667 * generator is resumed. */
25668 ZEND_VM_INC_OPCODE();
25669
25670 /* The GOTO VM uses a local opline variable. We need to set the opline
25671 * variable in execute_data so we don't resume at an old position. */
25672 SAVE_OPLINE();
25673
25674 ZEND_VM_RETURN();
25675 }
25676
ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25677 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25678 {
25679 USE_OPLINE
25680 zval *op1;
25681 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
25682 zval *result;
25683
25684 op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25685 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
25686 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_VAR == IS_CONST);
25687 if (IS_VAR & (IS_TMP_VAR|IS_VAR)) {
25688 zval_ptr_dtor_str(op1);
25689 }
25690 ZEND_VM_SMART_BRANCH(result, 0);
25691 }
25692
25693 if (opline->extended_value) {
25694 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
25695 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
25696 ZEND_VM_SMART_BRANCH(result, 0);
25697 }
25698 SAVE_OPLINE();
25699 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
25700 op1 = Z_REFVAL_P(op1);
25701 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
25702 result = zend_hash_find(ht, Z_STR_P(op1));
25703 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25704 ZEND_VM_SMART_BRANCH(result, 0);
25705 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
25706 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
25707 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25708 ZEND_VM_SMART_BRANCH(result, 0);
25709 }
25710 } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
25711 ZVAL_UNDEFINED_OP1();
25712 }
25713 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
25714 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
25715 SAVE_OPLINE();
25716 ZVAL_UNDEFINED_OP1();
25717 if (UNEXPECTED(EG(exception) != NULL)) {
25718 HANDLE_EXCEPTION();
25719 }
25720 }
25721 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
25722 ZEND_VM_SMART_BRANCH(result, 0);
25723 } else {
25724 zend_string *key;
25725 zval key_tmp;
25726
25727 if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
25728 op1 = Z_REFVAL_P(op1);
25729 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
25730 result = zend_hash_find(ht, Z_STR_P(op1));
25731 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25732 ZEND_VM_SMART_BRANCH(result, 0);
25733 }
25734 }
25735
25736 SAVE_OPLINE();
25737 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
25738 ZVAL_STR(&key_tmp, key);
25739 if (zend_compare(op1, &key_tmp) == 0) {
25740 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25741 ZEND_VM_SMART_BRANCH(1, 1);
25742 }
25743 } ZEND_HASH_FOREACH_END();
25744 }
25745 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25746 ZEND_VM_SMART_BRANCH(0, 1);
25747 }
25748
ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25749 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25750 {
25751 zend_class_entry *ce, *scope;
25752 zend_class_constant *c;
25753 zval *value, *zv, *constant_zv;
25754 zend_string *constant_name;
25755 USE_OPLINE
25756
25757 SAVE_OPLINE();
25758
25759 do {
25760 if (IS_VAR == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
25761 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
25762 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25763 break;
25764 }
25765 }
25766 if (IS_VAR == IS_CONST) {
25767 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
25768 ce = CACHED_PTR(opline->extended_value);
25769 } else {
25770 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);
25771 if (UNEXPECTED(ce == NULL)) {
25772 ZVAL_UNDEF(EX_VAR(opline->result.var));
25773 FREE_OP(opline->op2_type, opline->op2.var);
25774 HANDLE_EXCEPTION();
25775 }
25776 CACHE_PTR(opline->extended_value, ce);
25777 }
25778 } else if (IS_VAR == IS_UNUSED) {
25779 ce = zend_fetch_class(NULL, opline->op1.num);
25780 if (UNEXPECTED(ce == NULL)) {
25781 ZVAL_UNDEF(EX_VAR(opline->result.var));
25782 FREE_OP(opline->op2_type, opline->op2.var);
25783 HANDLE_EXCEPTION();
25784 }
25785 } else {
25786 ce = Z_CE_P(EX_VAR(opline->op1.var));
25787 }
25788 if (IS_VAR != IS_CONST
25789 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
25790 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
25791 value = CACHED_PTR(opline->extended_value + sizeof(void*));
25792 break;
25793 }
25794
25795 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
25796 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
25797 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
25798 ZVAL_UNDEF(EX_VAR(opline->result.var));
25799 FREE_OP(opline->op2_type, opline->op2.var);
25800 HANDLE_EXCEPTION();
25801 }
25802 constant_name = Z_STR_P(constant_zv);
25803 /* Magic 'class' for constant OP2 is caught at compile-time */
25804 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
25805 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
25806 FREE_OP(opline->op2_type, opline->op2.var);
25807 ZEND_VM_NEXT_OPCODE();
25808 }
25809 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
25810 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
25811 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
25812
25813 if (EXPECTED(zv != NULL)) {
25814 c = Z_PTR_P(zv);
25815 scope = EX(func)->op_array.scope;
25816 if (!zend_verify_const_access(c, scope)) {
25817 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));
25818 ZVAL_UNDEF(EX_VAR(opline->result.var));
25819 FREE_OP(opline->op2_type, opline->op2.var);
25820 HANDLE_EXCEPTION();
25821 }
25822
25823 if (ce->ce_flags & ZEND_ACC_TRAIT) {
25824 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25825 ZVAL_UNDEF(EX_VAR(opline->result.var));
25826 FREE_OP(opline->op2_type, opline->op2.var);
25827 HANDLE_EXCEPTION();
25828 }
25829
25830 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
25831 if (UNEXPECTED(is_constant_deprecated)) {
25832 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25833
25834 if (EG(exception)) {
25835 ZVAL_UNDEF(EX_VAR(opline->result.var));
25836 FREE_OP(opline->op2_type, opline->op2.var);
25837 HANDLE_EXCEPTION();
25838 }
25839 }
25840
25841 value = &c->value;
25842 // Enums require loading of all class constants to build the backed enum table
25843 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)) {
25844 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
25845 ZVAL_UNDEF(EX_VAR(opline->result.var));
25846 FREE_OP(opline->op2_type, opline->op2.var);
25847 HANDLE_EXCEPTION();
25848 }
25849 }
25850 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
25851 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
25852 ZVAL_UNDEF(EX_VAR(opline->result.var));
25853 FREE_OP(opline->op2_type, opline->op2.var);
25854 HANDLE_EXCEPTION();
25855 }
25856 }
25857 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
25858 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
25859 }
25860 } else {
25861 zend_throw_error(NULL, "Undefined constant %s::%s",
25862 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
25863 ZVAL_UNDEF(EX_VAR(opline->result.var));
25864 FREE_OP(opline->op2_type, opline->op2.var);
25865 HANDLE_EXCEPTION();
25866 }
25867 } while (0);
25868
25869 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
25870
25871 FREE_OP(opline->op2_type, opline->op2.var);
25872 ZEND_VM_NEXT_OPCODE();
25873 }
25874
ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25875 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25876 {
25877 USE_OPLINE
25878 zval *object;
25879 zval *property;
25880 zval *value;
25881 zval *zptr;
25882 void **cache_slot;
25883 zend_property_info *prop_info;
25884 zend_object *zobj;
25885 zend_string *name, *tmp_name;
25886
25887 SAVE_OPLINE();
25888 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25889 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
25890
25891 do {
25892 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
25893
25894 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
25895 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
25896 object = Z_REFVAL_P(object);
25897 goto assign_op_object;
25898 }
25899 if (IS_VAR == IS_CV
25900 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
25901 ZVAL_UNDEFINED_OP1();
25902 }
25903 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
25904 break;
25905 }
25906
25907 assign_op_object:
25908 /* here we are sure we are dealing with an object */
25909 zobj = Z_OBJ_P(object);
25910 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
25911 name = Z_STR_P(property);
25912 } else {
25913 name = zval_try_get_tmp_string(property, &tmp_name);
25914 if (UNEXPECTED(!name)) {
25915 UNDEF_RESULT();
25916 break;
25917 }
25918 }
25919 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
25920 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
25921 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
25922 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25923 ZVAL_NULL(EX_VAR(opline->result.var));
25924 }
25925 } else {
25926 zval *orig_zptr = zptr;
25927 zend_reference *ref;
25928
25929 do {
25930 if (UNEXPECTED(Z_ISREF_P(zptr))) {
25931 ref = Z_REF_P(zptr);
25932 zptr = Z_REFVAL_P(zptr);
25933 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
25934 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
25935 break;
25936 }
25937 }
25938
25939 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
25940 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
25941 } else {
25942 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
25943 }
25944 if (prop_info) {
25945 /* special case for typed properties */
25946 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
25947 } else {
25948 zend_binary_op(zptr, zptr, value OPLINE_CC);
25949 }
25950 } while (0);
25951
25952 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
25953 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
25954 }
25955 }
25956 } else {
25957 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
25958 }
25959 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
25960 zend_tmp_string_release(tmp_name);
25961 }
25962 } while (0);
25963
25964 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
25965 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
25966 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
25967 /* assign_obj has two opcodes! */
25968 ZEND_VM_NEXT_OPCODE_EX(1, 2);
25969 }
25970
25971 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)25972 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
25973 {
25974 USE_OPLINE
25975 zval *var_ptr;
25976 zval *value, *container, *dim;
25977 HashTable *ht;
25978
25979 SAVE_OPLINE();
25980 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
25981
25982 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
25983 assign_dim_op_array:
25984 SEPARATE_ARRAY(container);
25985 ht = Z_ARRVAL_P(container);
25986 assign_dim_op_new_array:
25987 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
25988 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
25989 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
25990 if (UNEXPECTED(!var_ptr)) {
25991 zend_cannot_add_element();
25992 goto assign_dim_op_ret_null;
25993 }
25994 } else {
25995 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
25996 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
25997 } else {
25998 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
25999 }
26000 if (UNEXPECTED(!var_ptr)) {
26001 goto assign_dim_op_ret_null;
26002 }
26003 }
26004
26005 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
26006
26007 do {
26008 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
26009 zend_reference *ref = Z_REF_P(var_ptr);
26010 var_ptr = Z_REFVAL_P(var_ptr);
26011 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26012 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26013 break;
26014 }
26015 }
26016 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26017 } while (0);
26018
26019 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26020 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26021 }
26022 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26023 } else {
26024 if (EXPECTED(Z_ISREF_P(container))) {
26025 container = Z_REFVAL_P(container);
26026 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
26027 goto assign_dim_op_array;
26028 }
26029 }
26030
26031 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
26032 zend_object *obj = Z_OBJ_P(container);
26033
26034 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26035 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
26036 dim++;
26037 }
26038 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
26039 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
26040 uint8_t old_type;
26041
26042 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
26043 ZVAL_UNDEFINED_OP1();
26044 }
26045 ht = zend_new_array(8);
26046 old_type = Z_TYPE_P(container);
26047 ZVAL_ARR(container, ht);
26048 if (UNEXPECTED(old_type == IS_FALSE)) {
26049 GC_ADDREF(ht);
26050 zend_false_to_array_deprecated();
26051 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
26052 zend_array_destroy(ht);
26053 goto assign_dim_op_ret_null;
26054 }
26055 }
26056 goto assign_dim_op_new_array;
26057 } else {
26058 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26059 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
26060 assign_dim_op_ret_null:
26061 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
26062 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26063 ZVAL_NULL(EX_VAR(opline->result.var));
26064 }
26065 }
26066 }
26067
26068 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26069 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26070 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26071 }
26072
ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26073 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26074 {
26075 USE_OPLINE
26076 zval *var_ptr;
26077 zval *value;
26078
26079 SAVE_OPLINE();
26080 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26081 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26082
26083 do {
26084 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
26085 zend_reference *ref = Z_REF_P(var_ptr);
26086 var_ptr = Z_REFVAL_P(var_ptr);
26087 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
26088 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
26089 break;
26090 }
26091 }
26092 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
26093 } while (0);
26094
26095 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26096 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
26097 }
26098
26099 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26100 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26101 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26102 }
26103
ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26104 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26105 {
26106 USE_OPLINE
26107 zval *object;
26108 zval *property;
26109 zval *zptr;
26110 void **cache_slot;
26111 zend_property_info *prop_info;
26112 zend_object *zobj;
26113 zend_string *name, *tmp_name;
26114
26115 SAVE_OPLINE();
26116 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26117 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26118
26119 do {
26120 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26121 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26122 object = Z_REFVAL_P(object);
26123 goto pre_incdec_object;
26124 }
26125 if (IS_VAR == IS_CV
26126 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26127 ZVAL_UNDEFINED_OP1();
26128 }
26129 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26130 break;
26131 }
26132
26133 pre_incdec_object:
26134 /* here we are sure we are dealing with an object */
26135 zobj = Z_OBJ_P(object);
26136 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26137 name = Z_STR_P(property);
26138 } else {
26139 name = zval_try_get_tmp_string(property, &tmp_name);
26140 if (UNEXPECTED(!name)) {
26141 UNDEF_RESULT();
26142 break;
26143 }
26144 }
26145 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
26146 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26147 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26148 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26149 ZVAL_NULL(EX_VAR(opline->result.var));
26150 }
26151 } else {
26152 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26153 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
26154 } else {
26155 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
26156 }
26157 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26158 }
26159 } else {
26160 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26161 }
26162 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26163 zend_tmp_string_release(tmp_name);
26164 }
26165 } while (0);
26166
26167 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26168 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26169 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26170 }
26171
ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26172 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26173 {
26174 USE_OPLINE
26175 zval *object;
26176 zval *property;
26177 zval *zptr;
26178 void **cache_slot;
26179 zend_property_info *prop_info;
26180 zend_object *zobj;
26181 zend_string *name, *tmp_name;
26182
26183 SAVE_OPLINE();
26184 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26185 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26186
26187 do {
26188 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26189 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26190 object = Z_REFVAL_P(object);
26191 goto post_incdec_object;
26192 }
26193 if (IS_VAR == IS_CV
26194 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
26195 ZVAL_UNDEFINED_OP1();
26196 }
26197 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
26198 break;
26199 }
26200
26201 post_incdec_object:
26202 /* here we are sure we are dealing with an object */
26203 zobj = Z_OBJ_P(object);
26204 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26205 name = Z_STR_P(property);
26206 } else {
26207 name = zval_try_get_tmp_string(property, &tmp_name);
26208 if (UNEXPECTED(!name)) {
26209 ZVAL_UNDEF(EX_VAR(opline->result.var));
26210 break;
26211 }
26212 }
26213 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
26214 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
26215 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
26216 ZVAL_NULL(EX_VAR(opline->result.var));
26217 } else {
26218 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26219 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
26220 } else {
26221 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
26222 }
26223
26224 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
26225 }
26226 } else {
26227 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
26228 }
26229 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26230 zend_tmp_string_release(tmp_name);
26231 }
26232 } while (0);
26233
26234 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26235 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26236 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26237 }
26238
ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26239 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26240 {
26241 USE_OPLINE
26242 zval *container;
26243
26244 SAVE_OPLINE();
26245 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26246 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);
26247 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26248 if (IS_VAR == IS_VAR) {
26249 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26250 }
26251 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26252 }
26253
ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26254 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26255 {
26256 USE_OPLINE
26257 zval *container;
26258
26259 SAVE_OPLINE();
26260 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26261 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);
26262 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26263 if (IS_VAR == IS_VAR) {
26264 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26265 }
26266 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26267 }
26268
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26269 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26270 {
26271 #if 0
26272 USE_OPLINE
26273 #endif
26274
26275 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
26276 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
26277 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26278 }
26279 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26280 } else {
26281 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
26282 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26283 }
26284 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26285 }
26286 }
26287
ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26288 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26289 {
26290 USE_OPLINE
26291 zval *container;
26292
26293 SAVE_OPLINE();
26294 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26295 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);
26296 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26297 if (IS_VAR == IS_VAR) {
26298 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26299 }
26300 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26301 }
26302
ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26303 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26304 {
26305 USE_OPLINE
26306 zval *property, *container, *result;
26307
26308 SAVE_OPLINE();
26309
26310 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26311 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26312 result = EX_VAR(opline->result.var);
26313 zend_fetch_property_address(
26314 result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR),
26315 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
26316 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
26317 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26318 if (IS_VAR == IS_VAR) {
26319 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26320 }
26321 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26322 }
26323
ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26324 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26325 {
26326 USE_OPLINE
26327 zval *property, *container, *result;
26328
26329 SAVE_OPLINE();
26330 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26331 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26332 result = EX_VAR(opline->result.var);
26333 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 OPLINE_CC EXECUTE_DATA_CC);
26334 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26335 if (IS_VAR == IS_VAR) {
26336 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26337 }
26338 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26339 }
26340
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26341 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26342 {
26343 #if 0
26344 USE_OPLINE
26345 #endif
26346
26347 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
26348 /* Behave like FETCH_OBJ_W */
26349 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
26350 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26351 }
26352 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26353 } else {
26354 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
26355 }
26356 }
26357
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26358 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26359 {
26360 USE_OPLINE
26361 zval *container, *property, *result;
26362
26363 SAVE_OPLINE();
26364 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26365 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26366 result = EX_VAR(opline->result.var);
26367 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 OPLINE_CC EXECUTE_DATA_CC);
26368 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26369 if (IS_VAR == IS_VAR) {
26370 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
26371 }
26372 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26373 }
26374
ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26375 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26376 {
26377 USE_OPLINE
26378 zval *container, *dim;
26379
26380 SAVE_OPLINE();
26381 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26382 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26383
26384 if (IS_VAR == IS_VAR
26385 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
26386 && UNEXPECTED(!Z_ISREF_P(container))
26387 ) {
26388 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
26389 zend_fetch_dimension_address_LIST_r(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
26390 } else {
26391 zend_fetch_dimension_address_W(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
26392 }
26393
26394 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26395 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
26396 }
26397
ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)26398 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26399 {
26400 USE_OPLINE
26401 zval *object, *value, tmp;
26402 zend_object *zobj;
26403 zend_string *name, *tmp_name;
26404 zend_refcounted *garbage = NULL;
26405
26406 SAVE_OPLINE();
26407 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26408 value = RT_CONSTANT((opline+1), (opline+1)->op1);
26409
26410 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26411 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26412 object = Z_REFVAL_P(object);
26413 goto assign_object;
26414 }
26415 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
26416 value = &EG(uninitialized_zval);
26417 goto free_and_exit_assign_obj;
26418 }
26419
26420 assign_object:
26421 zobj = Z_OBJ_P(object);
26422 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26423 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
26424 void **cache_slot = CACHE_ADDR(opline->extended_value);
26425 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
26426 zval *property_val;
26427
26428 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
26429 property_val = OBJ_PROP(zobj, prop_offset);
26430 if (Z_TYPE_P(property_val) != IS_UNDEF) {
26431 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
26432
26433 if (prop_info != NULL) {
26434 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
26435 goto free_and_exit_assign_obj;
26436 } else {
26437 fast_assign_obj:
26438 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
26439 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26440 ZVAL_COPY(EX_VAR(opline->result.var), value);
26441 }
26442 goto exit_assign_obj;
26443 }
26444 }
26445 } else {
26446 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26447 if (EXPECTED(zobj->properties != NULL)) {
26448 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
26449 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
26450 GC_DELREF(zobj->properties);
26451 }
26452 zobj->properties = zend_array_dup(zobj->properties);
26453 }
26454 property_val = zend_hash_find_known_hash(zobj->properties, name);
26455 if (property_val) {
26456 goto fast_assign_obj;
26457 }
26458 }
26459
26460 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
26461 if (EXPECTED(zobj->properties == NULL)) {
26462 rebuild_object_properties(zobj);
26463 }
26464 if (IS_CONST == IS_CONST) {
26465 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
26466 Z_ADDREF_P(value);
26467 }
26468 } else if (IS_CONST != IS_TMP_VAR) {
26469 if (Z_ISREF_P(value)) {
26470 if (IS_CONST == IS_VAR) {
26471 zend_reference *ref = Z_REF_P(value);
26472 if (GC_DELREF(ref) == 0) {
26473 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
26474 efree_size(ref, sizeof(zend_reference));
26475 value = &tmp;
26476 } else {
26477 value = Z_REFVAL_P(value);
26478 Z_TRY_ADDREF_P(value);
26479 }
26480 } else {
26481 value = Z_REFVAL_P(value);
26482 Z_TRY_ADDREF_P(value);
26483 }
26484 } else if (IS_CONST == IS_CV) {
26485 Z_TRY_ADDREF_P(value);
26486 }
26487 }
26488 zend_hash_add_new(zobj->properties, name, value);
26489 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26490 ZVAL_COPY(EX_VAR(opline->result.var), value);
26491 }
26492 goto exit_assign_obj;
26493 }
26494 }
26495 }
26496 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26497 } else {
26498 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
26499 if (UNEXPECTED(!name)) {
26500
26501 UNDEF_RESULT();
26502 goto exit_assign_obj;
26503 }
26504 }
26505
26506 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
26507 ZVAL_DEREF(value);
26508 }
26509
26510 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
26511
26512 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26513 zend_tmp_string_release(tmp_name);
26514 }
26515
26516 free_and_exit_assign_obj:
26517 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
26518 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
26519 }
26520
26521 exit_assign_obj:
26522 if (garbage) {
26523 GC_DTOR_NO_REF(garbage);
26524 }
26525 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26526 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26527 /* assign_obj has two opcodes! */
26528 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26529 }
26530
26531 /* 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)26532 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26533 {
26534 USE_OPLINE
26535 zval *object, *value, tmp;
26536 zend_object *zobj;
26537 zend_string *name, *tmp_name;
26538 zend_refcounted *garbage = NULL;
26539
26540 SAVE_OPLINE();
26541 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26542 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
26543
26544 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26545 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26546 object = Z_REFVAL_P(object);
26547 goto assign_object;
26548 }
26549 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
26550 value = &EG(uninitialized_zval);
26551 goto free_and_exit_assign_obj;
26552 }
26553
26554 assign_object:
26555 zobj = Z_OBJ_P(object);
26556 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26557 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
26558 void **cache_slot = CACHE_ADDR(opline->extended_value);
26559 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
26560 zval *property_val;
26561
26562 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
26563 property_val = OBJ_PROP(zobj, prop_offset);
26564 if (Z_TYPE_P(property_val) != IS_UNDEF) {
26565 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
26566
26567 if (prop_info != NULL) {
26568 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
26569 goto free_and_exit_assign_obj;
26570 } else {
26571 fast_assign_obj:
26572 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
26573 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26574 ZVAL_COPY(EX_VAR(opline->result.var), value);
26575 }
26576 goto exit_assign_obj;
26577 }
26578 }
26579 } else {
26580 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26581 if (EXPECTED(zobj->properties != NULL)) {
26582 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
26583 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
26584 GC_DELREF(zobj->properties);
26585 }
26586 zobj->properties = zend_array_dup(zobj->properties);
26587 }
26588 property_val = zend_hash_find_known_hash(zobj->properties, name);
26589 if (property_val) {
26590 goto fast_assign_obj;
26591 }
26592 }
26593
26594 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
26595 if (EXPECTED(zobj->properties == NULL)) {
26596 rebuild_object_properties(zobj);
26597 }
26598 if (IS_TMP_VAR == IS_CONST) {
26599 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
26600 Z_ADDREF_P(value);
26601 }
26602 } else if (IS_TMP_VAR != IS_TMP_VAR) {
26603 if (Z_ISREF_P(value)) {
26604 if (IS_TMP_VAR == IS_VAR) {
26605 zend_reference *ref = Z_REF_P(value);
26606 if (GC_DELREF(ref) == 0) {
26607 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
26608 efree_size(ref, sizeof(zend_reference));
26609 value = &tmp;
26610 } else {
26611 value = Z_REFVAL_P(value);
26612 Z_TRY_ADDREF_P(value);
26613 }
26614 } else {
26615 value = Z_REFVAL_P(value);
26616 Z_TRY_ADDREF_P(value);
26617 }
26618 } else if (IS_TMP_VAR == IS_CV) {
26619 Z_TRY_ADDREF_P(value);
26620 }
26621 }
26622 zend_hash_add_new(zobj->properties, name, value);
26623 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26624 ZVAL_COPY(EX_VAR(opline->result.var), value);
26625 }
26626 goto exit_assign_obj;
26627 }
26628 }
26629 }
26630 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26631 } else {
26632 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
26633 if (UNEXPECTED(!name)) {
26634 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
26635 UNDEF_RESULT();
26636 goto exit_assign_obj;
26637 }
26638 }
26639
26640 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
26641 ZVAL_DEREF(value);
26642 }
26643
26644 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
26645
26646 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26647 zend_tmp_string_release(tmp_name);
26648 }
26649
26650 free_and_exit_assign_obj:
26651 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
26652 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
26653 }
26654 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
26655 exit_assign_obj:
26656 if (garbage) {
26657 GC_DTOR_NO_REF(garbage);
26658 }
26659 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26660 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26661 /* assign_obj has two opcodes! */
26662 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26663 }
26664
26665 /* 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)26666 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26667 {
26668 USE_OPLINE
26669 zval *object, *value, tmp;
26670 zend_object *zobj;
26671 zend_string *name, *tmp_name;
26672 zend_refcounted *garbage = NULL;
26673
26674 SAVE_OPLINE();
26675 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26676 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
26677
26678 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26679 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26680 object = Z_REFVAL_P(object);
26681 goto assign_object;
26682 }
26683 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
26684 value = &EG(uninitialized_zval);
26685 goto free_and_exit_assign_obj;
26686 }
26687
26688 assign_object:
26689 zobj = Z_OBJ_P(object);
26690 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26691 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
26692 void **cache_slot = CACHE_ADDR(opline->extended_value);
26693 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
26694 zval *property_val;
26695
26696 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
26697 property_val = OBJ_PROP(zobj, prop_offset);
26698 if (Z_TYPE_P(property_val) != IS_UNDEF) {
26699 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
26700
26701 if (prop_info != NULL) {
26702 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
26703 goto free_and_exit_assign_obj;
26704 } else {
26705 fast_assign_obj:
26706 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
26707 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26708 ZVAL_COPY(EX_VAR(opline->result.var), value);
26709 }
26710 goto exit_assign_obj;
26711 }
26712 }
26713 } else {
26714 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26715 if (EXPECTED(zobj->properties != NULL)) {
26716 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
26717 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
26718 GC_DELREF(zobj->properties);
26719 }
26720 zobj->properties = zend_array_dup(zobj->properties);
26721 }
26722 property_val = zend_hash_find_known_hash(zobj->properties, name);
26723 if (property_val) {
26724 goto fast_assign_obj;
26725 }
26726 }
26727
26728 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
26729 if (EXPECTED(zobj->properties == NULL)) {
26730 rebuild_object_properties(zobj);
26731 }
26732 if (IS_VAR == IS_CONST) {
26733 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
26734 Z_ADDREF_P(value);
26735 }
26736 } else if (IS_VAR != IS_TMP_VAR) {
26737 if (Z_ISREF_P(value)) {
26738 if (IS_VAR == IS_VAR) {
26739 zend_reference *ref = Z_REF_P(value);
26740 if (GC_DELREF(ref) == 0) {
26741 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
26742 efree_size(ref, sizeof(zend_reference));
26743 value = &tmp;
26744 } else {
26745 value = Z_REFVAL_P(value);
26746 Z_TRY_ADDREF_P(value);
26747 }
26748 } else {
26749 value = Z_REFVAL_P(value);
26750 Z_TRY_ADDREF_P(value);
26751 }
26752 } else if (IS_VAR == IS_CV) {
26753 Z_TRY_ADDREF_P(value);
26754 }
26755 }
26756 zend_hash_add_new(zobj->properties, name, value);
26757 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26758 ZVAL_COPY(EX_VAR(opline->result.var), value);
26759 }
26760 goto exit_assign_obj;
26761 }
26762 }
26763 }
26764 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26765 } else {
26766 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
26767 if (UNEXPECTED(!name)) {
26768 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
26769 UNDEF_RESULT();
26770 goto exit_assign_obj;
26771 }
26772 }
26773
26774 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
26775 ZVAL_DEREF(value);
26776 }
26777
26778 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
26779
26780 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26781 zend_tmp_string_release(tmp_name);
26782 }
26783
26784 free_and_exit_assign_obj:
26785 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
26786 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
26787 }
26788 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
26789 exit_assign_obj:
26790 if (garbage) {
26791 GC_DTOR_NO_REF(garbage);
26792 }
26793 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26794 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26795 /* assign_obj has two opcodes! */
26796 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26797 }
26798
26799 /* 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)26800 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26801 {
26802 USE_OPLINE
26803 zval *object, *value, tmp;
26804 zend_object *zobj;
26805 zend_string *name, *tmp_name;
26806 zend_refcounted *garbage = NULL;
26807
26808 SAVE_OPLINE();
26809 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26810 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
26811
26812 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
26813 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
26814 object = Z_REFVAL_P(object);
26815 goto assign_object;
26816 }
26817 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
26818 value = &EG(uninitialized_zval);
26819 goto free_and_exit_assign_obj;
26820 }
26821
26822 assign_object:
26823 zobj = Z_OBJ_P(object);
26824 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26825 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
26826 void **cache_slot = CACHE_ADDR(opline->extended_value);
26827 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
26828 zval *property_val;
26829
26830 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
26831 property_val = OBJ_PROP(zobj, prop_offset);
26832 if (Z_TYPE_P(property_val) != IS_UNDEF) {
26833 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
26834
26835 if (prop_info != NULL) {
26836 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
26837 goto free_and_exit_assign_obj;
26838 } else {
26839 fast_assign_obj:
26840 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
26841 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26842 ZVAL_COPY(EX_VAR(opline->result.var), value);
26843 }
26844 goto exit_assign_obj;
26845 }
26846 }
26847 } else {
26848 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26849 if (EXPECTED(zobj->properties != NULL)) {
26850 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
26851 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
26852 GC_DELREF(zobj->properties);
26853 }
26854 zobj->properties = zend_array_dup(zobj->properties);
26855 }
26856 property_val = zend_hash_find_known_hash(zobj->properties, name);
26857 if (property_val) {
26858 goto fast_assign_obj;
26859 }
26860 }
26861
26862 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
26863 if (EXPECTED(zobj->properties == NULL)) {
26864 rebuild_object_properties(zobj);
26865 }
26866 if (IS_CV == IS_CONST) {
26867 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
26868 Z_ADDREF_P(value);
26869 }
26870 } else if (IS_CV != IS_TMP_VAR) {
26871 if (Z_ISREF_P(value)) {
26872 if (IS_CV == IS_VAR) {
26873 zend_reference *ref = Z_REF_P(value);
26874 if (GC_DELREF(ref) == 0) {
26875 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
26876 efree_size(ref, sizeof(zend_reference));
26877 value = &tmp;
26878 } else {
26879 value = Z_REFVAL_P(value);
26880 Z_TRY_ADDREF_P(value);
26881 }
26882 } else {
26883 value = Z_REFVAL_P(value);
26884 Z_TRY_ADDREF_P(value);
26885 }
26886 } else if (IS_CV == IS_CV) {
26887 Z_TRY_ADDREF_P(value);
26888 }
26889 }
26890 zend_hash_add_new(zobj->properties, name, value);
26891 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
26892 ZVAL_COPY(EX_VAR(opline->result.var), value);
26893 }
26894 goto exit_assign_obj;
26895 }
26896 }
26897 }
26898 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
26899 } else {
26900 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
26901 if (UNEXPECTED(!name)) {
26902
26903 UNDEF_RESULT();
26904 goto exit_assign_obj;
26905 }
26906 }
26907
26908 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
26909 ZVAL_DEREF(value);
26910 }
26911
26912 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
26913
26914 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
26915 zend_tmp_string_release(tmp_name);
26916 }
26917
26918 free_and_exit_assign_obj:
26919 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
26920 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
26921 }
26922
26923 exit_assign_obj:
26924 if (garbage) {
26925 GC_DTOR_NO_REF(garbage);
26926 }
26927 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
26928 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
26929 /* assign_obj has two opcodes! */
26930 ZEND_VM_NEXT_OPCODE_EX(1, 2);
26931 }
26932
26933 /* 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)26934 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
26935 {
26936 USE_OPLINE
26937 zval *object_ptr, *orig_object_ptr;
26938 zval *value;
26939 zval *variable_ptr;
26940 zval *dim;
26941 zend_refcounted *garbage = NULL;
26942
26943 SAVE_OPLINE();
26944 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
26945
26946 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
26947 try_assign_dim_array:
26948 SEPARATE_ARRAY(object_ptr);
26949 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
26950 value = RT_CONSTANT((opline+1), (opline+1)->op1);
26951 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
26952 HashTable *ht = Z_ARRVAL_P(object_ptr);
26953 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
26954 GC_ADDREF(ht);
26955 }
26956 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
26957 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
26958 zend_array_destroy(ht);
26959 goto assign_dim_error;
26960 }
26961 }
26962 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
26963 ZVAL_DEREF(value);
26964 }
26965 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
26966 if (UNEXPECTED(value == NULL)) {
26967 zend_cannot_add_element();
26968 goto assign_dim_error;
26969 } else if (IS_CONST == IS_CV) {
26970 if (Z_REFCOUNTED_P(value)) {
26971 Z_ADDREF_P(value);
26972 }
26973 } else if (IS_CONST == IS_VAR) {
26974 zval *free_op_data = EX_VAR((opline+1)->op1.var);
26975 if (Z_ISREF_P(free_op_data)) {
26976 if (Z_REFCOUNTED_P(value)) {
26977 Z_ADDREF_P(value);
26978 }
26979 zval_ptr_dtor_nogc(free_op_data);
26980 }
26981 } else if (IS_CONST == IS_CONST) {
26982 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
26983 Z_ADDREF_P(value);
26984 }
26985 }
26986 } else {
26987 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
26988 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
26989 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
26990 } else {
26991 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
26992 }
26993 if (UNEXPECTED(variable_ptr == NULL)) {
26994 goto assign_dim_error;
26995 }
26996 value = RT_CONSTANT((opline+1), (opline+1)->op1);
26997 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
26998 }
26999 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27000 ZVAL_COPY(EX_VAR(opline->result.var), value);
27001 }
27002 if (garbage) {
27003 GC_DTOR_NO_REF(garbage);
27004 }
27005 } else {
27006 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27007 object_ptr = Z_REFVAL_P(object_ptr);
27008 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27009 goto try_assign_dim_array;
27010 }
27011 }
27012 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27013 zend_object *obj = Z_OBJ_P(object_ptr);
27014
27015 GC_ADDREF(obj);
27016 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27017 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27018 dim = ZVAL_UNDEFINED_OP2();
27019 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27020 dim++;
27021 }
27022
27023 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27024 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27025 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27026 } else if (IS_CONST & (IS_CV|IS_VAR)) {
27027 ZVAL_DEREF(value);
27028 }
27029
27030 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27031
27032 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27033 zend_objects_store_del(obj);
27034 }
27035 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27036 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27037 zend_use_new_element_for_string();
27038
27039 UNDEF_RESULT();
27040 } else {
27041 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27042 value = RT_CONSTANT((opline+1), (opline+1)->op1);
27043 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27044
27045 }
27046 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27047 if (Z_ISREF_P(orig_object_ptr)
27048 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27049 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27050 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27051
27052 UNDEF_RESULT();
27053 } else {
27054 HashTable *ht = zend_new_array(8);
27055 uint8_t old_type = Z_TYPE_P(object_ptr);
27056
27057 ZVAL_ARR(object_ptr, ht);
27058 if (UNEXPECTED(old_type == IS_FALSE)) {
27059 GC_ADDREF(ht);
27060 zend_false_to_array_deprecated();
27061 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27062 zend_array_destroy(ht);
27063 goto assign_dim_error;
27064 }
27065 }
27066 goto try_assign_dim_array;
27067 }
27068 } else {
27069 zend_use_scalar_as_array();
27070 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27071 assign_dim_error:
27072
27073 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27074 ZVAL_NULL(EX_VAR(opline->result.var));
27075 }
27076 }
27077 }
27078 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27079 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27080 }
27081 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27082 /* assign_dim has two opcodes! */
27083 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27084 }
27085
ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27086 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27087 {
27088 USE_OPLINE
27089 zval *object_ptr, *orig_object_ptr;
27090 zval *value;
27091 zval *variable_ptr;
27092 zval *dim;
27093 zend_refcounted *garbage = NULL;
27094
27095 SAVE_OPLINE();
27096 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27097
27098 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27099 try_assign_dim_array:
27100 SEPARATE_ARRAY(object_ptr);
27101 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27102 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27103 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27104 HashTable *ht = Z_ARRVAL_P(object_ptr);
27105 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27106 GC_ADDREF(ht);
27107 }
27108 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27109 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27110 zend_array_destroy(ht);
27111 goto assign_dim_error;
27112 }
27113 }
27114 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
27115 ZVAL_DEREF(value);
27116 }
27117 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27118 if (UNEXPECTED(value == NULL)) {
27119 zend_cannot_add_element();
27120 goto assign_dim_error;
27121 } else if (IS_TMP_VAR == IS_CV) {
27122 if (Z_REFCOUNTED_P(value)) {
27123 Z_ADDREF_P(value);
27124 }
27125 } else if (IS_TMP_VAR == IS_VAR) {
27126 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27127 if (Z_ISREF_P(free_op_data)) {
27128 if (Z_REFCOUNTED_P(value)) {
27129 Z_ADDREF_P(value);
27130 }
27131 zval_ptr_dtor_nogc(free_op_data);
27132 }
27133 } else if (IS_TMP_VAR == IS_CONST) {
27134 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27135 Z_ADDREF_P(value);
27136 }
27137 }
27138 } else {
27139 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27140 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27141 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27142 } else {
27143 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27144 }
27145 if (UNEXPECTED(variable_ptr == NULL)) {
27146 goto assign_dim_error;
27147 }
27148 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27149 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
27150 }
27151 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27152 ZVAL_COPY(EX_VAR(opline->result.var), value);
27153 }
27154 if (garbage) {
27155 GC_DTOR_NO_REF(garbage);
27156 }
27157 } else {
27158 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27159 object_ptr = Z_REFVAL_P(object_ptr);
27160 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27161 goto try_assign_dim_array;
27162 }
27163 }
27164 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27165 zend_object *obj = Z_OBJ_P(object_ptr);
27166
27167 GC_ADDREF(obj);
27168 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27169 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27170 dim = ZVAL_UNDEFINED_OP2();
27171 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27172 dim++;
27173 }
27174
27175 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27176 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27177 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27178 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
27179 ZVAL_DEREF(value);
27180 }
27181
27182 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27183
27184 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27185 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27186 zend_objects_store_del(obj);
27187 }
27188 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27189 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27190 zend_use_new_element_for_string();
27191 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27192 UNDEF_RESULT();
27193 } else {
27194 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27195 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
27196 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27197 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27198 }
27199 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27200 if (Z_ISREF_P(orig_object_ptr)
27201 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27202 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27203 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27204 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27205 UNDEF_RESULT();
27206 } else {
27207 HashTable *ht = zend_new_array(8);
27208 uint8_t old_type = Z_TYPE_P(object_ptr);
27209
27210 ZVAL_ARR(object_ptr, ht);
27211 if (UNEXPECTED(old_type == IS_FALSE)) {
27212 GC_ADDREF(ht);
27213 zend_false_to_array_deprecated();
27214 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27215 zend_array_destroy(ht);
27216 goto assign_dim_error;
27217 }
27218 }
27219 goto try_assign_dim_array;
27220 }
27221 } else {
27222 zend_use_scalar_as_array();
27223 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27224 assign_dim_error:
27225 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27226 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27227 ZVAL_NULL(EX_VAR(opline->result.var));
27228 }
27229 }
27230 }
27231 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27232 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27233 }
27234 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27235 /* assign_dim has two opcodes! */
27236 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27237 }
27238
ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27239 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27240 {
27241 USE_OPLINE
27242 zval *object_ptr, *orig_object_ptr;
27243 zval *value;
27244 zval *variable_ptr;
27245 zval *dim;
27246 zend_refcounted *garbage = NULL;
27247
27248 SAVE_OPLINE();
27249 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27250
27251 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27252 try_assign_dim_array:
27253 SEPARATE_ARRAY(object_ptr);
27254 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27255 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27256 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27257 HashTable *ht = Z_ARRVAL_P(object_ptr);
27258 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27259 GC_ADDREF(ht);
27260 }
27261 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27262 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27263 zend_array_destroy(ht);
27264 goto assign_dim_error;
27265 }
27266 }
27267 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
27268 ZVAL_DEREF(value);
27269 }
27270 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27271 if (UNEXPECTED(value == NULL)) {
27272 zend_cannot_add_element();
27273 goto assign_dim_error;
27274 } else if (IS_VAR == IS_CV) {
27275 if (Z_REFCOUNTED_P(value)) {
27276 Z_ADDREF_P(value);
27277 }
27278 } else if (IS_VAR == IS_VAR) {
27279 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27280 if (Z_ISREF_P(free_op_data)) {
27281 if (Z_REFCOUNTED_P(value)) {
27282 Z_ADDREF_P(value);
27283 }
27284 zval_ptr_dtor_nogc(free_op_data);
27285 }
27286 } else if (IS_VAR == IS_CONST) {
27287 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27288 Z_ADDREF_P(value);
27289 }
27290 }
27291 } else {
27292 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27293 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27294 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27295 } else {
27296 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27297 }
27298 if (UNEXPECTED(variable_ptr == NULL)) {
27299 goto assign_dim_error;
27300 }
27301 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27302 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
27303 }
27304 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27305 ZVAL_COPY(EX_VAR(opline->result.var), value);
27306 }
27307 if (garbage) {
27308 GC_DTOR_NO_REF(garbage);
27309 }
27310 } else {
27311 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27312 object_ptr = Z_REFVAL_P(object_ptr);
27313 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27314 goto try_assign_dim_array;
27315 }
27316 }
27317 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27318 zend_object *obj = Z_OBJ_P(object_ptr);
27319
27320 GC_ADDREF(obj);
27321 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27322 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27323 dim = ZVAL_UNDEFINED_OP2();
27324 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27325 dim++;
27326 }
27327
27328 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27329 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27330 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27331 } else if (IS_VAR & (IS_CV|IS_VAR)) {
27332 ZVAL_DEREF(value);
27333 }
27334
27335 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27336
27337 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27338 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27339 zend_objects_store_del(obj);
27340 }
27341 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27342 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27343 zend_use_new_element_for_string();
27344 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27345 UNDEF_RESULT();
27346 } else {
27347 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27348 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27349 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27350 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27351 }
27352 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27353 if (Z_ISREF_P(orig_object_ptr)
27354 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27355 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27356 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27357 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27358 UNDEF_RESULT();
27359 } else {
27360 HashTable *ht = zend_new_array(8);
27361 uint8_t old_type = Z_TYPE_P(object_ptr);
27362
27363 ZVAL_ARR(object_ptr, ht);
27364 if (UNEXPECTED(old_type == IS_FALSE)) {
27365 GC_ADDREF(ht);
27366 zend_false_to_array_deprecated();
27367 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27368 zend_array_destroy(ht);
27369 goto assign_dim_error;
27370 }
27371 }
27372 goto try_assign_dim_array;
27373 }
27374 } else {
27375 zend_use_scalar_as_array();
27376 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27377 assign_dim_error:
27378 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27379 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27380 ZVAL_NULL(EX_VAR(opline->result.var));
27381 }
27382 }
27383 }
27384 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27385 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27386 }
27387 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27388 /* assign_dim has two opcodes! */
27389 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27390 }
27391
ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27392 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27393 {
27394 USE_OPLINE
27395 zval *object_ptr, *orig_object_ptr;
27396 zval *value;
27397 zval *variable_ptr;
27398 zval *dim;
27399 zend_refcounted *garbage = NULL;
27400
27401 SAVE_OPLINE();
27402 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27403
27404 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27405 try_assign_dim_array:
27406 SEPARATE_ARRAY(object_ptr);
27407 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27408 value = EX_VAR((opline+1)->op1.var);
27409 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
27410 HashTable *ht = Z_ARRVAL_P(object_ptr);
27411 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
27412 GC_ADDREF(ht);
27413 }
27414 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27415 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
27416 zend_array_destroy(ht);
27417 goto assign_dim_error;
27418 }
27419 }
27420 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
27421 ZVAL_DEREF(value);
27422 }
27423 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
27424 if (UNEXPECTED(value == NULL)) {
27425 zend_cannot_add_element();
27426 goto assign_dim_error;
27427 } else if (IS_CV == IS_CV) {
27428 if (Z_REFCOUNTED_P(value)) {
27429 Z_ADDREF_P(value);
27430 }
27431 } else if (IS_CV == IS_VAR) {
27432 zval *free_op_data = EX_VAR((opline+1)->op1.var);
27433 if (Z_ISREF_P(free_op_data)) {
27434 if (Z_REFCOUNTED_P(value)) {
27435 Z_ADDREF_P(value);
27436 }
27437 zval_ptr_dtor_nogc(free_op_data);
27438 }
27439 } else if (IS_CV == IS_CONST) {
27440 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
27441 Z_ADDREF_P(value);
27442 }
27443 }
27444 } else {
27445 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27446 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27447 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27448 } else {
27449 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
27450 }
27451 if (UNEXPECTED(variable_ptr == NULL)) {
27452 goto assign_dim_error;
27453 }
27454 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
27455 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
27456 }
27457 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27458 ZVAL_COPY(EX_VAR(opline->result.var), value);
27459 }
27460 if (garbage) {
27461 GC_DTOR_NO_REF(garbage);
27462 }
27463 } else {
27464 if (EXPECTED(Z_ISREF_P(object_ptr))) {
27465 object_ptr = Z_REFVAL_P(object_ptr);
27466 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
27467 goto try_assign_dim_array;
27468 }
27469 }
27470 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
27471 zend_object *obj = Z_OBJ_P(object_ptr);
27472
27473 GC_ADDREF(obj);
27474 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27475 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
27476 dim = ZVAL_UNDEFINED_OP2();
27477 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
27478 dim++;
27479 }
27480
27481 value = EX_VAR((opline+1)->op1.var);
27482 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
27483 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
27484 } else if (IS_CV & (IS_CV|IS_VAR)) {
27485 ZVAL_DEREF(value);
27486 }
27487
27488 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
27489
27490 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
27491 zend_objects_store_del(obj);
27492 }
27493 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
27494 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
27495 zend_use_new_element_for_string();
27496
27497 UNDEF_RESULT();
27498 } else {
27499 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27500 value = EX_VAR((opline+1)->op1.var);
27501 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
27502
27503 }
27504 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
27505 if (Z_ISREF_P(orig_object_ptr)
27506 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
27507 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
27508 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27509
27510 UNDEF_RESULT();
27511 } else {
27512 HashTable *ht = zend_new_array(8);
27513 uint8_t old_type = Z_TYPE_P(object_ptr);
27514
27515 ZVAL_ARR(object_ptr, ht);
27516 if (UNEXPECTED(old_type == IS_FALSE)) {
27517 GC_ADDREF(ht);
27518 zend_false_to_array_deprecated();
27519 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
27520 zend_array_destroy(ht);
27521 goto assign_dim_error;
27522 }
27523 }
27524 goto try_assign_dim_array;
27525 }
27526 } else {
27527 zend_use_scalar_as_array();
27528 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27529 assign_dim_error:
27530
27531 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
27532 ZVAL_NULL(EX_VAR(opline->result.var));
27533 }
27534 }
27535 }
27536 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27537 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27538 }
27539 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27540 /* assign_dim has two opcodes! */
27541 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27542 }
27543
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27544 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27545 {
27546 USE_OPLINE
27547 zval *property, *container, *value_ptr;
27548
27549 SAVE_OPLINE();
27550
27551 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27552 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27553
27554 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
27555
27556 if (1) {
27557 if (IS_VAR == IS_UNUSED) {
27558 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27559 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27560 } else {
27561 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27562 }
27563 } else {
27564 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27565 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27566 } else {
27567 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27568 }
27569 }
27570 } else {
27571 zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
27572 }
27573
27574 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27575 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27576 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
27577 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27578 }
27579
27580 /* 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)27581 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27582 {
27583 USE_OPLINE
27584 zval *property, *container, *value_ptr;
27585
27586 SAVE_OPLINE();
27587
27588 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27589 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27590
27591 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
27592
27593 if (1) {
27594 if (IS_VAR == IS_UNUSED) {
27595 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27596 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27597 } else {
27598 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27599 }
27600 } else {
27601 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27602 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27603 } else {
27604 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
27605 }
27606 }
27607 } else {
27608 zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
27609 }
27610
27611 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27612 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27613
27614 ZEND_VM_NEXT_OPCODE_EX(1, 2);
27615 }
27616
27617 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27618 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27619 {
27620 USE_OPLINE
27621 zval *function_name;
27622 zend_class_entry *ce;
27623 uint32_t call_info;
27624 zend_function *fbc;
27625 zend_execute_data *call;
27626
27627 SAVE_OPLINE();
27628
27629 if (IS_VAR == IS_CONST) {
27630 /* no function found. try a static method in class */
27631 ce = CACHED_PTR(opline->result.num);
27632 if (UNEXPECTED(ce == NULL)) {
27633 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);
27634 if (UNEXPECTED(ce == NULL)) {
27635 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27636 HANDLE_EXCEPTION();
27637 }
27638 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27639 CACHE_PTR(opline->result.num, ce);
27640 }
27641 }
27642 } else if (IS_VAR == IS_UNUSED) {
27643 ce = zend_fetch_class(NULL, opline->op1.num);
27644 if (UNEXPECTED(ce == NULL)) {
27645 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27646 HANDLE_EXCEPTION();
27647 }
27648 } else {
27649 ce = Z_CE_P(EX_VAR(opline->op1.var));
27650 }
27651
27652 if (IS_VAR == IS_CONST &&
27653 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
27654 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
27655 /* nothing to do */
27656 } else if (IS_VAR != IS_CONST &&
27657 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
27658 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
27659 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
27660 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27661 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27662 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27663 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
27664 do {
27665 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
27666 function_name = Z_REFVAL_P(function_name);
27667 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
27668 break;
27669 }
27670 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
27671 ZVAL_UNDEFINED_OP2();
27672 if (UNEXPECTED(EG(exception) != NULL)) {
27673 HANDLE_EXCEPTION();
27674 }
27675 }
27676 zend_throw_error(NULL, "Method name must be a string");
27677 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27678 HANDLE_EXCEPTION();
27679 } while (0);
27680 }
27681 }
27682
27683 if (ce->get_static_method) {
27684 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
27685 } else {
27686 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));
27687 }
27688 if (UNEXPECTED(fbc == NULL)) {
27689 if (EXPECTED(!EG(exception))) {
27690 zend_undefined_method(ce, Z_STR_P(function_name));
27691 }
27692 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27693 HANDLE_EXCEPTION();
27694 }
27695 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
27696 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
27697 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
27698 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
27699 }
27700 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
27701 init_func_run_time_cache(&fbc->op_array);
27702 }
27703 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27704 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27705 }
27706 } else {
27707 if (UNEXPECTED(ce->constructor == NULL)) {
27708 zend_throw_error(NULL, "Cannot call constructor");
27709 HANDLE_EXCEPTION();
27710 }
27711 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
27712 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
27713 HANDLE_EXCEPTION();
27714 }
27715 fbc = ce->constructor;
27716 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
27717 init_func_run_time_cache(&fbc->op_array);
27718 }
27719 }
27720
27721 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
27722 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
27723 ce = (zend_class_entry*)Z_OBJ(EX(This));
27724 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
27725 } else {
27726 zend_non_static_method_call(fbc);
27727 HANDLE_EXCEPTION();
27728 }
27729 } else {
27730 /* previous opcode is ZEND_FETCH_CLASS */
27731 if (IS_VAR == IS_UNUSED
27732 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
27733 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
27734 if (Z_TYPE(EX(This)) == IS_OBJECT) {
27735 ce = Z_OBJCE(EX(This));
27736 } else {
27737 ce = Z_CE(EX(This));
27738 }
27739 }
27740 call_info = ZEND_CALL_NESTED_FUNCTION;
27741 }
27742
27743 call = zend_vm_stack_push_call_frame(call_info,
27744 fbc, opline->extended_value, ce);
27745 call->prev_execute_data = EX(call);
27746 EX(call) = call;
27747
27748 ZEND_VM_NEXT_OPCODE();
27749 }
27750
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27751 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27752 {
27753 USE_OPLINE
27754 zval *expr_ptr, new_expr;
27755
27756 SAVE_OPLINE();
27757 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
27758 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
27759 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27760 if (Z_ISREF_P(expr_ptr)) {
27761 Z_ADDREF_P(expr_ptr);
27762 } else {
27763 ZVAL_MAKE_REF_EX(expr_ptr, 2);
27764 }
27765 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27766 } else {
27767 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27768 if (IS_VAR == IS_TMP_VAR) {
27769 /* pass */
27770 } else if (IS_VAR == IS_CONST) {
27771 Z_TRY_ADDREF_P(expr_ptr);
27772 } else if (IS_VAR == IS_CV) {
27773 ZVAL_DEREF(expr_ptr);
27774 Z_TRY_ADDREF_P(expr_ptr);
27775 } else /* if (IS_VAR == IS_VAR) */ {
27776 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
27777 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
27778
27779 expr_ptr = Z_REFVAL_P(expr_ptr);
27780 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
27781 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
27782 expr_ptr = &new_expr;
27783 efree_size(ref, sizeof(zend_reference));
27784 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
27785 Z_ADDREF_P(expr_ptr);
27786 }
27787 }
27788 }
27789 }
27790
27791 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
27792 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27793 zend_string *str;
27794 zend_ulong hval;
27795
27796 add_again:
27797 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
27798 str = Z_STR_P(offset);
27799 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27800 if (ZEND_HANDLE_NUMERIC(str, hval)) {
27801 goto num_index;
27802 }
27803 }
27804 str_index:
27805 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
27806 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
27807 hval = Z_LVAL_P(offset);
27808 num_index:
27809 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
27810 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
27811 offset = Z_REFVAL_P(offset);
27812 goto add_again;
27813 } else if (Z_TYPE_P(offset) == IS_NULL) {
27814 str = ZSTR_EMPTY_ALLOC();
27815 goto str_index;
27816 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
27817 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
27818 goto num_index;
27819 } else if (Z_TYPE_P(offset) == IS_FALSE) {
27820 hval = 0;
27821 goto num_index;
27822 } else if (Z_TYPE_P(offset) == IS_TRUE) {
27823 hval = 1;
27824 goto num_index;
27825 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
27826 zend_use_resource_as_offset(offset);
27827 hval = Z_RES_HANDLE_P(offset);
27828 goto num_index;
27829 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
27830 ZVAL_UNDEFINED_OP2();
27831 str = ZSTR_EMPTY_ALLOC();
27832 goto str_index;
27833 } else {
27834 zend_illegal_array_offset_access(offset);
27835 zval_ptr_dtor_nogc(expr_ptr);
27836 }
27837 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27838 } else {
27839 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
27840 zend_cannot_add_element();
27841 zval_ptr_dtor_nogc(expr_ptr);
27842 }
27843 }
27844 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27845 }
27846
ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27847 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27848 {
27849 zval *array;
27850 uint32_t size;
27851 USE_OPLINE
27852
27853 array = EX_VAR(opline->result.var);
27854 if (IS_VAR != IS_UNUSED) {
27855 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
27856 ZVAL_ARR(array, zend_new_array(size));
27857 /* Explicitly initialize array as not-packed if flag is set */
27858 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
27859 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
27860 }
27861 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
27862 } else {
27863 ZVAL_ARR(array, zend_new_array(0));
27864 ZEND_VM_NEXT_OPCODE();
27865 }
27866 }
27867
ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27868 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27869 {
27870 USE_OPLINE
27871 zval *container;
27872 zval *offset;
27873 zend_ulong hval;
27874 zend_string *key;
27875
27876 SAVE_OPLINE();
27877 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27878 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27879
27880 do {
27881 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
27882 HashTable *ht;
27883
27884 unset_dim_array:
27885 SEPARATE_ARRAY(container);
27886 ht = Z_ARRVAL_P(container);
27887 offset_again:
27888 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
27889 key = Z_STR_P(offset);
27890 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27891 if (ZEND_HANDLE_NUMERIC(key, hval)) {
27892 goto num_index_dim;
27893 }
27894 }
27895 str_index_dim:
27896 ZEND_ASSERT(ht != &EG(symbol_table));
27897 zend_hash_del(ht, key);
27898 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
27899 hval = Z_LVAL_P(offset);
27900 num_index_dim:
27901 zend_hash_index_del(ht, hval);
27902 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
27903 offset = Z_REFVAL_P(offset);
27904 goto offset_again;
27905 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
27906 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
27907 goto num_index_dim;
27908 } else if (Z_TYPE_P(offset) == IS_NULL) {
27909 key = ZSTR_EMPTY_ALLOC();
27910 goto str_index_dim;
27911 } else if (Z_TYPE_P(offset) == IS_FALSE) {
27912 hval = 0;
27913 goto num_index_dim;
27914 } else if (Z_TYPE_P(offset) == IS_TRUE) {
27915 hval = 1;
27916 goto num_index_dim;
27917 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
27918 zend_use_resource_as_offset(offset);
27919 hval = Z_RES_HANDLE_P(offset);
27920 goto num_index_dim;
27921 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
27922 ZVAL_UNDEFINED_OP2();
27923 key = ZSTR_EMPTY_ALLOC();
27924 goto str_index_dim;
27925 } else {
27926 zend_illegal_array_offset_unset(offset);
27927 }
27928 break;
27929 } else if (Z_ISREF_P(container)) {
27930 container = Z_REFVAL_P(container);
27931 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
27932 goto unset_dim_array;
27933 }
27934 }
27935 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
27936 container = ZVAL_UNDEFINED_OP1();
27937 }
27938 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
27939 offset = ZVAL_UNDEFINED_OP2();
27940 }
27941 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
27942 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
27943 offset++;
27944 }
27945 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
27946 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
27947 zend_throw_error(NULL, "Cannot unset string offsets");
27948 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
27949 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
27950 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
27951 zend_false_to_array_deprecated();
27952 }
27953 } while (0);
27954
27955 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
27956 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
27957 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
27958 }
27959
ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)27960 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
27961 {
27962 USE_OPLINE
27963 zval *container;
27964 zval *offset;
27965 zend_string *name, *tmp_name;
27966
27967 SAVE_OPLINE();
27968 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
27969 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
27970
27971 do {
27972 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
27973 if (Z_ISREF_P(container)) {
27974 container = Z_REFVAL_P(container);
27975 if (Z_TYPE_P(container) != IS_OBJECT) {
27976 if (IS_VAR == IS_CV
27977 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
27978 ZVAL_UNDEFINED_OP1();
27979 }
27980 break;
27981 }
27982 } else {
27983 break;
27984 }
27985 }
27986 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
27987 name = Z_STR_P(offset);
27988 } else {
27989 name = zval_try_get_tmp_string(offset, &tmp_name);
27990 if (UNEXPECTED(!name)) {
27991 break;
27992 }
27993 }
27994 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));
27995 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
27996 zend_tmp_string_release(tmp_name);
27997 }
27998 } while (0);
27999
28000 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28001 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28002 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28003 }
28004
ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28005 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28006 {
28007 USE_OPLINE
28008
28009 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
28010
28011 SAVE_OPLINE();
28012 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
28013 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28014 }
28015
28016 /* Destroy the previously yielded value */
28017 zval_ptr_dtor(&generator->value);
28018
28019 /* Destroy the previously yielded key */
28020 zval_ptr_dtor(&generator->key);
28021
28022 /* Set the new yielded value */
28023 if (IS_VAR != IS_UNUSED) {
28024 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
28025 /* Constants and temporary variables aren't yieldable by reference,
28026 * but we still allow them with a notice. */
28027 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
28028 zval *value;
28029
28030 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28031
28032 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28033 ZVAL_COPY_VALUE(&generator->value, value);
28034 if (IS_VAR == IS_CONST) {
28035 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28036 Z_ADDREF(generator->value);
28037 }
28038 }
28039 } else {
28040 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28041
28042 /* If a function call result is yielded and the function did
28043 * not return by reference we throw a notice. */
28044 do {
28045 if (IS_VAR == IS_VAR) {
28046 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
28047 if (opline->extended_value == ZEND_RETURNS_FUNCTION
28048 && !Z_ISREF_P(value_ptr)) {
28049 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
28050 ZVAL_COPY(&generator->value, value_ptr);
28051 break;
28052 }
28053 }
28054 if (Z_ISREF_P(value_ptr)) {
28055 Z_ADDREF_P(value_ptr);
28056 } else {
28057 ZVAL_MAKE_REF_EX(value_ptr, 2);
28058 }
28059 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
28060 } while (0);
28061
28062 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28063 }
28064 } else {
28065 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28066
28067 /* Consts, temporary variables and references need copying */
28068 if (IS_VAR == IS_CONST) {
28069 ZVAL_COPY_VALUE(&generator->value, value);
28070 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
28071 Z_ADDREF(generator->value);
28072 }
28073 } else if (IS_VAR == IS_TMP_VAR) {
28074 ZVAL_COPY_VALUE(&generator->value, value);
28075 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
28076 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
28077 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28078 } else {
28079 ZVAL_COPY_VALUE(&generator->value, value);
28080 if (IS_VAR == IS_CV) {
28081 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
28082 }
28083 }
28084 }
28085 } else {
28086 /* If no value was specified yield null */
28087 ZVAL_NULL(&generator->value);
28088 }
28089
28090 /* Set the new yielded key */
28091 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
28092 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28093 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
28094 key = Z_REFVAL_P(key);
28095 }
28096 ZVAL_COPY(&generator->key, key);
28097 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28098
28099 if (Z_TYPE(generator->key) == IS_LONG
28100 && Z_LVAL(generator->key) > generator->largest_used_integer_key
28101 ) {
28102 generator->largest_used_integer_key = Z_LVAL(generator->key);
28103 }
28104 } else {
28105 /* If no key was specified we use auto-increment keys */
28106 generator->largest_used_integer_key++;
28107 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
28108 }
28109
28110 if (RETURN_VALUE_USED(opline)) {
28111 /* If the return value of yield is used set the send
28112 * target and initialize it to NULL */
28113 generator->send_target = EX_VAR(opline->result.var);
28114 ZVAL_NULL(generator->send_target);
28115 } else {
28116 generator->send_target = NULL;
28117 }
28118
28119 /* We increment to the next op, so we are at the correct position when the
28120 * generator is resumed. */
28121 ZEND_VM_INC_OPCODE();
28122
28123 /* The GOTO VM uses a local opline variable. We need to set the opline
28124 * variable in execute_data so we don't resume at an old position. */
28125 SAVE_OPLINE();
28126
28127 ZEND_VM_RETURN();
28128 }
28129
ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28130 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28131 {
28132 USE_OPLINE
28133 zval *op1, *op2;
28134 bool result;
28135
28136 SAVE_OPLINE();
28137 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28138 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28139 result = fast_is_identical_function(op1, op2);
28140 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28141 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28142 ZEND_VM_SMART_BRANCH(result, 1);
28143 }
28144
ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28145 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28146 {
28147 USE_OPLINE
28148 zval *op1, *op2;
28149 bool result;
28150
28151 SAVE_OPLINE();
28152 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28153 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28154 result = fast_is_identical_function(op1, op2);
28155 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28156 ZEND_VM_SMART_BRANCH(result, 1);
28157 }
28158
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28159 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28160 {
28161 USE_OPLINE
28162 zval *op1, *op2;
28163 bool result;
28164
28165 SAVE_OPLINE();
28166 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28167 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28168 result = fast_is_not_identical_function(op1, op2);
28169 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28170 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28171 ZEND_VM_SMART_BRANCH(result, 1);
28172 }
28173
ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28174 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28175 {
28176 USE_OPLINE
28177 zval *value;
28178 zval *variable_ptr;
28179
28180 SAVE_OPLINE();
28181 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28182 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28183
28184 if (0 || UNEXPECTED(0)) {
28185 zend_refcounted *garbage = NULL;
28186
28187 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28188 if (UNEXPECTED(0)) {
28189 ZVAL_COPY(EX_VAR(opline->result.var), value);
28190 }
28191 if (garbage) {
28192 GC_DTOR_NO_REF(garbage);
28193 }
28194 } else {
28195 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
28196 }
28197 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28198 /* zend_assign_to_variable() always takes care of op2, never free it! */
28199
28200 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28201 }
28202
ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28203 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28204 {
28205 USE_OPLINE
28206 zval *value;
28207 zval *variable_ptr;
28208
28209 SAVE_OPLINE();
28210 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
28211 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28212
28213 if (0 || UNEXPECTED(1)) {
28214 zend_refcounted *garbage = NULL;
28215
28216 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28217 if (UNEXPECTED(1)) {
28218 ZVAL_COPY(EX_VAR(opline->result.var), value);
28219 }
28220 if (garbage) {
28221 GC_DTOR_NO_REF(garbage);
28222 }
28223 } else {
28224 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
28225 }
28226 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28227 /* zend_assign_to_variable() always takes care of op2, never free it! */
28228
28229 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28230 }
28231
ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28232 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28233 {
28234 USE_OPLINE
28235 zval *op1, *op2;
28236 bool result;
28237
28238 SAVE_OPLINE();
28239 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28240 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28241 result = fast_is_identical_function(op1, op2);
28242 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28243 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28244 ZEND_VM_SMART_BRANCH(result, 1);
28245 }
28246
ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28247 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28248 {
28249 USE_OPLINE
28250 zval *op1, *op2;
28251 bool result;
28252
28253 SAVE_OPLINE();
28254 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28255 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28256 result = fast_is_identical_function(op1, op2);
28257 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28258 ZEND_VM_SMART_BRANCH(result, 1);
28259 }
28260
ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28261 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28262 {
28263 USE_OPLINE
28264 zval *op1, *op2;
28265 bool result;
28266
28267 SAVE_OPLINE();
28268 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
28269 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
28270 result = fast_is_not_identical_function(op1, op2);
28271 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28272 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28273 ZEND_VM_SMART_BRANCH(result, 1);
28274 }
28275
ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28276 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28277 {
28278 USE_OPLINE
28279 zval *value;
28280 zval *variable_ptr;
28281
28282 SAVE_OPLINE();
28283 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28284 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28285
28286 if (0 || UNEXPECTED(0)) {
28287 zend_refcounted *garbage = NULL;
28288
28289 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
28290 if (UNEXPECTED(0)) {
28291 ZVAL_COPY(EX_VAR(opline->result.var), value);
28292 }
28293 if (garbage) {
28294 GC_DTOR_NO_REF(garbage);
28295 }
28296 } else {
28297 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
28298 }
28299 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28300 /* zend_assign_to_variable() always takes care of op2, never free it! */
28301
28302 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28303 }
28304
ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28305 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28306 {
28307 USE_OPLINE
28308 zval *value;
28309 zval *variable_ptr;
28310
28311 SAVE_OPLINE();
28312 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28313 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28314
28315 if (0 || UNEXPECTED(1)) {
28316 zend_refcounted *garbage = NULL;
28317
28318 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
28319 if (UNEXPECTED(1)) {
28320 ZVAL_COPY(EX_VAR(opline->result.var), value);
28321 }
28322 if (garbage) {
28323 GC_DTOR_NO_REF(garbage);
28324 }
28325 } else {
28326 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
28327 }
28328 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28329 /* zend_assign_to_variable() always takes care of op2, never free it! */
28330
28331 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28332 }
28333
ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28334 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28335 {
28336 USE_OPLINE
28337 zval *variable_ptr;
28338 zval *value_ptr;
28339 zend_refcounted *garbage = NULL;
28340
28341 SAVE_OPLINE();
28342 value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
28343 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28344
28345 if (IS_VAR == IS_VAR &&
28346 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
28347
28348 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
28349 variable_ptr = &EG(uninitialized_zval);
28350 } else if (IS_VAR == IS_VAR &&
28351 opline->extended_value == ZEND_RETURNS_FUNCTION &&
28352 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
28353
28354 variable_ptr = zend_wrong_assign_to_variable_reference(
28355 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
28356 } else {
28357 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
28358 }
28359
28360 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28361 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
28362 }
28363
28364 if (garbage) {
28365 GC_DTOR(garbage);
28366 }
28367
28368 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
28369 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28370 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28371 }
28372
ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28373 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28374 {
28375 USE_OPLINE
28376 zval *var_ptr;
28377 zval *value, *container, *dim;
28378 HashTable *ht;
28379
28380 SAVE_OPLINE();
28381 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28382
28383 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28384 assign_dim_op_array:
28385 SEPARATE_ARRAY(container);
28386 ht = Z_ARRVAL_P(container);
28387 assign_dim_op_new_array:
28388 dim = NULL;
28389 if (IS_UNUSED == IS_UNUSED) {
28390 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
28391 if (UNEXPECTED(!var_ptr)) {
28392 zend_cannot_add_element();
28393 goto assign_dim_op_ret_null;
28394 }
28395 } else {
28396 if (IS_UNUSED == IS_CONST) {
28397 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
28398 } else {
28399 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
28400 }
28401 if (UNEXPECTED(!var_ptr)) {
28402 goto assign_dim_op_ret_null;
28403 }
28404 }
28405
28406 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
28407
28408 do {
28409 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
28410 zend_reference *ref = Z_REF_P(var_ptr);
28411 var_ptr = Z_REFVAL_P(var_ptr);
28412 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
28413 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
28414 break;
28415 }
28416 }
28417 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
28418 } while (0);
28419
28420 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28421 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
28422 }
28423 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
28424 } else {
28425 if (EXPECTED(Z_ISREF_P(container))) {
28426 container = Z_REFVAL_P(container);
28427 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
28428 goto assign_dim_op_array;
28429 }
28430 }
28431
28432 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
28433 zend_object *obj = Z_OBJ_P(container);
28434
28435 dim = NULL;
28436 if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28437 dim++;
28438 }
28439 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
28440 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
28441 uint8_t old_type;
28442
28443 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
28444 ZVAL_UNDEFINED_OP1();
28445 }
28446 ht = zend_new_array(8);
28447 old_type = Z_TYPE_P(container);
28448 ZVAL_ARR(container, ht);
28449 if (UNEXPECTED(old_type == IS_FALSE)) {
28450 GC_ADDREF(ht);
28451 zend_false_to_array_deprecated();
28452 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28453 zend_array_destroy(ht);
28454 goto assign_dim_op_ret_null;
28455 }
28456 }
28457 goto assign_dim_op_new_array;
28458 } else {
28459 dim = NULL;
28460 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
28461 assign_dim_op_ret_null:
28462 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
28463 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28464 ZVAL_NULL(EX_VAR(opline->result.var));
28465 }
28466 }
28467 }
28468
28469 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28470 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28471 }
28472
ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28473 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28474 {
28475 USE_OPLINE
28476 zval *container;
28477
28478 SAVE_OPLINE();
28479 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28480 zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
28481
28482 if (IS_VAR == IS_VAR) {
28483 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
28484 }
28485 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28486 }
28487
ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28488 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28489 {
28490 USE_OPLINE
28491 zval *container;
28492
28493 SAVE_OPLINE();
28494 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28495 zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
28496
28497 if (IS_VAR == IS_VAR) {
28498 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
28499 }
28500 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
28501 }
28502
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28503 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28504 {
28505 #if 0
28506 USE_OPLINE
28507 #endif
28508
28509 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
28510 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
28511 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28512 }
28513 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28514 } else {
28515 if (IS_UNUSED == IS_UNUSED) {
28516 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28517 }
28518 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
28519 }
28520 }
28521
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28522 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28523 {
28524 USE_OPLINE
28525 zval *object_ptr, *orig_object_ptr;
28526 zval *value;
28527 zval *variable_ptr;
28528 zval *dim;
28529 zend_refcounted *garbage = NULL;
28530
28531 SAVE_OPLINE();
28532 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28533
28534 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28535 try_assign_dim_array:
28536 SEPARATE_ARRAY(object_ptr);
28537 if (IS_UNUSED == IS_UNUSED) {
28538 value = RT_CONSTANT((opline+1), (opline+1)->op1);
28539 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28540 HashTable *ht = Z_ARRVAL_P(object_ptr);
28541 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28542 GC_ADDREF(ht);
28543 }
28544 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28545 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28546 zend_array_destroy(ht);
28547 goto assign_dim_error;
28548 }
28549 }
28550 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
28551 ZVAL_DEREF(value);
28552 }
28553 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28554 if (UNEXPECTED(value == NULL)) {
28555 zend_cannot_add_element();
28556 goto assign_dim_error;
28557 } else if (IS_CONST == IS_CV) {
28558 if (Z_REFCOUNTED_P(value)) {
28559 Z_ADDREF_P(value);
28560 }
28561 } else if (IS_CONST == IS_VAR) {
28562 zval *free_op_data = EX_VAR((opline+1)->op1.var);
28563 if (Z_ISREF_P(free_op_data)) {
28564 if (Z_REFCOUNTED_P(value)) {
28565 Z_ADDREF_P(value);
28566 }
28567 zval_ptr_dtor_nogc(free_op_data);
28568 }
28569 } else if (IS_CONST == IS_CONST) {
28570 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28571 Z_ADDREF_P(value);
28572 }
28573 }
28574 } else {
28575 dim = NULL;
28576 if (IS_UNUSED == IS_CONST) {
28577 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28578 } else {
28579 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28580 }
28581 if (UNEXPECTED(variable_ptr == NULL)) {
28582 goto assign_dim_error;
28583 }
28584 value = RT_CONSTANT((opline+1), (opline+1)->op1);
28585 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
28586 }
28587 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28588 ZVAL_COPY(EX_VAR(opline->result.var), value);
28589 }
28590 if (garbage) {
28591 GC_DTOR_NO_REF(garbage);
28592 }
28593 } else {
28594 if (EXPECTED(Z_ISREF_P(object_ptr))) {
28595 object_ptr = Z_REFVAL_P(object_ptr);
28596 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28597 goto try_assign_dim_array;
28598 }
28599 }
28600 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28601 zend_object *obj = Z_OBJ_P(object_ptr);
28602
28603 GC_ADDREF(obj);
28604 dim = NULL;
28605 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28606 dim = ZVAL_UNDEFINED_OP2();
28607 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28608 dim++;
28609 }
28610
28611 value = RT_CONSTANT((opline+1), (opline+1)->op1);
28612 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28613 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28614 } else if (IS_CONST & (IS_CV|IS_VAR)) {
28615 ZVAL_DEREF(value);
28616 }
28617
28618 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28619
28620 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28621 zend_objects_store_del(obj);
28622 }
28623 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28624 if (IS_UNUSED == IS_UNUSED) {
28625 zend_use_new_element_for_string();
28626
28627 UNDEF_RESULT();
28628 } else {
28629 dim = NULL;
28630 value = RT_CONSTANT((opline+1), (opline+1)->op1);
28631 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28632
28633 }
28634 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28635 if (Z_ISREF_P(orig_object_ptr)
28636 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28637 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28638 dim = NULL;
28639
28640 UNDEF_RESULT();
28641 } else {
28642 HashTable *ht = zend_new_array(8);
28643 uint8_t old_type = Z_TYPE_P(object_ptr);
28644
28645 ZVAL_ARR(object_ptr, ht);
28646 if (UNEXPECTED(old_type == IS_FALSE)) {
28647 GC_ADDREF(ht);
28648 zend_false_to_array_deprecated();
28649 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28650 zend_array_destroy(ht);
28651 goto assign_dim_error;
28652 }
28653 }
28654 goto try_assign_dim_array;
28655 }
28656 } else {
28657 zend_use_scalar_as_array();
28658 dim = NULL;
28659 assign_dim_error:
28660
28661 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28662 ZVAL_NULL(EX_VAR(opline->result.var));
28663 }
28664 }
28665 }
28666 if (IS_UNUSED != IS_UNUSED) {
28667
28668 }
28669 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28670 /* assign_dim has two opcodes! */
28671 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28672 }
28673
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28674 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28675 {
28676 USE_OPLINE
28677 zval *object_ptr, *orig_object_ptr;
28678 zval *value;
28679 zval *variable_ptr;
28680 zval *dim;
28681 zend_refcounted *garbage = NULL;
28682
28683 SAVE_OPLINE();
28684 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28685
28686 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28687 try_assign_dim_array:
28688 SEPARATE_ARRAY(object_ptr);
28689 if (IS_UNUSED == IS_UNUSED) {
28690 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
28691 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28692 HashTable *ht = Z_ARRVAL_P(object_ptr);
28693 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28694 GC_ADDREF(ht);
28695 }
28696 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28697 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28698 zend_array_destroy(ht);
28699 goto assign_dim_error;
28700 }
28701 }
28702 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
28703 ZVAL_DEREF(value);
28704 }
28705 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28706 if (UNEXPECTED(value == NULL)) {
28707 zend_cannot_add_element();
28708 goto assign_dim_error;
28709 } else if (IS_TMP_VAR == IS_CV) {
28710 if (Z_REFCOUNTED_P(value)) {
28711 Z_ADDREF_P(value);
28712 }
28713 } else if (IS_TMP_VAR == IS_VAR) {
28714 zval *free_op_data = EX_VAR((opline+1)->op1.var);
28715 if (Z_ISREF_P(free_op_data)) {
28716 if (Z_REFCOUNTED_P(value)) {
28717 Z_ADDREF_P(value);
28718 }
28719 zval_ptr_dtor_nogc(free_op_data);
28720 }
28721 } else if (IS_TMP_VAR == IS_CONST) {
28722 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28723 Z_ADDREF_P(value);
28724 }
28725 }
28726 } else {
28727 dim = NULL;
28728 if (IS_UNUSED == IS_CONST) {
28729 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28730 } else {
28731 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28732 }
28733 if (UNEXPECTED(variable_ptr == NULL)) {
28734 goto assign_dim_error;
28735 }
28736 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
28737 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
28738 }
28739 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28740 ZVAL_COPY(EX_VAR(opline->result.var), value);
28741 }
28742 if (garbage) {
28743 GC_DTOR_NO_REF(garbage);
28744 }
28745 } else {
28746 if (EXPECTED(Z_ISREF_P(object_ptr))) {
28747 object_ptr = Z_REFVAL_P(object_ptr);
28748 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28749 goto try_assign_dim_array;
28750 }
28751 }
28752 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28753 zend_object *obj = Z_OBJ_P(object_ptr);
28754
28755 GC_ADDREF(obj);
28756 dim = NULL;
28757 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28758 dim = ZVAL_UNDEFINED_OP2();
28759 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28760 dim++;
28761 }
28762
28763 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
28764 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28765 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28766 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
28767 ZVAL_DEREF(value);
28768 }
28769
28770 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28771
28772 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28773 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28774 zend_objects_store_del(obj);
28775 }
28776 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28777 if (IS_UNUSED == IS_UNUSED) {
28778 zend_use_new_element_for_string();
28779 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28780 UNDEF_RESULT();
28781 } else {
28782 dim = NULL;
28783 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
28784 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28785 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28786 }
28787 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28788 if (Z_ISREF_P(orig_object_ptr)
28789 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28790 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28791 dim = NULL;
28792 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28793 UNDEF_RESULT();
28794 } else {
28795 HashTable *ht = zend_new_array(8);
28796 uint8_t old_type = Z_TYPE_P(object_ptr);
28797
28798 ZVAL_ARR(object_ptr, ht);
28799 if (UNEXPECTED(old_type == IS_FALSE)) {
28800 GC_ADDREF(ht);
28801 zend_false_to_array_deprecated();
28802 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28803 zend_array_destroy(ht);
28804 goto assign_dim_error;
28805 }
28806 }
28807 goto try_assign_dim_array;
28808 }
28809 } else {
28810 zend_use_scalar_as_array();
28811 dim = NULL;
28812 assign_dim_error:
28813 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28814 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28815 ZVAL_NULL(EX_VAR(opline->result.var));
28816 }
28817 }
28818 }
28819 if (IS_UNUSED != IS_UNUSED) {
28820
28821 }
28822 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28823 /* assign_dim has two opcodes! */
28824 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28825 }
28826
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28827 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28828 {
28829 USE_OPLINE
28830 zval *object_ptr, *orig_object_ptr;
28831 zval *value;
28832 zval *variable_ptr;
28833 zval *dim;
28834 zend_refcounted *garbage = NULL;
28835
28836 SAVE_OPLINE();
28837 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28838
28839 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28840 try_assign_dim_array:
28841 SEPARATE_ARRAY(object_ptr);
28842 if (IS_UNUSED == IS_UNUSED) {
28843 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28844 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28845 HashTable *ht = Z_ARRVAL_P(object_ptr);
28846 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
28847 GC_ADDREF(ht);
28848 }
28849 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28850 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
28851 zend_array_destroy(ht);
28852 goto assign_dim_error;
28853 }
28854 }
28855 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
28856 ZVAL_DEREF(value);
28857 }
28858 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
28859 if (UNEXPECTED(value == NULL)) {
28860 zend_cannot_add_element();
28861 goto assign_dim_error;
28862 } else if (IS_VAR == IS_CV) {
28863 if (Z_REFCOUNTED_P(value)) {
28864 Z_ADDREF_P(value);
28865 }
28866 } else if (IS_VAR == IS_VAR) {
28867 zval *free_op_data = EX_VAR((opline+1)->op1.var);
28868 if (Z_ISREF_P(free_op_data)) {
28869 if (Z_REFCOUNTED_P(value)) {
28870 Z_ADDREF_P(value);
28871 }
28872 zval_ptr_dtor_nogc(free_op_data);
28873 }
28874 } else if (IS_VAR == IS_CONST) {
28875 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
28876 Z_ADDREF_P(value);
28877 }
28878 }
28879 } else {
28880 dim = NULL;
28881 if (IS_UNUSED == IS_CONST) {
28882 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28883 } else {
28884 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
28885 }
28886 if (UNEXPECTED(variable_ptr == NULL)) {
28887 goto assign_dim_error;
28888 }
28889 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28890 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
28891 }
28892 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28893 ZVAL_COPY(EX_VAR(opline->result.var), value);
28894 }
28895 if (garbage) {
28896 GC_DTOR_NO_REF(garbage);
28897 }
28898 } else {
28899 if (EXPECTED(Z_ISREF_P(object_ptr))) {
28900 object_ptr = Z_REFVAL_P(object_ptr);
28901 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28902 goto try_assign_dim_array;
28903 }
28904 }
28905 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
28906 zend_object *obj = Z_OBJ_P(object_ptr);
28907
28908 GC_ADDREF(obj);
28909 dim = NULL;
28910 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
28911 dim = ZVAL_UNDEFINED_OP2();
28912 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
28913 dim++;
28914 }
28915
28916 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28917 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
28918 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
28919 } else if (IS_VAR & (IS_CV|IS_VAR)) {
28920 ZVAL_DEREF(value);
28921 }
28922
28923 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
28924
28925 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28926 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
28927 zend_objects_store_del(obj);
28928 }
28929 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
28930 if (IS_UNUSED == IS_UNUSED) {
28931 zend_use_new_element_for_string();
28932 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28933 UNDEF_RESULT();
28934 } else {
28935 dim = NULL;
28936 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
28937 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
28938 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28939 }
28940 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
28941 if (Z_ISREF_P(orig_object_ptr)
28942 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
28943 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
28944 dim = NULL;
28945 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28946 UNDEF_RESULT();
28947 } else {
28948 HashTable *ht = zend_new_array(8);
28949 uint8_t old_type = Z_TYPE_P(object_ptr);
28950
28951 ZVAL_ARR(object_ptr, ht);
28952 if (UNEXPECTED(old_type == IS_FALSE)) {
28953 GC_ADDREF(ht);
28954 zend_false_to_array_deprecated();
28955 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
28956 zend_array_destroy(ht);
28957 goto assign_dim_error;
28958 }
28959 }
28960 goto try_assign_dim_array;
28961 }
28962 } else {
28963 zend_use_scalar_as_array();
28964 dim = NULL;
28965 assign_dim_error:
28966 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
28967 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
28968 ZVAL_NULL(EX_VAR(opline->result.var));
28969 }
28970 }
28971 }
28972 if (IS_UNUSED != IS_UNUSED) {
28973
28974 }
28975 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
28976 /* assign_dim has two opcodes! */
28977 ZEND_VM_NEXT_OPCODE_EX(1, 2);
28978 }
28979
ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)28980 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
28981 {
28982 USE_OPLINE
28983 zval *object_ptr, *orig_object_ptr;
28984 zval *value;
28985 zval *variable_ptr;
28986 zval *dim;
28987 zend_refcounted *garbage = NULL;
28988
28989 SAVE_OPLINE();
28990 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
28991
28992 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
28993 try_assign_dim_array:
28994 SEPARATE_ARRAY(object_ptr);
28995 if (IS_UNUSED == IS_UNUSED) {
28996 value = EX_VAR((opline+1)->op1.var);
28997 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
28998 HashTable *ht = Z_ARRVAL_P(object_ptr);
28999 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
29000 GC_ADDREF(ht);
29001 }
29002 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29003 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
29004 zend_array_destroy(ht);
29005 goto assign_dim_error;
29006 }
29007 }
29008 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
29009 ZVAL_DEREF(value);
29010 }
29011 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
29012 if (UNEXPECTED(value == NULL)) {
29013 zend_cannot_add_element();
29014 goto assign_dim_error;
29015 } else if (IS_CV == IS_CV) {
29016 if (Z_REFCOUNTED_P(value)) {
29017 Z_ADDREF_P(value);
29018 }
29019 } else if (IS_CV == IS_VAR) {
29020 zval *free_op_data = EX_VAR((opline+1)->op1.var);
29021 if (Z_ISREF_P(free_op_data)) {
29022 if (Z_REFCOUNTED_P(value)) {
29023 Z_ADDREF_P(value);
29024 }
29025 zval_ptr_dtor_nogc(free_op_data);
29026 }
29027 } else if (IS_CV == IS_CONST) {
29028 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
29029 Z_ADDREF_P(value);
29030 }
29031 }
29032 } else {
29033 dim = NULL;
29034 if (IS_UNUSED == IS_CONST) {
29035 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29036 } else {
29037 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
29038 }
29039 if (UNEXPECTED(variable_ptr == NULL)) {
29040 goto assign_dim_error;
29041 }
29042 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
29043 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
29044 }
29045 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29046 ZVAL_COPY(EX_VAR(opline->result.var), value);
29047 }
29048 if (garbage) {
29049 GC_DTOR_NO_REF(garbage);
29050 }
29051 } else {
29052 if (EXPECTED(Z_ISREF_P(object_ptr))) {
29053 object_ptr = Z_REFVAL_P(object_ptr);
29054 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
29055 goto try_assign_dim_array;
29056 }
29057 }
29058 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
29059 zend_object *obj = Z_OBJ_P(object_ptr);
29060
29061 GC_ADDREF(obj);
29062 dim = NULL;
29063 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
29064 dim = ZVAL_UNDEFINED_OP2();
29065 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
29066 dim++;
29067 }
29068
29069 value = EX_VAR((opline+1)->op1.var);
29070 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
29071 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
29072 } else if (IS_CV & (IS_CV|IS_VAR)) {
29073 ZVAL_DEREF(value);
29074 }
29075
29076 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
29077
29078 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
29079 zend_objects_store_del(obj);
29080 }
29081 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
29082 if (IS_UNUSED == IS_UNUSED) {
29083 zend_use_new_element_for_string();
29084
29085 UNDEF_RESULT();
29086 } else {
29087 dim = NULL;
29088 value = EX_VAR((opline+1)->op1.var);
29089 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
29090
29091 }
29092 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
29093 if (Z_ISREF_P(orig_object_ptr)
29094 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
29095 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
29096 dim = NULL;
29097
29098 UNDEF_RESULT();
29099 } else {
29100 HashTable *ht = zend_new_array(8);
29101 uint8_t old_type = Z_TYPE_P(object_ptr);
29102
29103 ZVAL_ARR(object_ptr, ht);
29104 if (UNEXPECTED(old_type == IS_FALSE)) {
29105 GC_ADDREF(ht);
29106 zend_false_to_array_deprecated();
29107 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
29108 zend_array_destroy(ht);
29109 goto assign_dim_error;
29110 }
29111 }
29112 goto try_assign_dim_array;
29113 }
29114 } else {
29115 zend_use_scalar_as_array();
29116 dim = NULL;
29117 assign_dim_error:
29118
29119 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
29120 ZVAL_NULL(EX_VAR(opline->result.var));
29121 }
29122 }
29123 }
29124 if (IS_UNUSED != IS_UNUSED) {
29125
29126 }
29127 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29128 /* assign_dim has two opcodes! */
29129 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29130 }
29131
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29132 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29133 {
29134 USE_OPLINE
29135 zval *function_name;
29136 zend_class_entry *ce;
29137 uint32_t call_info;
29138 zend_function *fbc;
29139 zend_execute_data *call;
29140
29141 SAVE_OPLINE();
29142
29143 if (IS_VAR == IS_CONST) {
29144 /* no function found. try a static method in class */
29145 ce = CACHED_PTR(opline->result.num);
29146 if (UNEXPECTED(ce == NULL)) {
29147 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);
29148 if (UNEXPECTED(ce == NULL)) {
29149
29150 HANDLE_EXCEPTION();
29151 }
29152 if (IS_UNUSED != IS_CONST) {
29153 CACHE_PTR(opline->result.num, ce);
29154 }
29155 }
29156 } else if (IS_VAR == IS_UNUSED) {
29157 ce = zend_fetch_class(NULL, opline->op1.num);
29158 if (UNEXPECTED(ce == NULL)) {
29159
29160 HANDLE_EXCEPTION();
29161 }
29162 } else {
29163 ce = Z_CE_P(EX_VAR(opline->op1.var));
29164 }
29165
29166 if (IS_VAR == IS_CONST &&
29167 IS_UNUSED == IS_CONST &&
29168 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
29169 /* nothing to do */
29170 } else if (IS_VAR != IS_CONST &&
29171 IS_UNUSED == IS_CONST &&
29172 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
29173 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
29174 } else if (IS_UNUSED != IS_UNUSED) {
29175 function_name = NULL;
29176 if (IS_UNUSED != IS_CONST) {
29177 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
29178 do {
29179 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
29180 function_name = Z_REFVAL_P(function_name);
29181 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
29182 break;
29183 }
29184 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
29185 ZVAL_UNDEFINED_OP2();
29186 if (UNEXPECTED(EG(exception) != NULL)) {
29187 HANDLE_EXCEPTION();
29188 }
29189 }
29190 zend_throw_error(NULL, "Method name must be a string");
29191
29192 HANDLE_EXCEPTION();
29193 } while (0);
29194 }
29195 }
29196
29197 if (ce->get_static_method) {
29198 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
29199 } else {
29200 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
29201 }
29202 if (UNEXPECTED(fbc == NULL)) {
29203 if (EXPECTED(!EG(exception))) {
29204 zend_undefined_method(ce, Z_STR_P(function_name));
29205 }
29206
29207 HANDLE_EXCEPTION();
29208 }
29209 if (IS_UNUSED == IS_CONST &&
29210 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
29211 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
29212 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
29213 }
29214 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
29215 init_func_run_time_cache(&fbc->op_array);
29216 }
29217 if (IS_UNUSED != IS_CONST) {
29218
29219 }
29220 } else {
29221 if (UNEXPECTED(ce->constructor == NULL)) {
29222 zend_throw_error(NULL, "Cannot call constructor");
29223 HANDLE_EXCEPTION();
29224 }
29225 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
29226 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
29227 HANDLE_EXCEPTION();
29228 }
29229 fbc = ce->constructor;
29230 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
29231 init_func_run_time_cache(&fbc->op_array);
29232 }
29233 }
29234
29235 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
29236 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
29237 ce = (zend_class_entry*)Z_OBJ(EX(This));
29238 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
29239 } else {
29240 zend_non_static_method_call(fbc);
29241 HANDLE_EXCEPTION();
29242 }
29243 } else {
29244 /* previous opcode is ZEND_FETCH_CLASS */
29245 if (IS_VAR == IS_UNUSED
29246 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
29247 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
29248 if (Z_TYPE(EX(This)) == IS_OBJECT) {
29249 ce = Z_OBJCE(EX(This));
29250 } else {
29251 ce = Z_CE(EX(This));
29252 }
29253 }
29254 call_info = ZEND_CALL_NESTED_FUNCTION;
29255 }
29256
29257 call = zend_vm_stack_push_call_frame(call_info,
29258 fbc, opline->extended_value, ce);
29259 call->prev_execute_data = EX(call);
29260 EX(call) = call;
29261
29262 ZEND_VM_NEXT_OPCODE();
29263 }
29264
ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29265 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29266 {
29267 if (IS_VAR == IS_UNUSED) {
29268 SAVE_OPLINE();
29269 zend_verify_missing_return_type(EX(func));
29270 HANDLE_EXCEPTION();
29271 } else {
29272 /* prevents "undefined variable opline" errors */
29273 #if 0 || (IS_VAR != IS_UNUSED)
29274 USE_OPLINE
29275 zval *retval_ref, *retval_ptr;
29276 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
29277 retval_ref = retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29278
29279 if (IS_VAR == IS_CONST) {
29280 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
29281 retval_ref = retval_ptr = EX_VAR(opline->result.var);
29282 } else if (IS_VAR == IS_VAR) {
29283 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
29284 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
29285 }
29286 ZVAL_DEREF(retval_ptr);
29287 } else if (IS_VAR == IS_CV) {
29288 ZVAL_DEREF(retval_ptr);
29289 }
29290
29291 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
29292 ZEND_VM_NEXT_OPCODE();
29293 }
29294
29295 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
29296 SAVE_OPLINE();
29297 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
29298 if (UNEXPECTED(EG(exception))) {
29299 HANDLE_EXCEPTION();
29300 }
29301 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
29302 ZEND_VM_NEXT_OPCODE();
29303 }
29304 }
29305
29306 zend_reference *ref = NULL;
29307 void *cache_slot = CACHE_ADDR(opline->op2.num);
29308 if (UNEXPECTED(retval_ref != retval_ptr)) {
29309 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
29310 ref = Z_REF_P(retval_ref);
29311 } else {
29312 /* A cast might happen - unwrap the reference if this is a by-value return */
29313 if (Z_REFCOUNT_P(retval_ref) == 1) {
29314 ZVAL_UNREF(retval_ref);
29315 } else {
29316 Z_DELREF_P(retval_ref);
29317 ZVAL_COPY(retval_ref, retval_ptr);
29318 }
29319 retval_ptr = retval_ref;
29320 }
29321 }
29322
29323 SAVE_OPLINE();
29324 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
29325 zend_verify_return_error(EX(func), retval_ptr);
29326 HANDLE_EXCEPTION();
29327 }
29328 ZEND_VM_NEXT_OPCODE();
29329 #endif
29330 }
29331 }
29332
ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29333 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29334 {
29335 USE_OPLINE
29336 zval *varptr, *arg;
29337
29338 if (IS_UNUSED == IS_CONST) {
29339 SAVE_OPLINE();
29340 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29341 uint32_t arg_num;
29342 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29343 if (UNEXPECTED(!arg)) {
29344 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29345 HANDLE_EXCEPTION();
29346 }
29347 } else {
29348 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29349 }
29350
29351 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29352 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
29353 SAVE_OPLINE();
29354 ZVAL_UNDEFINED_OP1();
29355 ZVAL_NULL(arg);
29356 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29357 }
29358
29359 if (IS_VAR == IS_CV) {
29360 ZVAL_COPY_DEREF(arg, varptr);
29361 } else /* if (IS_VAR == IS_VAR) */ {
29362 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29363 zend_refcounted *ref = Z_COUNTED_P(varptr);
29364
29365 varptr = Z_REFVAL_P(varptr);
29366 ZVAL_COPY_VALUE(arg, varptr);
29367 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29368 efree_size(ref, sizeof(zend_reference));
29369 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29370 Z_ADDREF_P(arg);
29371 }
29372 } else {
29373 ZVAL_COPY_VALUE(arg, varptr);
29374 }
29375 }
29376
29377 ZEND_VM_NEXT_OPCODE();
29378 }
29379
ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29380 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29381 {
29382 USE_OPLINE
29383 zval *varptr, *arg;
29384
29385 if (IS_UNUSED == IS_CONST) {
29386 SAVE_OPLINE();
29387 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29388 uint32_t arg_num;
29389 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29390 if (UNEXPECTED(!arg)) {
29391 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29392 HANDLE_EXCEPTION();
29393 }
29394 } else {
29395 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29396 }
29397
29398 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29399 ZVAL_COPY_VALUE(arg, varptr);
29400
29401 if (EXPECTED(Z_ISREF_P(varptr))) {
29402 ZEND_VM_NEXT_OPCODE();
29403 }
29404
29405 SAVE_OPLINE();
29406 ZVAL_NEW_REF(arg, arg);
29407 zend_error(E_NOTICE, "Only variables should be passed by reference");
29408 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29409 }
29410
ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29411 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29412 {
29413 USE_OPLINE
29414 zval *varptr, *arg;
29415 uint32_t arg_num;
29416
29417 if (IS_UNUSED == IS_CONST) {
29418 SAVE_OPLINE();
29419 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29420 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29421 if (UNEXPECTED(!arg)) {
29422 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29423 HANDLE_EXCEPTION();
29424 }
29425 } else {
29426 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29427 arg_num = opline->op2.num;
29428 }
29429
29430 if (EXPECTED(0)) {
29431 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29432 goto send_var;
29433 }
29434
29435 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29436 ZVAL_COPY_VALUE(arg, varptr);
29437
29438 if (EXPECTED(Z_ISREF_P(varptr) ||
29439 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
29440 ZEND_VM_NEXT_OPCODE();
29441 }
29442 } else {
29443 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29444 goto send_var;
29445 }
29446
29447 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29448 ZVAL_COPY_VALUE(arg, varptr);
29449
29450 if (EXPECTED(Z_ISREF_P(varptr) ||
29451 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
29452 ZEND_VM_NEXT_OPCODE();
29453 }
29454 }
29455
29456 SAVE_OPLINE();
29457 ZVAL_NEW_REF(arg, arg);
29458 zend_error(E_NOTICE, "Only variables should be passed by reference");
29459 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29460
29461 send_var:
29462 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29463 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29464 zend_refcounted *ref = Z_COUNTED_P(varptr);
29465
29466 varptr = Z_REFVAL_P(varptr);
29467 ZVAL_COPY_VALUE(arg, varptr);
29468 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29469 efree_size(ref, sizeof(zend_reference));
29470 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29471 Z_ADDREF_P(arg);
29472 }
29473 } else {
29474 ZVAL_COPY_VALUE(arg, varptr);
29475 }
29476 ZEND_VM_NEXT_OPCODE();
29477 }
29478
ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29479 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)
29480 {
29481 USE_OPLINE
29482 zval *varptr, *arg;
29483 uint32_t arg_num;
29484
29485 if (IS_UNUSED == IS_CONST) {
29486 SAVE_OPLINE();
29487 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29488 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29489 if (UNEXPECTED(!arg)) {
29490 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29491 HANDLE_EXCEPTION();
29492 }
29493 } else {
29494 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29495 arg_num = opline->op2.num;
29496 }
29497
29498 if (EXPECTED(1)) {
29499 if (!QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29500 goto send_var;
29501 }
29502
29503 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29504 ZVAL_COPY_VALUE(arg, varptr);
29505
29506 if (EXPECTED(Z_ISREF_P(varptr) ||
29507 QUICK_ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
29508 ZEND_VM_NEXT_OPCODE();
29509 }
29510 } else {
29511 if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29512 goto send_var;
29513 }
29514
29515 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29516 ZVAL_COPY_VALUE(arg, varptr);
29517
29518 if (EXPECTED(Z_ISREF_P(varptr) ||
29519 ARG_MAY_BE_SENT_BY_REF(EX(call)->func, arg_num))) {
29520 ZEND_VM_NEXT_OPCODE();
29521 }
29522 }
29523
29524 SAVE_OPLINE();
29525 ZVAL_NEW_REF(arg, arg);
29526 zend_error(E_NOTICE, "Only variables should be passed by reference");
29527 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29528
29529 send_var:
29530 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29531 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29532 zend_refcounted *ref = Z_COUNTED_P(varptr);
29533
29534 varptr = Z_REFVAL_P(varptr);
29535 ZVAL_COPY_VALUE(arg, varptr);
29536 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29537 efree_size(ref, sizeof(zend_reference));
29538 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29539 Z_ADDREF_P(arg);
29540 }
29541 } else {
29542 ZVAL_COPY_VALUE(arg, varptr);
29543 }
29544 ZEND_VM_NEXT_OPCODE();
29545 }
29546
ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29547 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29548 {
29549 USE_OPLINE
29550 zval *varptr, *arg;
29551
29552 SAVE_OPLINE();
29553 if (IS_UNUSED == IS_CONST) {
29554 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29555 uint32_t arg_num;
29556 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29557 if (UNEXPECTED(!arg)) {
29558 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29559 HANDLE_EXCEPTION();
29560 }
29561 } else {
29562 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29563 }
29564
29565 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29566 if (Z_ISREF_P(varptr)) {
29567 Z_ADDREF_P(varptr);
29568 } else {
29569 ZVAL_MAKE_REF_EX(varptr, 2);
29570 }
29571 ZVAL_REF(arg, Z_REF_P(varptr));
29572
29573 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29574 ZEND_VM_NEXT_OPCODE();
29575 }
29576
ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29577 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29578 {
29579 USE_OPLINE
29580 zval *varptr, *arg;
29581 uint32_t arg_num;
29582
29583 if (IS_UNUSED == IS_CONST) {
29584 SAVE_OPLINE();
29585 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29586 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29587 if (UNEXPECTED(!arg)) {
29588 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29589 HANDLE_EXCEPTION();
29590 }
29591 } else {
29592 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29593 arg_num = opline->op2.num;
29594 }
29595
29596 if (EXPECTED(0)) {
29597 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29598 goto send_var_by_ref;
29599 }
29600 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29601 send_var_by_ref:
29602 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29603 if (Z_ISREF_P(varptr)) {
29604 Z_ADDREF_P(varptr);
29605 } else {
29606 ZVAL_MAKE_REF_EX(varptr, 2);
29607 }
29608 ZVAL_REF(arg, Z_REF_P(varptr));
29609
29610 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29611 ZEND_VM_NEXT_OPCODE();
29612 }
29613
29614 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29615 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
29616 SAVE_OPLINE();
29617 ZVAL_UNDEFINED_OP1();
29618 ZVAL_NULL(arg);
29619 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29620 }
29621
29622 if (IS_VAR == IS_CV) {
29623 ZVAL_COPY_DEREF(arg, varptr);
29624 } else /* if (IS_VAR == IS_VAR) */ {
29625 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29626 zend_refcounted *ref = Z_COUNTED_P(varptr);
29627
29628 varptr = Z_REFVAL_P(varptr);
29629 ZVAL_COPY_VALUE(arg, varptr);
29630 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29631 efree_size(ref, sizeof(zend_reference));
29632 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29633 Z_ADDREF_P(arg);
29634 }
29635 } else {
29636 ZVAL_COPY_VALUE(arg, varptr);
29637 }
29638 }
29639
29640 ZEND_VM_NEXT_OPCODE();
29641 }
29642
ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29643 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29644 {
29645 USE_OPLINE
29646 zval *varptr, *arg;
29647 uint32_t arg_num;
29648
29649 if (IS_UNUSED == IS_CONST) {
29650 SAVE_OPLINE();
29651 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29652 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29653 if (UNEXPECTED(!arg)) {
29654 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29655 HANDLE_EXCEPTION();
29656 }
29657 } else {
29658 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29659 arg_num = opline->op2.num;
29660 }
29661
29662 if (EXPECTED(1)) {
29663 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29664 goto send_var_by_ref;
29665 }
29666 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
29667 send_var_by_ref:
29668 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29669 if (Z_ISREF_P(varptr)) {
29670 Z_ADDREF_P(varptr);
29671 } else {
29672 ZVAL_MAKE_REF_EX(varptr, 2);
29673 }
29674 ZVAL_REF(arg, Z_REF_P(varptr));
29675
29676 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29677 ZEND_VM_NEXT_OPCODE();
29678 }
29679
29680 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29681 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
29682 SAVE_OPLINE();
29683 ZVAL_UNDEFINED_OP1();
29684 ZVAL_NULL(arg);
29685 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29686 }
29687
29688 if (IS_VAR == IS_CV) {
29689 ZVAL_COPY_DEREF(arg, varptr);
29690 } else /* if (IS_VAR == IS_VAR) */ {
29691 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29692 zend_refcounted *ref = Z_COUNTED_P(varptr);
29693
29694 varptr = Z_REFVAL_P(varptr);
29695 ZVAL_COPY_VALUE(arg, varptr);
29696 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29697 efree_size(ref, sizeof(zend_reference));
29698 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29699 Z_ADDREF_P(arg);
29700 }
29701 } else {
29702 ZVAL_COPY_VALUE(arg, varptr);
29703 }
29704 }
29705
29706 ZEND_VM_NEXT_OPCODE();
29707 }
29708
ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29709 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29710 {
29711 USE_OPLINE
29712 zval *varptr, *arg;
29713
29714 if (IS_UNUSED == IS_CONST) {
29715 // TODO: Would it make sense to share the cache slot with CHECK_FUNC_ARG?
29716 SAVE_OPLINE();
29717 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
29718 uint32_t arg_num;
29719 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
29720 if (UNEXPECTED(!arg)) {
29721 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29722 HANDLE_EXCEPTION();
29723 }
29724 } else {
29725 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
29726 }
29727
29728 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
29729 varptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29730 if (Z_ISREF_P(varptr)) {
29731 Z_ADDREF_P(varptr);
29732 } else {
29733 ZVAL_MAKE_REF_EX(varptr, 2);
29734 }
29735 ZVAL_REF(arg, Z_REF_P(varptr));
29736
29737 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29738 ZEND_VM_NEXT_OPCODE();
29739 }
29740
29741 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29742
29743 if (UNEXPECTED(Z_ISREF_P(varptr))) {
29744 zend_refcounted *ref = Z_COUNTED_P(varptr);
29745
29746 varptr = Z_REFVAL_P(varptr);
29747 ZVAL_COPY_VALUE(arg, varptr);
29748 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29749 efree_size(ref, sizeof(zend_reference));
29750 } else if (Z_OPT_REFCOUNTED_P(arg)) {
29751 Z_ADDREF_P(arg);
29752 }
29753 } else {
29754 ZVAL_COPY_VALUE(arg, varptr);
29755 }
29756
29757 ZEND_VM_NEXT_OPCODE();
29758 }
29759
ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29760 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29761 {
29762 USE_OPLINE
29763 zval *result;
29764 zend_function *constructor;
29765 zend_class_entry *ce;
29766 zend_execute_data *call;
29767
29768 SAVE_OPLINE();
29769 if (IS_VAR == IS_CONST) {
29770 ce = CACHED_PTR(opline->op2.num);
29771 if (UNEXPECTED(ce == NULL)) {
29772 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);
29773 if (UNEXPECTED(ce == NULL)) {
29774 ZVAL_UNDEF(EX_VAR(opline->result.var));
29775 HANDLE_EXCEPTION();
29776 }
29777 CACHE_PTR(opline->op2.num, ce);
29778 }
29779 } else if (IS_VAR == IS_UNUSED) {
29780 ce = zend_fetch_class(NULL, opline->op1.num);
29781 if (UNEXPECTED(ce == NULL)) {
29782 ZVAL_UNDEF(EX_VAR(opline->result.var));
29783 HANDLE_EXCEPTION();
29784 }
29785 } else {
29786 ce = Z_CE_P(EX_VAR(opline->op1.var));
29787 }
29788
29789 result = EX_VAR(opline->result.var);
29790 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
29791 ZVAL_UNDEF(result);
29792 HANDLE_EXCEPTION();
29793 }
29794
29795 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
29796 if (constructor == NULL) {
29797 if (UNEXPECTED(EG(exception))) {
29798 HANDLE_EXCEPTION();
29799 }
29800
29801 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
29802 * opcode is DO_FCALL in case EXT instructions are used. */
29803 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
29804 ZEND_VM_NEXT_OPCODE_EX(1, 2);
29805 }
29806
29807 /* Perform a dummy function call */
29808 call = zend_vm_stack_push_call_frame(
29809 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
29810 opline->extended_value, NULL);
29811 } else {
29812 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
29813 init_func_run_time_cache(&constructor->op_array);
29814 }
29815 /* We are not handling overloaded classes right now */
29816 call = zend_vm_stack_push_call_frame(
29817 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
29818 constructor,
29819 opline->extended_value,
29820 Z_OBJ_P(result));
29821 Z_ADDREF_P(result);
29822 }
29823
29824 call->prev_execute_data = EX(call);
29825 EX(call) = call;
29826 ZEND_VM_NEXT_OPCODE();
29827 }
29828
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29829 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29830 {
29831 USE_OPLINE
29832 zval *expr_ptr, new_expr;
29833
29834 SAVE_OPLINE();
29835 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
29836 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
29837 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29838 if (Z_ISREF_P(expr_ptr)) {
29839 Z_ADDREF_P(expr_ptr);
29840 } else {
29841 ZVAL_MAKE_REF_EX(expr_ptr, 2);
29842 }
29843 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
29844 } else {
29845 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29846 if (IS_VAR == IS_TMP_VAR) {
29847 /* pass */
29848 } else if (IS_VAR == IS_CONST) {
29849 Z_TRY_ADDREF_P(expr_ptr);
29850 } else if (IS_VAR == IS_CV) {
29851 ZVAL_DEREF(expr_ptr);
29852 Z_TRY_ADDREF_P(expr_ptr);
29853 } else /* if (IS_VAR == IS_VAR) */ {
29854 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
29855 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
29856
29857 expr_ptr = Z_REFVAL_P(expr_ptr);
29858 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
29859 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
29860 expr_ptr = &new_expr;
29861 efree_size(ref, sizeof(zend_reference));
29862 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
29863 Z_ADDREF_P(expr_ptr);
29864 }
29865 }
29866 }
29867 }
29868
29869 if (IS_UNUSED != IS_UNUSED) {
29870 zval *offset = NULL;
29871 zend_string *str;
29872 zend_ulong hval;
29873
29874 add_again:
29875 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
29876 str = Z_STR_P(offset);
29877 if (IS_UNUSED != IS_CONST) {
29878 if (ZEND_HANDLE_NUMERIC(str, hval)) {
29879 goto num_index;
29880 }
29881 }
29882 str_index:
29883 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
29884 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
29885 hval = Z_LVAL_P(offset);
29886 num_index:
29887 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
29888 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
29889 offset = Z_REFVAL_P(offset);
29890 goto add_again;
29891 } else if (Z_TYPE_P(offset) == IS_NULL) {
29892 str = ZSTR_EMPTY_ALLOC();
29893 goto str_index;
29894 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
29895 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
29896 goto num_index;
29897 } else if (Z_TYPE_P(offset) == IS_FALSE) {
29898 hval = 0;
29899 goto num_index;
29900 } else if (Z_TYPE_P(offset) == IS_TRUE) {
29901 hval = 1;
29902 goto num_index;
29903 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
29904 zend_use_resource_as_offset(offset);
29905 hval = Z_RES_HANDLE_P(offset);
29906 goto num_index;
29907 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
29908 ZVAL_UNDEFINED_OP2();
29909 str = ZSTR_EMPTY_ALLOC();
29910 goto str_index;
29911 } else {
29912 zend_illegal_array_offset_access(offset);
29913 zval_ptr_dtor_nogc(expr_ptr);
29914 }
29915
29916 } else {
29917 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
29918 zend_cannot_add_element();
29919 zval_ptr_dtor_nogc(expr_ptr);
29920 }
29921 }
29922 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
29923 }
29924
ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29925 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29926 {
29927 zval *array;
29928 uint32_t size;
29929 USE_OPLINE
29930
29931 array = EX_VAR(opline->result.var);
29932 if (IS_VAR != IS_UNUSED) {
29933 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
29934 ZVAL_ARR(array, zend_new_array(size));
29935 /* Explicitly initialize array as not-packed if flag is set */
29936 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
29937 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
29938 }
29939 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29940 } else {
29941 ZVAL_ARR(array, zend_new_array(0));
29942 ZEND_VM_NEXT_OPCODE();
29943 }
29944 }
29945
ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29946 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29947 {
29948 USE_OPLINE
29949 zval *var_ptr;
29950
29951 var_ptr = EX_VAR(opline->op1.var);
29952 if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
29953 if (UNEXPECTED(Z_REFCOUNT_P(var_ptr) == 1)) {
29954 ZVAL_UNREF(var_ptr);
29955 }
29956 }
29957
29958 ZEND_VM_NEXT_OPCODE();
29959 }
29960
ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)29961 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
29962 {
29963 USE_OPLINE
29964
29965 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
29966
29967 SAVE_OPLINE();
29968 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
29969 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
29970 }
29971
29972 /* Destroy the previously yielded value */
29973 zval_ptr_dtor(&generator->value);
29974
29975 /* Destroy the previously yielded key */
29976 zval_ptr_dtor(&generator->key);
29977
29978 /* Set the new yielded value */
29979 if (IS_VAR != IS_UNUSED) {
29980 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
29981 /* Constants and temporary variables aren't yieldable by reference,
29982 * but we still allow them with a notice. */
29983 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
29984 zval *value;
29985
29986 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
29987
29988 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29989 ZVAL_COPY_VALUE(&generator->value, value);
29990 if (IS_VAR == IS_CONST) {
29991 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
29992 Z_ADDREF(generator->value);
29993 }
29994 }
29995 } else {
29996 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
29997
29998 /* If a function call result is yielded and the function did
29999 * not return by reference we throw a notice. */
30000 do {
30001 if (IS_VAR == IS_VAR) {
30002 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
30003 if (opline->extended_value == ZEND_RETURNS_FUNCTION
30004 && !Z_ISREF_P(value_ptr)) {
30005 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
30006 ZVAL_COPY(&generator->value, value_ptr);
30007 break;
30008 }
30009 }
30010 if (Z_ISREF_P(value_ptr)) {
30011 Z_ADDREF_P(value_ptr);
30012 } else {
30013 ZVAL_MAKE_REF_EX(value_ptr, 2);
30014 }
30015 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
30016 } while (0);
30017
30018 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30019 }
30020 } else {
30021 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30022
30023 /* Consts, temporary variables and references need copying */
30024 if (IS_VAR == IS_CONST) {
30025 ZVAL_COPY_VALUE(&generator->value, value);
30026 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
30027 Z_ADDREF(generator->value);
30028 }
30029 } else if (IS_VAR == IS_TMP_VAR) {
30030 ZVAL_COPY_VALUE(&generator->value, value);
30031 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
30032 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
30033 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30034 } else {
30035 ZVAL_COPY_VALUE(&generator->value, value);
30036 if (IS_VAR == IS_CV) {
30037 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
30038 }
30039 }
30040 }
30041 } else {
30042 /* If no value was specified yield null */
30043 ZVAL_NULL(&generator->value);
30044 }
30045
30046 /* Set the new yielded key */
30047 if (IS_UNUSED != IS_UNUSED) {
30048 zval *key = NULL;
30049 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
30050 key = Z_REFVAL_P(key);
30051 }
30052 ZVAL_COPY(&generator->key, key);
30053
30054 if (Z_TYPE(generator->key) == IS_LONG
30055 && Z_LVAL(generator->key) > generator->largest_used_integer_key
30056 ) {
30057 generator->largest_used_integer_key = Z_LVAL(generator->key);
30058 }
30059 } else {
30060 /* If no key was specified we use auto-increment keys */
30061 generator->largest_used_integer_key++;
30062 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
30063 }
30064
30065 if (RETURN_VALUE_USED(opline)) {
30066 /* If the return value of yield is used set the send
30067 * target and initialize it to NULL */
30068 generator->send_target = EX_VAR(opline->result.var);
30069 ZVAL_NULL(generator->send_target);
30070 } else {
30071 generator->send_target = NULL;
30072 }
30073
30074 /* We increment to the next op, so we are at the correct position when the
30075 * generator is resumed. */
30076 ZEND_VM_INC_OPCODE();
30077
30078 /* The GOTO VM uses a local opline variable. We need to set the opline
30079 * variable in execute_data so we don't resume at an old position. */
30080 SAVE_OPLINE();
30081
30082 ZEND_VM_RETURN();
30083 }
30084
ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30085 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30086 {
30087 USE_OPLINE
30088 zval *op1 = EX_VAR(opline->op1.var);
30089
30090 if (IS_VAR == IS_CV) {
30091 if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
30092 ZVAL_NEW_EMPTY_REF(op1);
30093 Z_SET_REFCOUNT_P(op1, 2);
30094 ZVAL_NULL(Z_REFVAL_P(op1));
30095 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30096 } else {
30097 if (Z_ISREF_P(op1)) {
30098 Z_ADDREF_P(op1);
30099 } else {
30100 ZVAL_MAKE_REF_EX(op1, 2);
30101 }
30102 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30103 }
30104 } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
30105 op1 = Z_INDIRECT_P(op1);
30106 if (EXPECTED(!Z_ISREF_P(op1))) {
30107 ZVAL_MAKE_REF_EX(op1, 2);
30108 } else {
30109 GC_ADDREF(Z_REF_P(op1));
30110 }
30111 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
30112 } else {
30113 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
30114 }
30115 ZEND_VM_NEXT_OPCODE();
30116 }
30117
ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30118 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30119 {
30120 USE_OPLINE
30121 zval *op1;
30122 zend_string *type;
30123
30124 SAVE_OPLINE();
30125 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30126 type = zend_zval_get_legacy_type(op1);
30127 if (EXPECTED(type)) {
30128 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
30129 } else {
30130 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
30131 }
30132 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30133 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30134 }
30135
ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30136 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30137 {
30138 USE_OPLINE
30139 zval *varptr, *arg;
30140 uint32_t arg_num = opline->op2.num;
30141
30142 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
30143 ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30144 }
30145
30146 varptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30147 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
30148
30149 if (IS_VAR == IS_CV) {
30150 ZVAL_COPY(arg, varptr);
30151 } else /* if (IS_VAR == IS_VAR) */ {
30152 ZVAL_COPY_VALUE(arg, varptr);
30153 }
30154
30155 ZEND_VM_NEXT_OPCODE();
30156 }
30157
ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30158 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30159 {
30160 USE_OPLINE
30161 zval *op1, *op2;
30162 bool result;
30163
30164 SAVE_OPLINE();
30165 op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
30166 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30167 result = fast_is_identical_function(op1, op2);
30168
30169 ZEND_VM_SMART_BRANCH(result, 1);
30170 }
30171
ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30172 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30173 {
30174 USE_OPLINE
30175 zval *object;
30176 zval *property;
30177 zval *value;
30178 zval *zptr;
30179 void **cache_slot;
30180 zend_property_info *prop_info;
30181 zend_object *zobj;
30182 zend_string *name, *tmp_name;
30183
30184 SAVE_OPLINE();
30185 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30186 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30187
30188 do {
30189 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
30190
30191 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30192 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30193 object = Z_REFVAL_P(object);
30194 goto assign_op_object;
30195 }
30196 if (IS_VAR == IS_CV
30197 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
30198 ZVAL_UNDEFINED_OP1();
30199 }
30200 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
30201 break;
30202 }
30203
30204 assign_op_object:
30205 /* here we are sure we are dealing with an object */
30206 zobj = Z_OBJ_P(object);
30207 if (IS_CV == IS_CONST) {
30208 name = Z_STR_P(property);
30209 } else {
30210 name = zval_try_get_tmp_string(property, &tmp_name);
30211 if (UNEXPECTED(!name)) {
30212 UNDEF_RESULT();
30213 break;
30214 }
30215 }
30216 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
30217 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
30218 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
30219 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30220 ZVAL_NULL(EX_VAR(opline->result.var));
30221 }
30222 } else {
30223 zval *orig_zptr = zptr;
30224 zend_reference *ref;
30225
30226 do {
30227 if (UNEXPECTED(Z_ISREF_P(zptr))) {
30228 ref = Z_REF_P(zptr);
30229 zptr = Z_REFVAL_P(zptr);
30230 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
30231 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
30232 break;
30233 }
30234 }
30235
30236 if (IS_CV == IS_CONST) {
30237 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
30238 } else {
30239 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
30240 }
30241 if (prop_info) {
30242 /* special case for typed properties */
30243 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
30244 } else {
30245 zend_binary_op(zptr, zptr, value OPLINE_CC);
30246 }
30247 } while (0);
30248
30249 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30250 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
30251 }
30252 }
30253 } else {
30254 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
30255 }
30256 if (IS_CV != IS_CONST) {
30257 zend_tmp_string_release(tmp_name);
30258 }
30259 } while (0);
30260
30261 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
30262
30263 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30264 /* assign_obj has two opcodes! */
30265 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30266 }
30267
30268 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30269 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30270 {
30271 USE_OPLINE
30272 zval *var_ptr;
30273 zval *value, *container, *dim;
30274 HashTable *ht;
30275
30276 SAVE_OPLINE();
30277 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30278
30279 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
30280 assign_dim_op_array:
30281 SEPARATE_ARRAY(container);
30282 ht = Z_ARRVAL_P(container);
30283 assign_dim_op_new_array:
30284 dim = EX_VAR(opline->op2.var);
30285 if (IS_CV == IS_UNUSED) {
30286 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
30287 if (UNEXPECTED(!var_ptr)) {
30288 zend_cannot_add_element();
30289 goto assign_dim_op_ret_null;
30290 }
30291 } else {
30292 if (IS_CV == IS_CONST) {
30293 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
30294 } else {
30295 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
30296 }
30297 if (UNEXPECTED(!var_ptr)) {
30298 goto assign_dim_op_ret_null;
30299 }
30300 }
30301
30302 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
30303
30304 do {
30305 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
30306 zend_reference *ref = Z_REF_P(var_ptr);
30307 var_ptr = Z_REFVAL_P(var_ptr);
30308 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
30309 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
30310 break;
30311 }
30312 }
30313 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
30314 } while (0);
30315
30316 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30317 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
30318 }
30319 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
30320 } else {
30321 if (EXPECTED(Z_ISREF_P(container))) {
30322 container = Z_REFVAL_P(container);
30323 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
30324 goto assign_dim_op_array;
30325 }
30326 }
30327
30328 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
30329 zend_object *obj = Z_OBJ_P(container);
30330
30331 dim = EX_VAR(opline->op2.var);
30332 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
30333 dim++;
30334 }
30335 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
30336 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
30337 uint8_t old_type;
30338
30339 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
30340 ZVAL_UNDEFINED_OP1();
30341 }
30342 ht = zend_new_array(8);
30343 old_type = Z_TYPE_P(container);
30344 ZVAL_ARR(container, ht);
30345 if (UNEXPECTED(old_type == IS_FALSE)) {
30346 GC_ADDREF(ht);
30347 zend_false_to_array_deprecated();
30348 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
30349 zend_array_destroy(ht);
30350 goto assign_dim_op_ret_null;
30351 }
30352 }
30353 goto assign_dim_op_new_array;
30354 } else {
30355 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30356 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
30357 assign_dim_op_ret_null:
30358 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
30359 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30360 ZVAL_NULL(EX_VAR(opline->result.var));
30361 }
30362 }
30363 }
30364
30365 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30366 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30367 }
30368
ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30369 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30370 {
30371 USE_OPLINE
30372 zval *var_ptr;
30373 zval *value;
30374
30375 SAVE_OPLINE();
30376 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30377 var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30378
30379 do {
30380 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
30381 zend_reference *ref = Z_REF_P(var_ptr);
30382 var_ptr = Z_REFVAL_P(var_ptr);
30383 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
30384 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
30385 break;
30386 }
30387 }
30388 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
30389 } while (0);
30390
30391 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30392 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
30393 }
30394
30395 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30396 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30397 }
30398
ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30399 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30400 {
30401 USE_OPLINE
30402 zval *object;
30403 zval *property;
30404 zval *zptr;
30405 void **cache_slot;
30406 zend_property_info *prop_info;
30407 zend_object *zobj;
30408 zend_string *name, *tmp_name;
30409
30410 SAVE_OPLINE();
30411 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30412 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30413
30414 do {
30415 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30416 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30417 object = Z_REFVAL_P(object);
30418 goto pre_incdec_object;
30419 }
30420 if (IS_VAR == IS_CV
30421 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
30422 ZVAL_UNDEFINED_OP1();
30423 }
30424 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
30425 break;
30426 }
30427
30428 pre_incdec_object:
30429 /* here we are sure we are dealing with an object */
30430 zobj = Z_OBJ_P(object);
30431 if (IS_CV == IS_CONST) {
30432 name = Z_STR_P(property);
30433 } else {
30434 name = zval_try_get_tmp_string(property, &tmp_name);
30435 if (UNEXPECTED(!name)) {
30436 UNDEF_RESULT();
30437 break;
30438 }
30439 }
30440 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
30441 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
30442 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
30443 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30444 ZVAL_NULL(EX_VAR(opline->result.var));
30445 }
30446 } else {
30447 if (IS_CV == IS_CONST) {
30448 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
30449 } else {
30450 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
30451 }
30452 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
30453 }
30454 } else {
30455 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
30456 }
30457 if (IS_CV != IS_CONST) {
30458 zend_tmp_string_release(tmp_name);
30459 }
30460 } while (0);
30461
30462 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30463 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30464 }
30465
ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30466 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30467 {
30468 USE_OPLINE
30469 zval *object;
30470 zval *property;
30471 zval *zptr;
30472 void **cache_slot;
30473 zend_property_info *prop_info;
30474 zend_object *zobj;
30475 zend_string *name, *tmp_name;
30476
30477 SAVE_OPLINE();
30478 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30479 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30480
30481 do {
30482 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30483 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30484 object = Z_REFVAL_P(object);
30485 goto post_incdec_object;
30486 }
30487 if (IS_VAR == IS_CV
30488 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
30489 ZVAL_UNDEFINED_OP1();
30490 }
30491 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
30492 break;
30493 }
30494
30495 post_incdec_object:
30496 /* here we are sure we are dealing with an object */
30497 zobj = Z_OBJ_P(object);
30498 if (IS_CV == IS_CONST) {
30499 name = Z_STR_P(property);
30500 } else {
30501 name = zval_try_get_tmp_string(property, &tmp_name);
30502 if (UNEXPECTED(!name)) {
30503 ZVAL_UNDEF(EX_VAR(opline->result.var));
30504 break;
30505 }
30506 }
30507 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
30508 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
30509 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
30510 ZVAL_NULL(EX_VAR(opline->result.var));
30511 } else {
30512 if (IS_CV == IS_CONST) {
30513 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
30514 } else {
30515 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
30516 }
30517
30518 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
30519 }
30520 } else {
30521 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
30522 }
30523 if (IS_CV != IS_CONST) {
30524 zend_tmp_string_release(tmp_name);
30525 }
30526 } while (0);
30527
30528 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30529 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30530 }
30531
ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30532 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30533 {
30534 USE_OPLINE
30535 zval *container;
30536
30537 SAVE_OPLINE();
30538 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30539 zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
30540
30541 if (IS_VAR == IS_VAR) {
30542 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30543 }
30544 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30545 }
30546
ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30547 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30548 {
30549 USE_OPLINE
30550 zval *container;
30551
30552 SAVE_OPLINE();
30553 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30554 zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
30555
30556 if (IS_VAR == IS_VAR) {
30557 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30558 }
30559 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30560 }
30561
ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30562 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30563 {
30564 #if 0
30565 USE_OPLINE
30566 #endif
30567
30568 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
30569 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
30570 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30571 }
30572 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30573 } else {
30574 if (IS_CV == IS_UNUSED) {
30575 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30576 }
30577 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30578 }
30579 }
30580
ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30581 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30582 {
30583 USE_OPLINE
30584 zval *container;
30585
30586 SAVE_OPLINE();
30587 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30588 zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
30589
30590 if (IS_VAR == IS_VAR) {
30591 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30592 }
30593 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30594 }
30595
ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30596 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30597 {
30598 USE_OPLINE
30599 zval *property, *container, *result;
30600
30601 SAVE_OPLINE();
30602
30603 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30604 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30605 result = EX_VAR(opline->result.var);
30606 zend_fetch_property_address(
30607 result, container, IS_VAR, property, IS_CV,
30608 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
30609 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
30610
30611 if (IS_VAR == IS_VAR) {
30612 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30613 }
30614 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30615 }
30616
ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30617 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30618 {
30619 USE_OPLINE
30620 zval *property, *container, *result;
30621
30622 SAVE_OPLINE();
30623 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30624 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30625 result = EX_VAR(opline->result.var);
30626 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 OPLINE_CC EXECUTE_DATA_CC);
30627
30628 if (IS_VAR == IS_VAR) {
30629 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30630 }
30631 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30632 }
30633
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30634 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30635 {
30636 #if 0
30637 USE_OPLINE
30638 #endif
30639
30640 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
30641 /* Behave like FETCH_OBJ_W */
30642 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
30643 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30644 }
30645 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30646 } else {
30647 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
30648 }
30649 }
30650
ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30651 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30652 {
30653 USE_OPLINE
30654 zval *container, *property, *result;
30655
30656 SAVE_OPLINE();
30657 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30658 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
30659 result = EX_VAR(opline->result.var);
30660 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 OPLINE_CC EXECUTE_DATA_CC);
30661
30662 if (IS_VAR == IS_VAR) {
30663 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
30664 }
30665 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30666 }
30667
ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30668 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30669 {
30670 USE_OPLINE
30671 zval *container, *dim;
30672
30673 SAVE_OPLINE();
30674 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30675 dim = EX_VAR(opline->op2.var);
30676
30677 if (IS_VAR == IS_VAR
30678 && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT
30679 && UNEXPECTED(!Z_ISREF_P(container))
30680 ) {
30681 zend_error(E_NOTICE, "Attempting to set reference to non referenceable value");
30682 zend_fetch_dimension_address_LIST_r(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
30683 } else {
30684 zend_fetch_dimension_address_W(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
30685 }
30686
30687 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
30688 }
30689
ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)30690 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30691 {
30692 USE_OPLINE
30693 zval *object, *value, tmp;
30694 zend_object *zobj;
30695 zend_string *name, *tmp_name;
30696 zend_refcounted *garbage = NULL;
30697
30698 SAVE_OPLINE();
30699 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30700 value = RT_CONSTANT((opline+1), (opline+1)->op1);
30701
30702 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30703 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30704 object = Z_REFVAL_P(object);
30705 goto assign_object;
30706 }
30707 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
30708 value = &EG(uninitialized_zval);
30709 goto free_and_exit_assign_obj;
30710 }
30711
30712 assign_object:
30713 zobj = Z_OBJ_P(object);
30714 if (IS_CV == IS_CONST) {
30715 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
30716 void **cache_slot = CACHE_ADDR(opline->extended_value);
30717 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
30718 zval *property_val;
30719
30720 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
30721 property_val = OBJ_PROP(zobj, prop_offset);
30722 if (Z_TYPE_P(property_val) != IS_UNDEF) {
30723 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
30724
30725 if (prop_info != NULL) {
30726 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
30727 goto free_and_exit_assign_obj;
30728 } else {
30729 fast_assign_obj:
30730 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
30731 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30732 ZVAL_COPY(EX_VAR(opline->result.var), value);
30733 }
30734 goto exit_assign_obj;
30735 }
30736 }
30737 } else {
30738 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
30739 if (EXPECTED(zobj->properties != NULL)) {
30740 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
30741 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
30742 GC_DELREF(zobj->properties);
30743 }
30744 zobj->properties = zend_array_dup(zobj->properties);
30745 }
30746 property_val = zend_hash_find_known_hash(zobj->properties, name);
30747 if (property_val) {
30748 goto fast_assign_obj;
30749 }
30750 }
30751
30752 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
30753 if (EXPECTED(zobj->properties == NULL)) {
30754 rebuild_object_properties(zobj);
30755 }
30756 if (IS_CONST == IS_CONST) {
30757 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
30758 Z_ADDREF_P(value);
30759 }
30760 } else if (IS_CONST != IS_TMP_VAR) {
30761 if (Z_ISREF_P(value)) {
30762 if (IS_CONST == IS_VAR) {
30763 zend_reference *ref = Z_REF_P(value);
30764 if (GC_DELREF(ref) == 0) {
30765 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
30766 efree_size(ref, sizeof(zend_reference));
30767 value = &tmp;
30768 } else {
30769 value = Z_REFVAL_P(value);
30770 Z_TRY_ADDREF_P(value);
30771 }
30772 } else {
30773 value = Z_REFVAL_P(value);
30774 Z_TRY_ADDREF_P(value);
30775 }
30776 } else if (IS_CONST == IS_CV) {
30777 Z_TRY_ADDREF_P(value);
30778 }
30779 }
30780 zend_hash_add_new(zobj->properties, name, value);
30781 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30782 ZVAL_COPY(EX_VAR(opline->result.var), value);
30783 }
30784 goto exit_assign_obj;
30785 }
30786 }
30787 }
30788 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
30789 } else {
30790 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
30791 if (UNEXPECTED(!name)) {
30792
30793 UNDEF_RESULT();
30794 goto exit_assign_obj;
30795 }
30796 }
30797
30798 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
30799 ZVAL_DEREF(value);
30800 }
30801
30802 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
30803
30804 if (IS_CV != IS_CONST) {
30805 zend_tmp_string_release(tmp_name);
30806 }
30807
30808 free_and_exit_assign_obj:
30809 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
30810 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
30811 }
30812
30813 exit_assign_obj:
30814 if (garbage) {
30815 GC_DTOR_NO_REF(garbage);
30816 }
30817
30818 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30819 /* assign_obj has two opcodes! */
30820 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30821 }
30822
30823 /* 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)30824 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30825 {
30826 USE_OPLINE
30827 zval *object, *value, tmp;
30828 zend_object *zobj;
30829 zend_string *name, *tmp_name;
30830 zend_refcounted *garbage = NULL;
30831
30832 SAVE_OPLINE();
30833 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30834 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
30835
30836 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30837 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30838 object = Z_REFVAL_P(object);
30839 goto assign_object;
30840 }
30841 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
30842 value = &EG(uninitialized_zval);
30843 goto free_and_exit_assign_obj;
30844 }
30845
30846 assign_object:
30847 zobj = Z_OBJ_P(object);
30848 if (IS_CV == IS_CONST) {
30849 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
30850 void **cache_slot = CACHE_ADDR(opline->extended_value);
30851 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
30852 zval *property_val;
30853
30854 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
30855 property_val = OBJ_PROP(zobj, prop_offset);
30856 if (Z_TYPE_P(property_val) != IS_UNDEF) {
30857 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
30858
30859 if (prop_info != NULL) {
30860 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
30861 goto free_and_exit_assign_obj;
30862 } else {
30863 fast_assign_obj:
30864 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
30865 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30866 ZVAL_COPY(EX_VAR(opline->result.var), value);
30867 }
30868 goto exit_assign_obj;
30869 }
30870 }
30871 } else {
30872 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
30873 if (EXPECTED(zobj->properties != NULL)) {
30874 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
30875 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
30876 GC_DELREF(zobj->properties);
30877 }
30878 zobj->properties = zend_array_dup(zobj->properties);
30879 }
30880 property_val = zend_hash_find_known_hash(zobj->properties, name);
30881 if (property_val) {
30882 goto fast_assign_obj;
30883 }
30884 }
30885
30886 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
30887 if (EXPECTED(zobj->properties == NULL)) {
30888 rebuild_object_properties(zobj);
30889 }
30890 if (IS_TMP_VAR == IS_CONST) {
30891 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
30892 Z_ADDREF_P(value);
30893 }
30894 } else if (IS_TMP_VAR != IS_TMP_VAR) {
30895 if (Z_ISREF_P(value)) {
30896 if (IS_TMP_VAR == IS_VAR) {
30897 zend_reference *ref = Z_REF_P(value);
30898 if (GC_DELREF(ref) == 0) {
30899 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
30900 efree_size(ref, sizeof(zend_reference));
30901 value = &tmp;
30902 } else {
30903 value = Z_REFVAL_P(value);
30904 Z_TRY_ADDREF_P(value);
30905 }
30906 } else {
30907 value = Z_REFVAL_P(value);
30908 Z_TRY_ADDREF_P(value);
30909 }
30910 } else if (IS_TMP_VAR == IS_CV) {
30911 Z_TRY_ADDREF_P(value);
30912 }
30913 }
30914 zend_hash_add_new(zobj->properties, name, value);
30915 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
30916 ZVAL_COPY(EX_VAR(opline->result.var), value);
30917 }
30918 goto exit_assign_obj;
30919 }
30920 }
30921 }
30922 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
30923 } else {
30924 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
30925 if (UNEXPECTED(!name)) {
30926 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
30927 UNDEF_RESULT();
30928 goto exit_assign_obj;
30929 }
30930 }
30931
30932 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
30933 ZVAL_DEREF(value);
30934 }
30935
30936 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
30937
30938 if (IS_CV != IS_CONST) {
30939 zend_tmp_string_release(tmp_name);
30940 }
30941
30942 free_and_exit_assign_obj:
30943 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
30944 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
30945 }
30946 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
30947 exit_assign_obj:
30948 if (garbage) {
30949 GC_DTOR_NO_REF(garbage);
30950 }
30951
30952 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
30953 /* assign_obj has two opcodes! */
30954 ZEND_VM_NEXT_OPCODE_EX(1, 2);
30955 }
30956
30957 /* 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)30958 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
30959 {
30960 USE_OPLINE
30961 zval *object, *value, tmp;
30962 zend_object *zobj;
30963 zend_string *name, *tmp_name;
30964 zend_refcounted *garbage = NULL;
30965
30966 SAVE_OPLINE();
30967 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
30968 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
30969
30970 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
30971 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
30972 object = Z_REFVAL_P(object);
30973 goto assign_object;
30974 }
30975 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
30976 value = &EG(uninitialized_zval);
30977 goto free_and_exit_assign_obj;
30978 }
30979
30980 assign_object:
30981 zobj = Z_OBJ_P(object);
30982 if (IS_CV == IS_CONST) {
30983 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
30984 void **cache_slot = CACHE_ADDR(opline->extended_value);
30985 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
30986 zval *property_val;
30987
30988 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
30989 property_val = OBJ_PROP(zobj, prop_offset);
30990 if (Z_TYPE_P(property_val) != IS_UNDEF) {
30991 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
30992
30993 if (prop_info != NULL) {
30994 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
30995 goto free_and_exit_assign_obj;
30996 } else {
30997 fast_assign_obj:
30998 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
30999 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31000 ZVAL_COPY(EX_VAR(opline->result.var), value);
31001 }
31002 goto exit_assign_obj;
31003 }
31004 }
31005 } else {
31006 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31007 if (EXPECTED(zobj->properties != NULL)) {
31008 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31009 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31010 GC_DELREF(zobj->properties);
31011 }
31012 zobj->properties = zend_array_dup(zobj->properties);
31013 }
31014 property_val = zend_hash_find_known_hash(zobj->properties, name);
31015 if (property_val) {
31016 goto fast_assign_obj;
31017 }
31018 }
31019
31020 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31021 if (EXPECTED(zobj->properties == NULL)) {
31022 rebuild_object_properties(zobj);
31023 }
31024 if (IS_VAR == IS_CONST) {
31025 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31026 Z_ADDREF_P(value);
31027 }
31028 } else if (IS_VAR != IS_TMP_VAR) {
31029 if (Z_ISREF_P(value)) {
31030 if (IS_VAR == IS_VAR) {
31031 zend_reference *ref = Z_REF_P(value);
31032 if (GC_DELREF(ref) == 0) {
31033 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31034 efree_size(ref, sizeof(zend_reference));
31035 value = &tmp;
31036 } else {
31037 value = Z_REFVAL_P(value);
31038 Z_TRY_ADDREF_P(value);
31039 }
31040 } else {
31041 value = Z_REFVAL_P(value);
31042 Z_TRY_ADDREF_P(value);
31043 }
31044 } else if (IS_VAR == IS_CV) {
31045 Z_TRY_ADDREF_P(value);
31046 }
31047 }
31048 zend_hash_add_new(zobj->properties, name, value);
31049 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31050 ZVAL_COPY(EX_VAR(opline->result.var), value);
31051 }
31052 goto exit_assign_obj;
31053 }
31054 }
31055 }
31056 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31057 } else {
31058 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31059 if (UNEXPECTED(!name)) {
31060 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31061 UNDEF_RESULT();
31062 goto exit_assign_obj;
31063 }
31064 }
31065
31066 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
31067 ZVAL_DEREF(value);
31068 }
31069
31070 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31071
31072 if (IS_CV != IS_CONST) {
31073 zend_tmp_string_release(tmp_name);
31074 }
31075
31076 free_and_exit_assign_obj:
31077 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31078 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31079 }
31080 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31081 exit_assign_obj:
31082 if (garbage) {
31083 GC_DTOR_NO_REF(garbage);
31084 }
31085
31086 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31087 /* assign_obj has two opcodes! */
31088 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31089 }
31090
31091 /* 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)31092 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31093 {
31094 USE_OPLINE
31095 zval *object, *value, tmp;
31096 zend_object *zobj;
31097 zend_string *name, *tmp_name;
31098 zend_refcounted *garbage = NULL;
31099
31100 SAVE_OPLINE();
31101 object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31102 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
31103
31104 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
31105 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
31106 object = Z_REFVAL_P(object);
31107 goto assign_object;
31108 }
31109 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
31110 value = &EG(uninitialized_zval);
31111 goto free_and_exit_assign_obj;
31112 }
31113
31114 assign_object:
31115 zobj = Z_OBJ_P(object);
31116 if (IS_CV == IS_CONST) {
31117 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
31118 void **cache_slot = CACHE_ADDR(opline->extended_value);
31119 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
31120 zval *property_val;
31121
31122 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
31123 property_val = OBJ_PROP(zobj, prop_offset);
31124 if (Z_TYPE_P(property_val) != IS_UNDEF) {
31125 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
31126
31127 if (prop_info != NULL) {
31128 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
31129 goto free_and_exit_assign_obj;
31130 } else {
31131 fast_assign_obj:
31132 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31133 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31134 ZVAL_COPY(EX_VAR(opline->result.var), value);
31135 }
31136 goto exit_assign_obj;
31137 }
31138 }
31139 } else {
31140 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31141 if (EXPECTED(zobj->properties != NULL)) {
31142 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
31143 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
31144 GC_DELREF(zobj->properties);
31145 }
31146 zobj->properties = zend_array_dup(zobj->properties);
31147 }
31148 property_val = zend_hash_find_known_hash(zobj->properties, name);
31149 if (property_val) {
31150 goto fast_assign_obj;
31151 }
31152 }
31153
31154 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
31155 if (EXPECTED(zobj->properties == NULL)) {
31156 rebuild_object_properties(zobj);
31157 }
31158 if (IS_CV == IS_CONST) {
31159 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
31160 Z_ADDREF_P(value);
31161 }
31162 } else if (IS_CV != IS_TMP_VAR) {
31163 if (Z_ISREF_P(value)) {
31164 if (IS_CV == IS_VAR) {
31165 zend_reference *ref = Z_REF_P(value);
31166 if (GC_DELREF(ref) == 0) {
31167 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
31168 efree_size(ref, sizeof(zend_reference));
31169 value = &tmp;
31170 } else {
31171 value = Z_REFVAL_P(value);
31172 Z_TRY_ADDREF_P(value);
31173 }
31174 } else {
31175 value = Z_REFVAL_P(value);
31176 Z_TRY_ADDREF_P(value);
31177 }
31178 } else if (IS_CV == IS_CV) {
31179 Z_TRY_ADDREF_P(value);
31180 }
31181 }
31182 zend_hash_add_new(zobj->properties, name, value);
31183 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31184 ZVAL_COPY(EX_VAR(opline->result.var), value);
31185 }
31186 goto exit_assign_obj;
31187 }
31188 }
31189 }
31190 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
31191 } else {
31192 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
31193 if (UNEXPECTED(!name)) {
31194
31195 UNDEF_RESULT();
31196 goto exit_assign_obj;
31197 }
31198 }
31199
31200 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
31201 ZVAL_DEREF(value);
31202 }
31203
31204 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
31205
31206 if (IS_CV != IS_CONST) {
31207 zend_tmp_string_release(tmp_name);
31208 }
31209
31210 free_and_exit_assign_obj:
31211 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
31212 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
31213 }
31214
31215 exit_assign_obj:
31216 if (garbage) {
31217 GC_DTOR_NO_REF(garbage);
31218 }
31219
31220 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31221 /* assign_obj has two opcodes! */
31222 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31223 }
31224
31225 /* 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)31226 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31227 {
31228 USE_OPLINE
31229 zval *object_ptr, *orig_object_ptr;
31230 zval *value;
31231 zval *variable_ptr;
31232 zval *dim;
31233 zend_refcounted *garbage = NULL;
31234
31235 SAVE_OPLINE();
31236 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31237
31238 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31239 try_assign_dim_array:
31240 SEPARATE_ARRAY(object_ptr);
31241 if (IS_CV == IS_UNUSED) {
31242 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31243 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
31244 HashTable *ht = Z_ARRVAL_P(object_ptr);
31245 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
31246 GC_ADDREF(ht);
31247 }
31248 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31249 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
31250 zend_array_destroy(ht);
31251 goto assign_dim_error;
31252 }
31253 }
31254 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
31255 ZVAL_DEREF(value);
31256 }
31257 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
31258 if (UNEXPECTED(value == NULL)) {
31259 zend_cannot_add_element();
31260 goto assign_dim_error;
31261 } else if (IS_CONST == IS_CV) {
31262 if (Z_REFCOUNTED_P(value)) {
31263 Z_ADDREF_P(value);
31264 }
31265 } else if (IS_CONST == IS_VAR) {
31266 zval *free_op_data = EX_VAR((opline+1)->op1.var);
31267 if (Z_ISREF_P(free_op_data)) {
31268 if (Z_REFCOUNTED_P(value)) {
31269 Z_ADDREF_P(value);
31270 }
31271 zval_ptr_dtor_nogc(free_op_data);
31272 }
31273 } else if (IS_CONST == IS_CONST) {
31274 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
31275 Z_ADDREF_P(value);
31276 }
31277 }
31278 } else {
31279 dim = EX_VAR(opline->op2.var);
31280 if (IS_CV == IS_CONST) {
31281 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31282 } else {
31283 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31284 }
31285 if (UNEXPECTED(variable_ptr == NULL)) {
31286 goto assign_dim_error;
31287 }
31288 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31289 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
31290 }
31291 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31292 ZVAL_COPY(EX_VAR(opline->result.var), value);
31293 }
31294 if (garbage) {
31295 GC_DTOR_NO_REF(garbage);
31296 }
31297 } else {
31298 if (EXPECTED(Z_ISREF_P(object_ptr))) {
31299 object_ptr = Z_REFVAL_P(object_ptr);
31300 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31301 goto try_assign_dim_array;
31302 }
31303 }
31304 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
31305 zend_object *obj = Z_OBJ_P(object_ptr);
31306
31307 GC_ADDREF(obj);
31308 dim = EX_VAR(opline->op2.var);
31309 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
31310 dim = ZVAL_UNDEFINED_OP2();
31311 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
31312 dim++;
31313 }
31314
31315 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31316 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
31317 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31318 } else if (IS_CONST & (IS_CV|IS_VAR)) {
31319 ZVAL_DEREF(value);
31320 }
31321
31322 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
31323
31324 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
31325 zend_objects_store_del(obj);
31326 }
31327 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
31328 if (IS_CV == IS_UNUSED) {
31329 zend_use_new_element_for_string();
31330
31331 UNDEF_RESULT();
31332 } else {
31333 dim = EX_VAR(opline->op2.var);
31334 value = RT_CONSTANT((opline+1), (opline+1)->op1);
31335 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
31336
31337 }
31338 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
31339 if (Z_ISREF_P(orig_object_ptr)
31340 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
31341 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
31342 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31343
31344 UNDEF_RESULT();
31345 } else {
31346 HashTable *ht = zend_new_array(8);
31347 uint8_t old_type = Z_TYPE_P(object_ptr);
31348
31349 ZVAL_ARR(object_ptr, ht);
31350 if (UNEXPECTED(old_type == IS_FALSE)) {
31351 GC_ADDREF(ht);
31352 zend_false_to_array_deprecated();
31353 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
31354 zend_array_destroy(ht);
31355 goto assign_dim_error;
31356 }
31357 }
31358 goto try_assign_dim_array;
31359 }
31360 } else {
31361 zend_use_scalar_as_array();
31362 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31363 assign_dim_error:
31364
31365 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31366 ZVAL_NULL(EX_VAR(opline->result.var));
31367 }
31368 }
31369 }
31370 if (IS_CV != IS_UNUSED) {
31371
31372 }
31373 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31374 /* assign_dim has two opcodes! */
31375 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31376 }
31377
ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31378 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31379 {
31380 USE_OPLINE
31381 zval *object_ptr, *orig_object_ptr;
31382 zval *value;
31383 zval *variable_ptr;
31384 zval *dim;
31385 zend_refcounted *garbage = NULL;
31386
31387 SAVE_OPLINE();
31388 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31389
31390 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31391 try_assign_dim_array:
31392 SEPARATE_ARRAY(object_ptr);
31393 if (IS_CV == IS_UNUSED) {
31394 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31395 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
31396 HashTable *ht = Z_ARRVAL_P(object_ptr);
31397 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
31398 GC_ADDREF(ht);
31399 }
31400 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31401 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
31402 zend_array_destroy(ht);
31403 goto assign_dim_error;
31404 }
31405 }
31406 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
31407 ZVAL_DEREF(value);
31408 }
31409 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
31410 if (UNEXPECTED(value == NULL)) {
31411 zend_cannot_add_element();
31412 goto assign_dim_error;
31413 } else if (IS_TMP_VAR == IS_CV) {
31414 if (Z_REFCOUNTED_P(value)) {
31415 Z_ADDREF_P(value);
31416 }
31417 } else if (IS_TMP_VAR == IS_VAR) {
31418 zval *free_op_data = EX_VAR((opline+1)->op1.var);
31419 if (Z_ISREF_P(free_op_data)) {
31420 if (Z_REFCOUNTED_P(value)) {
31421 Z_ADDREF_P(value);
31422 }
31423 zval_ptr_dtor_nogc(free_op_data);
31424 }
31425 } else if (IS_TMP_VAR == IS_CONST) {
31426 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
31427 Z_ADDREF_P(value);
31428 }
31429 }
31430 } else {
31431 dim = EX_VAR(opline->op2.var);
31432 if (IS_CV == IS_CONST) {
31433 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31434 } else {
31435 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31436 }
31437 if (UNEXPECTED(variable_ptr == NULL)) {
31438 goto assign_dim_error;
31439 }
31440 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31441 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
31442 }
31443 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31444 ZVAL_COPY(EX_VAR(opline->result.var), value);
31445 }
31446 if (garbage) {
31447 GC_DTOR_NO_REF(garbage);
31448 }
31449 } else {
31450 if (EXPECTED(Z_ISREF_P(object_ptr))) {
31451 object_ptr = Z_REFVAL_P(object_ptr);
31452 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31453 goto try_assign_dim_array;
31454 }
31455 }
31456 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
31457 zend_object *obj = Z_OBJ_P(object_ptr);
31458
31459 GC_ADDREF(obj);
31460 dim = EX_VAR(opline->op2.var);
31461 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
31462 dim = ZVAL_UNDEFINED_OP2();
31463 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
31464 dim++;
31465 }
31466
31467 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31468 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
31469 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31470 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
31471 ZVAL_DEREF(value);
31472 }
31473
31474 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
31475
31476 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31477 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
31478 zend_objects_store_del(obj);
31479 }
31480 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
31481 if (IS_CV == IS_UNUSED) {
31482 zend_use_new_element_for_string();
31483 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31484 UNDEF_RESULT();
31485 } else {
31486 dim = EX_VAR(opline->op2.var);
31487 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
31488 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
31489 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31490 }
31491 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
31492 if (Z_ISREF_P(orig_object_ptr)
31493 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
31494 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
31495 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31496 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31497 UNDEF_RESULT();
31498 } else {
31499 HashTable *ht = zend_new_array(8);
31500 uint8_t old_type = Z_TYPE_P(object_ptr);
31501
31502 ZVAL_ARR(object_ptr, ht);
31503 if (UNEXPECTED(old_type == IS_FALSE)) {
31504 GC_ADDREF(ht);
31505 zend_false_to_array_deprecated();
31506 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
31507 zend_array_destroy(ht);
31508 goto assign_dim_error;
31509 }
31510 }
31511 goto try_assign_dim_array;
31512 }
31513 } else {
31514 zend_use_scalar_as_array();
31515 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31516 assign_dim_error:
31517 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31518 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31519 ZVAL_NULL(EX_VAR(opline->result.var));
31520 }
31521 }
31522 }
31523 if (IS_CV != IS_UNUSED) {
31524
31525 }
31526 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31527 /* assign_dim has two opcodes! */
31528 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31529 }
31530
ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31531 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31532 {
31533 USE_OPLINE
31534 zval *object_ptr, *orig_object_ptr;
31535 zval *value;
31536 zval *variable_ptr;
31537 zval *dim;
31538 zend_refcounted *garbage = NULL;
31539
31540 SAVE_OPLINE();
31541 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31542
31543 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31544 try_assign_dim_array:
31545 SEPARATE_ARRAY(object_ptr);
31546 if (IS_CV == IS_UNUSED) {
31547 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31548 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
31549 HashTable *ht = Z_ARRVAL_P(object_ptr);
31550 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
31551 GC_ADDREF(ht);
31552 }
31553 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31554 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
31555 zend_array_destroy(ht);
31556 goto assign_dim_error;
31557 }
31558 }
31559 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
31560 ZVAL_DEREF(value);
31561 }
31562 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
31563 if (UNEXPECTED(value == NULL)) {
31564 zend_cannot_add_element();
31565 goto assign_dim_error;
31566 } else if (IS_VAR == IS_CV) {
31567 if (Z_REFCOUNTED_P(value)) {
31568 Z_ADDREF_P(value);
31569 }
31570 } else if (IS_VAR == IS_VAR) {
31571 zval *free_op_data = EX_VAR((opline+1)->op1.var);
31572 if (Z_ISREF_P(free_op_data)) {
31573 if (Z_REFCOUNTED_P(value)) {
31574 Z_ADDREF_P(value);
31575 }
31576 zval_ptr_dtor_nogc(free_op_data);
31577 }
31578 } else if (IS_VAR == IS_CONST) {
31579 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
31580 Z_ADDREF_P(value);
31581 }
31582 }
31583 } else {
31584 dim = EX_VAR(opline->op2.var);
31585 if (IS_CV == IS_CONST) {
31586 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31587 } else {
31588 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31589 }
31590 if (UNEXPECTED(variable_ptr == NULL)) {
31591 goto assign_dim_error;
31592 }
31593 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31594 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
31595 }
31596 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31597 ZVAL_COPY(EX_VAR(opline->result.var), value);
31598 }
31599 if (garbage) {
31600 GC_DTOR_NO_REF(garbage);
31601 }
31602 } else {
31603 if (EXPECTED(Z_ISREF_P(object_ptr))) {
31604 object_ptr = Z_REFVAL_P(object_ptr);
31605 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31606 goto try_assign_dim_array;
31607 }
31608 }
31609 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
31610 zend_object *obj = Z_OBJ_P(object_ptr);
31611
31612 GC_ADDREF(obj);
31613 dim = EX_VAR(opline->op2.var);
31614 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
31615 dim = ZVAL_UNDEFINED_OP2();
31616 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
31617 dim++;
31618 }
31619
31620 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31621 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
31622 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31623 } else if (IS_VAR & (IS_CV|IS_VAR)) {
31624 ZVAL_DEREF(value);
31625 }
31626
31627 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
31628
31629 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31630 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
31631 zend_objects_store_del(obj);
31632 }
31633 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
31634 if (IS_CV == IS_UNUSED) {
31635 zend_use_new_element_for_string();
31636 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31637 UNDEF_RESULT();
31638 } else {
31639 dim = EX_VAR(opline->op2.var);
31640 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31641 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
31642 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31643 }
31644 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
31645 if (Z_ISREF_P(orig_object_ptr)
31646 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
31647 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
31648 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31649 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31650 UNDEF_RESULT();
31651 } else {
31652 HashTable *ht = zend_new_array(8);
31653 uint8_t old_type = Z_TYPE_P(object_ptr);
31654
31655 ZVAL_ARR(object_ptr, ht);
31656 if (UNEXPECTED(old_type == IS_FALSE)) {
31657 GC_ADDREF(ht);
31658 zend_false_to_array_deprecated();
31659 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
31660 zend_array_destroy(ht);
31661 goto assign_dim_error;
31662 }
31663 }
31664 goto try_assign_dim_array;
31665 }
31666 } else {
31667 zend_use_scalar_as_array();
31668 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31669 assign_dim_error:
31670 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31671 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31672 ZVAL_NULL(EX_VAR(opline->result.var));
31673 }
31674 }
31675 }
31676 if (IS_CV != IS_UNUSED) {
31677
31678 }
31679 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31680 /* assign_dim has two opcodes! */
31681 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31682 }
31683
ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31684 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31685 {
31686 USE_OPLINE
31687 zval *object_ptr, *orig_object_ptr;
31688 zval *value;
31689 zval *variable_ptr;
31690 zval *dim;
31691 zend_refcounted *garbage = NULL;
31692
31693 SAVE_OPLINE();
31694 orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31695
31696 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31697 try_assign_dim_array:
31698 SEPARATE_ARRAY(object_ptr);
31699 if (IS_CV == IS_UNUSED) {
31700 value = EX_VAR((opline+1)->op1.var);
31701 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
31702 HashTable *ht = Z_ARRVAL_P(object_ptr);
31703 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
31704 GC_ADDREF(ht);
31705 }
31706 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31707 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
31708 zend_array_destroy(ht);
31709 goto assign_dim_error;
31710 }
31711 }
31712 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
31713 ZVAL_DEREF(value);
31714 }
31715 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
31716 if (UNEXPECTED(value == NULL)) {
31717 zend_cannot_add_element();
31718 goto assign_dim_error;
31719 } else if (IS_CV == IS_CV) {
31720 if (Z_REFCOUNTED_P(value)) {
31721 Z_ADDREF_P(value);
31722 }
31723 } else if (IS_CV == IS_VAR) {
31724 zval *free_op_data = EX_VAR((opline+1)->op1.var);
31725 if (Z_ISREF_P(free_op_data)) {
31726 if (Z_REFCOUNTED_P(value)) {
31727 Z_ADDREF_P(value);
31728 }
31729 zval_ptr_dtor_nogc(free_op_data);
31730 }
31731 } else if (IS_CV == IS_CONST) {
31732 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
31733 Z_ADDREF_P(value);
31734 }
31735 }
31736 } else {
31737 dim = EX_VAR(opline->op2.var);
31738 if (IS_CV == IS_CONST) {
31739 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31740 } else {
31741 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
31742 }
31743 if (UNEXPECTED(variable_ptr == NULL)) {
31744 goto assign_dim_error;
31745 }
31746 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
31747 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31748 }
31749 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31750 ZVAL_COPY(EX_VAR(opline->result.var), value);
31751 }
31752 if (garbage) {
31753 GC_DTOR_NO_REF(garbage);
31754 }
31755 } else {
31756 if (EXPECTED(Z_ISREF_P(object_ptr))) {
31757 object_ptr = Z_REFVAL_P(object_ptr);
31758 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
31759 goto try_assign_dim_array;
31760 }
31761 }
31762 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
31763 zend_object *obj = Z_OBJ_P(object_ptr);
31764
31765 GC_ADDREF(obj);
31766 dim = EX_VAR(opline->op2.var);
31767 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
31768 dim = ZVAL_UNDEFINED_OP2();
31769 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
31770 dim++;
31771 }
31772
31773 value = EX_VAR((opline+1)->op1.var);
31774 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
31775 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
31776 } else if (IS_CV & (IS_CV|IS_VAR)) {
31777 ZVAL_DEREF(value);
31778 }
31779
31780 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
31781
31782 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
31783 zend_objects_store_del(obj);
31784 }
31785 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
31786 if (IS_CV == IS_UNUSED) {
31787 zend_use_new_element_for_string();
31788
31789 UNDEF_RESULT();
31790 } else {
31791 dim = EX_VAR(opline->op2.var);
31792 value = EX_VAR((opline+1)->op1.var);
31793 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
31794
31795 }
31796 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
31797 if (Z_ISREF_P(orig_object_ptr)
31798 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
31799 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
31800 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31801
31802 UNDEF_RESULT();
31803 } else {
31804 HashTable *ht = zend_new_array(8);
31805 uint8_t old_type = Z_TYPE_P(object_ptr);
31806
31807 ZVAL_ARR(object_ptr, ht);
31808 if (UNEXPECTED(old_type == IS_FALSE)) {
31809 GC_ADDREF(ht);
31810 zend_false_to_array_deprecated();
31811 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
31812 zend_array_destroy(ht);
31813 goto assign_dim_error;
31814 }
31815 }
31816 goto try_assign_dim_array;
31817 }
31818 } else {
31819 zend_use_scalar_as_array();
31820 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31821 assign_dim_error:
31822
31823 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31824 ZVAL_NULL(EX_VAR(opline->result.var));
31825 }
31826 }
31827 }
31828 if (IS_CV != IS_UNUSED) {
31829
31830 }
31831 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31832 /* assign_dim has two opcodes! */
31833 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31834 }
31835
ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31836 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31837 {
31838 USE_OPLINE
31839 zval *value;
31840 zval *variable_ptr;
31841
31842 SAVE_OPLINE();
31843 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31844 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31845
31846 if (0 || UNEXPECTED(0)) {
31847 zend_refcounted *garbage = NULL;
31848
31849 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31850 if (UNEXPECTED(0)) {
31851 ZVAL_COPY(EX_VAR(opline->result.var), value);
31852 }
31853 if (garbage) {
31854 GC_DTOR_NO_REF(garbage);
31855 }
31856 } else {
31857 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
31858 }
31859 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31860 /* zend_assign_to_variable() always takes care of op2, never free it! */
31861
31862 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31863 }
31864
ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31865 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31866 {
31867 USE_OPLINE
31868 zval *value;
31869 zval *variable_ptr;
31870
31871 SAVE_OPLINE();
31872 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31873 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31874
31875 if (0 || UNEXPECTED(1)) {
31876 zend_refcounted *garbage = NULL;
31877
31878 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
31879 if (UNEXPECTED(1)) {
31880 ZVAL_COPY(EX_VAR(opline->result.var), value);
31881 }
31882 if (garbage) {
31883 GC_DTOR_NO_REF(garbage);
31884 }
31885 } else {
31886 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
31887 }
31888 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31889 /* zend_assign_to_variable() always takes care of op2, never free it! */
31890
31891 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31892 }
31893
ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31894 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31895 {
31896 USE_OPLINE
31897 zval *variable_ptr;
31898 zval *value_ptr;
31899 zend_refcounted *garbage = NULL;
31900
31901 SAVE_OPLINE();
31902 value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
31903 variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31904
31905 if (IS_VAR == IS_VAR &&
31906 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
31907
31908 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
31909 variable_ptr = &EG(uninitialized_zval);
31910 } else if (IS_CV == IS_VAR &&
31911 opline->extended_value == ZEND_RETURNS_FUNCTION &&
31912 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
31913
31914 variable_ptr = zend_wrong_assign_to_variable_reference(
31915 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
31916 } else {
31917 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
31918 }
31919
31920 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
31921 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
31922 }
31923
31924 if (garbage) {
31925 GC_DTOR(garbage);
31926 }
31927
31928 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31929 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
31930 }
31931
ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)31932 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31933 {
31934 USE_OPLINE
31935 zval *property, *container, *value_ptr;
31936
31937 SAVE_OPLINE();
31938
31939 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31940 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31941
31942 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
31943
31944 if (1) {
31945 if (IS_VAR == IS_UNUSED) {
31946 if (IS_CV == IS_CONST) {
31947 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31948 } else {
31949 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31950 }
31951 } else {
31952 if (IS_CV == IS_CONST) {
31953 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31954 } else {
31955 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31956 }
31957 }
31958 } else {
31959 zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31960 }
31961
31962 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
31963
31964 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
31965 ZEND_VM_NEXT_OPCODE_EX(1, 2);
31966 }
31967
31968 /* 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)31969 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
31970 {
31971 USE_OPLINE
31972 zval *property, *container, *value_ptr;
31973
31974 SAVE_OPLINE();
31975
31976 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
31977 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
31978
31979 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
31980
31981 if (1) {
31982 if (IS_VAR == IS_UNUSED) {
31983 if (IS_CV == IS_CONST) {
31984 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31985 } else {
31986 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31987 }
31988 } else {
31989 if (IS_CV == IS_CONST) {
31990 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31991 } else {
31992 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31993 }
31994 }
31995 } else {
31996 zend_assign_to_property_reference(container, IS_VAR, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
31997 }
31998
31999 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32000
32001
32002 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32003 }
32004
32005 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32006 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32007 {
32008 USE_OPLINE
32009 zval *function_name;
32010 zend_class_entry *ce;
32011 uint32_t call_info;
32012 zend_function *fbc;
32013 zend_execute_data *call;
32014
32015 SAVE_OPLINE();
32016
32017 if (IS_VAR == IS_CONST) {
32018 /* no function found. try a static method in class */
32019 ce = CACHED_PTR(opline->result.num);
32020 if (UNEXPECTED(ce == NULL)) {
32021 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);
32022 if (UNEXPECTED(ce == NULL)) {
32023
32024 HANDLE_EXCEPTION();
32025 }
32026 if (IS_CV != IS_CONST) {
32027 CACHE_PTR(opline->result.num, ce);
32028 }
32029 }
32030 } else if (IS_VAR == IS_UNUSED) {
32031 ce = zend_fetch_class(NULL, opline->op1.num);
32032 if (UNEXPECTED(ce == NULL)) {
32033
32034 HANDLE_EXCEPTION();
32035 }
32036 } else {
32037 ce = Z_CE_P(EX_VAR(opline->op1.var));
32038 }
32039
32040 if (IS_VAR == IS_CONST &&
32041 IS_CV == IS_CONST &&
32042 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
32043 /* nothing to do */
32044 } else if (IS_VAR != IS_CONST &&
32045 IS_CV == IS_CONST &&
32046 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
32047 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
32048 } else if (IS_CV != IS_UNUSED) {
32049 function_name = EX_VAR(opline->op2.var);
32050 if (IS_CV != IS_CONST) {
32051 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
32052 do {
32053 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
32054 function_name = Z_REFVAL_P(function_name);
32055 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
32056 break;
32057 }
32058 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
32059 ZVAL_UNDEFINED_OP2();
32060 if (UNEXPECTED(EG(exception) != NULL)) {
32061 HANDLE_EXCEPTION();
32062 }
32063 }
32064 zend_throw_error(NULL, "Method name must be a string");
32065
32066 HANDLE_EXCEPTION();
32067 } while (0);
32068 }
32069 }
32070
32071 if (ce->get_static_method) {
32072 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
32073 } else {
32074 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
32075 }
32076 if (UNEXPECTED(fbc == NULL)) {
32077 if (EXPECTED(!EG(exception))) {
32078 zend_undefined_method(ce, Z_STR_P(function_name));
32079 }
32080
32081 HANDLE_EXCEPTION();
32082 }
32083 if (IS_CV == IS_CONST &&
32084 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
32085 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
32086 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
32087 }
32088 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32089 init_func_run_time_cache(&fbc->op_array);
32090 }
32091 if (IS_CV != IS_CONST) {
32092
32093 }
32094 } else {
32095 if (UNEXPECTED(ce->constructor == NULL)) {
32096 zend_throw_error(NULL, "Cannot call constructor");
32097 HANDLE_EXCEPTION();
32098 }
32099 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
32100 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
32101 HANDLE_EXCEPTION();
32102 }
32103 fbc = ce->constructor;
32104 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
32105 init_func_run_time_cache(&fbc->op_array);
32106 }
32107 }
32108
32109 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
32110 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
32111 ce = (zend_class_entry*)Z_OBJ(EX(This));
32112 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
32113 } else {
32114 zend_non_static_method_call(fbc);
32115 HANDLE_EXCEPTION();
32116 }
32117 } else {
32118 /* previous opcode is ZEND_FETCH_CLASS */
32119 if (IS_VAR == IS_UNUSED
32120 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
32121 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
32122 if (Z_TYPE(EX(This)) == IS_OBJECT) {
32123 ce = Z_OBJCE(EX(This));
32124 } else {
32125 ce = Z_CE(EX(This));
32126 }
32127 }
32128 call_info = ZEND_CALL_NESTED_FUNCTION;
32129 }
32130
32131 call = zend_vm_stack_push_call_frame(call_info,
32132 fbc, opline->extended_value, ce);
32133 call->prev_execute_data = EX(call);
32134 EX(call) = call;
32135
32136 ZEND_VM_NEXT_OPCODE();
32137 }
32138
ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32139 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32140 {
32141 USE_OPLINE
32142 zval *expr_ptr, new_expr;
32143
32144 SAVE_OPLINE();
32145 if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
32146 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
32147 expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32148 if (Z_ISREF_P(expr_ptr)) {
32149 Z_ADDREF_P(expr_ptr);
32150 } else {
32151 ZVAL_MAKE_REF_EX(expr_ptr, 2);
32152 }
32153 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32154 } else {
32155 expr_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32156 if (IS_VAR == IS_TMP_VAR) {
32157 /* pass */
32158 } else if (IS_VAR == IS_CONST) {
32159 Z_TRY_ADDREF_P(expr_ptr);
32160 } else if (IS_VAR == IS_CV) {
32161 ZVAL_DEREF(expr_ptr);
32162 Z_TRY_ADDREF_P(expr_ptr);
32163 } else /* if (IS_VAR == IS_VAR) */ {
32164 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
32165 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
32166
32167 expr_ptr = Z_REFVAL_P(expr_ptr);
32168 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
32169 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
32170 expr_ptr = &new_expr;
32171 efree_size(ref, sizeof(zend_reference));
32172 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
32173 Z_ADDREF_P(expr_ptr);
32174 }
32175 }
32176 }
32177 }
32178
32179 if (IS_CV != IS_UNUSED) {
32180 zval *offset = EX_VAR(opline->op2.var);
32181 zend_string *str;
32182 zend_ulong hval;
32183
32184 add_again:
32185 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
32186 str = Z_STR_P(offset);
32187 if (IS_CV != IS_CONST) {
32188 if (ZEND_HANDLE_NUMERIC(str, hval)) {
32189 goto num_index;
32190 }
32191 }
32192 str_index:
32193 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
32194 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
32195 hval = Z_LVAL_P(offset);
32196 num_index:
32197 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
32198 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
32199 offset = Z_REFVAL_P(offset);
32200 goto add_again;
32201 } else if (Z_TYPE_P(offset) == IS_NULL) {
32202 str = ZSTR_EMPTY_ALLOC();
32203 goto str_index;
32204 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
32205 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
32206 goto num_index;
32207 } else if (Z_TYPE_P(offset) == IS_FALSE) {
32208 hval = 0;
32209 goto num_index;
32210 } else if (Z_TYPE_P(offset) == IS_TRUE) {
32211 hval = 1;
32212 goto num_index;
32213 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
32214 zend_use_resource_as_offset(offset);
32215 hval = Z_RES_HANDLE_P(offset);
32216 goto num_index;
32217 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
32218 ZVAL_UNDEFINED_OP2();
32219 str = ZSTR_EMPTY_ALLOC();
32220 goto str_index;
32221 } else {
32222 zend_illegal_array_offset_access(offset);
32223 zval_ptr_dtor_nogc(expr_ptr);
32224 }
32225
32226 } else {
32227 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
32228 zend_cannot_add_element();
32229 zval_ptr_dtor_nogc(expr_ptr);
32230 }
32231 }
32232 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32233 }
32234
ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32235 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32236 {
32237 zval *array;
32238 uint32_t size;
32239 USE_OPLINE
32240
32241 array = EX_VAR(opline->result.var);
32242 if (IS_VAR != IS_UNUSED) {
32243 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
32244 ZVAL_ARR(array, zend_new_array(size));
32245 /* Explicitly initialize array as not-packed if flag is set */
32246 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
32247 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
32248 }
32249 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
32250 } else {
32251 ZVAL_ARR(array, zend_new_array(0));
32252 ZEND_VM_NEXT_OPCODE();
32253 }
32254 }
32255
ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32256 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32257 {
32258 USE_OPLINE
32259 zval *container;
32260 zval *offset;
32261 zend_ulong hval;
32262 zend_string *key;
32263
32264 SAVE_OPLINE();
32265 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32266 offset = EX_VAR(opline->op2.var);
32267
32268 do {
32269 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
32270 HashTable *ht;
32271
32272 unset_dim_array:
32273 SEPARATE_ARRAY(container);
32274 ht = Z_ARRVAL_P(container);
32275 offset_again:
32276 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
32277 key = Z_STR_P(offset);
32278 if (IS_CV != IS_CONST) {
32279 if (ZEND_HANDLE_NUMERIC(key, hval)) {
32280 goto num_index_dim;
32281 }
32282 }
32283 str_index_dim:
32284 ZEND_ASSERT(ht != &EG(symbol_table));
32285 zend_hash_del(ht, key);
32286 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
32287 hval = Z_LVAL_P(offset);
32288 num_index_dim:
32289 zend_hash_index_del(ht, hval);
32290 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
32291 offset = Z_REFVAL_P(offset);
32292 goto offset_again;
32293 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
32294 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
32295 goto num_index_dim;
32296 } else if (Z_TYPE_P(offset) == IS_NULL) {
32297 key = ZSTR_EMPTY_ALLOC();
32298 goto str_index_dim;
32299 } else if (Z_TYPE_P(offset) == IS_FALSE) {
32300 hval = 0;
32301 goto num_index_dim;
32302 } else if (Z_TYPE_P(offset) == IS_TRUE) {
32303 hval = 1;
32304 goto num_index_dim;
32305 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
32306 zend_use_resource_as_offset(offset);
32307 hval = Z_RES_HANDLE_P(offset);
32308 goto num_index_dim;
32309 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
32310 ZVAL_UNDEFINED_OP2();
32311 key = ZSTR_EMPTY_ALLOC();
32312 goto str_index_dim;
32313 } else {
32314 zend_illegal_array_offset_unset(offset);
32315 }
32316 break;
32317 } else if (Z_ISREF_P(container)) {
32318 container = Z_REFVAL_P(container);
32319 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
32320 goto unset_dim_array;
32321 }
32322 }
32323 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
32324 container = ZVAL_UNDEFINED_OP1();
32325 }
32326 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
32327 offset = ZVAL_UNDEFINED_OP2();
32328 }
32329 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
32330 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
32331 offset++;
32332 }
32333 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
32334 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
32335 zend_throw_error(NULL, "Cannot unset string offsets");
32336 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
32337 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
32338 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
32339 zend_false_to_array_deprecated();
32340 }
32341 } while (0);
32342
32343 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32344 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32345 }
32346
ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32347 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32348 {
32349 USE_OPLINE
32350 zval *container;
32351 zval *offset;
32352 zend_string *name, *tmp_name;
32353
32354 SAVE_OPLINE();
32355 container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32356 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32357
32358 do {
32359 if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
32360 if (Z_ISREF_P(container)) {
32361 container = Z_REFVAL_P(container);
32362 if (Z_TYPE_P(container) != IS_OBJECT) {
32363 if (IS_VAR == IS_CV
32364 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
32365 ZVAL_UNDEFINED_OP1();
32366 }
32367 break;
32368 }
32369 } else {
32370 break;
32371 }
32372 }
32373 if (IS_CV == IS_CONST) {
32374 name = Z_STR_P(offset);
32375 } else {
32376 name = zval_try_get_tmp_string(offset, &tmp_name);
32377 if (UNEXPECTED(!name)) {
32378 break;
32379 }
32380 }
32381 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
32382 if (IS_CV != IS_CONST) {
32383 zend_tmp_string_release(tmp_name);
32384 }
32385 } while (0);
32386
32387 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32388 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32389 }
32390
ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32391 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32392 {
32393 USE_OPLINE
32394
32395 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
32396
32397 SAVE_OPLINE();
32398 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
32399 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
32400 }
32401
32402 /* Destroy the previously yielded value */
32403 zval_ptr_dtor(&generator->value);
32404
32405 /* Destroy the previously yielded key */
32406 zval_ptr_dtor(&generator->key);
32407
32408 /* Set the new yielded value */
32409 if (IS_VAR != IS_UNUSED) {
32410 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
32411 /* Constants and temporary variables aren't yieldable by reference,
32412 * but we still allow them with a notice. */
32413 if (IS_VAR & (IS_CONST|IS_TMP_VAR)) {
32414 zval *value;
32415
32416 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
32417
32418 value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32419 ZVAL_COPY_VALUE(&generator->value, value);
32420 if (IS_VAR == IS_CONST) {
32421 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
32422 Z_ADDREF(generator->value);
32423 }
32424 }
32425 } else {
32426 zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32427
32428 /* If a function call result is yielded and the function did
32429 * not return by reference we throw a notice. */
32430 do {
32431 if (IS_VAR == IS_VAR) {
32432 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
32433 if (opline->extended_value == ZEND_RETURNS_FUNCTION
32434 && !Z_ISREF_P(value_ptr)) {
32435 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
32436 ZVAL_COPY(&generator->value, value_ptr);
32437 break;
32438 }
32439 }
32440 if (Z_ISREF_P(value_ptr)) {
32441 Z_ADDREF_P(value_ptr);
32442 } else {
32443 ZVAL_MAKE_REF_EX(value_ptr, 2);
32444 }
32445 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
32446 } while (0);
32447
32448 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32449 }
32450 } else {
32451 zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
32452
32453 /* Consts, temporary variables and references need copying */
32454 if (IS_VAR == IS_CONST) {
32455 ZVAL_COPY_VALUE(&generator->value, value);
32456 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
32457 Z_ADDREF(generator->value);
32458 }
32459 } else if (IS_VAR == IS_TMP_VAR) {
32460 ZVAL_COPY_VALUE(&generator->value, value);
32461 } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
32462 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
32463 zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
32464 } else {
32465 ZVAL_COPY_VALUE(&generator->value, value);
32466 if (IS_VAR == IS_CV) {
32467 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
32468 }
32469 }
32470 }
32471 } else {
32472 /* If no value was specified yield null */
32473 ZVAL_NULL(&generator->value);
32474 }
32475
32476 /* Set the new yielded key */
32477 if (IS_CV != IS_UNUSED) {
32478 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
32479 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
32480 key = Z_REFVAL_P(key);
32481 }
32482 ZVAL_COPY(&generator->key, key);
32483
32484 if (Z_TYPE(generator->key) == IS_LONG
32485 && Z_LVAL(generator->key) > generator->largest_used_integer_key
32486 ) {
32487 generator->largest_used_integer_key = Z_LVAL(generator->key);
32488 }
32489 } else {
32490 /* If no key was specified we use auto-increment keys */
32491 generator->largest_used_integer_key++;
32492 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
32493 }
32494
32495 if (RETURN_VALUE_USED(opline)) {
32496 /* If the return value of yield is used set the send
32497 * target and initialize it to NULL */
32498 generator->send_target = EX_VAR(opline->result.var);
32499 ZVAL_NULL(generator->send_target);
32500 } else {
32501 generator->send_target = NULL;
32502 }
32503
32504 /* We increment to the next op, so we are at the correct position when the
32505 * generator is resumed. */
32506 ZEND_VM_INC_OPCODE();
32507
32508 /* The GOTO VM uses a local opline variable. We need to set the opline
32509 * variable in execute_data so we don't resume at an old position. */
32510 SAVE_OPLINE();
32511
32512 ZEND_VM_RETURN();
32513 }
32514
ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32515 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)
32516 {
32517 USE_OPLINE
32518 zval *array;
32519 zval *value, *variable_ptr;
32520 uint32_t value_type;
32521 HashTable *fe_ht;
32522 HashPosition pos;
32523
32524 array = EX_VAR(opline->op1.var);
32525 SAVE_OPLINE();
32526 fe_ht = Z_ARRVAL_P(array);
32527 pos = Z_FE_POS_P(array);
32528 if (HT_IS_PACKED(fe_ht)) {
32529 value = fe_ht->arPacked + pos;
32530 while (1) {
32531 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
32532 /* reached end of iteration */
32533 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
32534 ZEND_VM_CONTINUE();
32535 }
32536 value_type = Z_TYPE_INFO_P(value);
32537 ZEND_ASSERT(value_type != IS_INDIRECT);
32538 if (EXPECTED(value_type != IS_UNDEF)) {
32539 break;
32540 }
32541 pos++;
32542 value++;
32543 }
32544 Z_FE_POS_P(array) = pos + 1;
32545 if (0) {
32546 ZVAL_LONG(EX_VAR(opline->result.var), pos);
32547 }
32548 } else {
32549 Bucket *p;
32550
32551 p = fe_ht->arData + pos;
32552 while (1) {
32553 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
32554 /* reached end of iteration */
32555 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
32556 ZEND_VM_CONTINUE();
32557 }
32558 pos++;
32559 value = &p->val;
32560 value_type = Z_TYPE_INFO_P(value);
32561 ZEND_ASSERT(value_type != IS_INDIRECT);
32562 if (EXPECTED(value_type != IS_UNDEF)) {
32563 break;
32564 }
32565 p++;
32566 }
32567 Z_FE_POS_P(array) = pos;
32568 if (0) {
32569 if (!p->key) {
32570 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
32571 } else {
32572 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
32573 }
32574 }
32575 }
32576
32577 variable_ptr = EX_VAR(opline->op2.var);
32578 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32579 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32580 }
32581
32582
ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32583 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)
32584 {
32585 USE_OPLINE
32586 zval *array;
32587 zval *value, *variable_ptr;
32588 uint32_t value_type;
32589 HashTable *fe_ht;
32590 HashPosition pos;
32591
32592 array = EX_VAR(opline->op1.var);
32593 SAVE_OPLINE();
32594 fe_ht = Z_ARRVAL_P(array);
32595 pos = Z_FE_POS_P(array);
32596 if (HT_IS_PACKED(fe_ht)) {
32597 value = fe_ht->arPacked + pos;
32598 while (1) {
32599 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
32600 /* reached end of iteration */
32601 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
32602 ZEND_VM_CONTINUE();
32603 }
32604 value_type = Z_TYPE_INFO_P(value);
32605 ZEND_ASSERT(value_type != IS_INDIRECT);
32606 if (EXPECTED(value_type != IS_UNDEF)) {
32607 break;
32608 }
32609 pos++;
32610 value++;
32611 }
32612 Z_FE_POS_P(array) = pos + 1;
32613 if (1) {
32614 ZVAL_LONG(EX_VAR(opline->result.var), pos);
32615 }
32616 } else {
32617 Bucket *p;
32618
32619 p = fe_ht->arData + pos;
32620 while (1) {
32621 if (UNEXPECTED(pos >= fe_ht->nNumUsed)) {
32622 /* reached end of iteration */
32623 ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
32624 ZEND_VM_CONTINUE();
32625 }
32626 pos++;
32627 value = &p->val;
32628 value_type = Z_TYPE_INFO_P(value);
32629 ZEND_ASSERT(value_type != IS_INDIRECT);
32630 if (EXPECTED(value_type != IS_UNDEF)) {
32631 break;
32632 }
32633 p++;
32634 }
32635 Z_FE_POS_P(array) = pos;
32636 if (1) {
32637 if (!p->key) {
32638 ZVAL_LONG(EX_VAR(opline->result.var), p->h);
32639 } else {
32640 ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key);
32641 }
32642 }
32643 }
32644
32645 variable_ptr = EX_VAR(opline->op2.var);
32646 zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
32647 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32648 }
32649
32650
ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32651 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32652 {
32653 USE_OPLINE
32654 zval *obj;
32655 zend_object *zobj;
32656 zend_class_entry *ce, *scope;
32657 zend_function *clone;
32658 zend_object_clone_obj_t clone_call;
32659
32660 SAVE_OPLINE();
32661 obj = &EX(This);
32662
32663 do {
32664 if (IS_UNUSED == IS_CONST ||
32665 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
32666 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
32667 obj = Z_REFVAL_P(obj);
32668 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
32669 break;
32670 }
32671 }
32672 ZVAL_UNDEF(EX_VAR(opline->result.var));
32673 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
32674 ZVAL_UNDEFINED_OP1();
32675 if (UNEXPECTED(EG(exception) != NULL)) {
32676 HANDLE_EXCEPTION();
32677 }
32678 }
32679 zend_throw_error(NULL, "__clone method called on non-object");
32680
32681 HANDLE_EXCEPTION();
32682 }
32683 } while (0);
32684
32685 zobj = Z_OBJ_P(obj);
32686 ce = zobj->ce;
32687 clone = ce->clone;
32688 clone_call = zobj->handlers->clone_obj;
32689 if (UNEXPECTED(clone_call == NULL)) {
32690 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
32691
32692 ZVAL_UNDEF(EX_VAR(opline->result.var));
32693 HANDLE_EXCEPTION();
32694 }
32695
32696 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
32697 scope = EX(func)->op_array.scope;
32698 if (clone->common.scope != scope) {
32699 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
32700 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
32701 zend_wrong_clone_call(clone, scope);
32702
32703 ZVAL_UNDEF(EX_VAR(opline->result.var));
32704 HANDLE_EXCEPTION();
32705 }
32706 }
32707 }
32708
32709 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
32710
32711 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32712 }
32713
ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32714 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32715 {
32716 uint32_t fetch_type;
32717 zend_class_entry *called_scope, *scope;
32718 USE_OPLINE
32719
32720 if (IS_UNUSED != IS_UNUSED) {
32721 SAVE_OPLINE();
32722 zval *op = NULL;
32723 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
32724 ZVAL_DEREF(op);
32725 if (Z_TYPE_P(op) != IS_OBJECT) {
32726 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
32727 ZVAL_UNDEF(EX_VAR(opline->result.var));
32728
32729 HANDLE_EXCEPTION();
32730 }
32731 }
32732
32733 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
32734
32735 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32736 }
32737
32738 fetch_type = opline->op1.num;
32739 scope = EX(func)->op_array.scope;
32740 if (UNEXPECTED(scope == NULL)) {
32741 SAVE_OPLINE();
32742 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
32743 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
32744 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
32745 ZVAL_UNDEF(EX_VAR(opline->result.var));
32746 HANDLE_EXCEPTION();
32747 }
32748
32749 switch (fetch_type) {
32750 case ZEND_FETCH_CLASS_SELF:
32751 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
32752 break;
32753 case ZEND_FETCH_CLASS_PARENT:
32754 if (UNEXPECTED(scope->parent == NULL)) {
32755 SAVE_OPLINE();
32756 zend_throw_error(NULL,
32757 "Cannot use \"parent\" when current class scope has no parent");
32758 ZVAL_UNDEF(EX_VAR(opline->result.var));
32759 HANDLE_EXCEPTION();
32760 }
32761 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
32762 break;
32763 case ZEND_FETCH_CLASS_STATIC:
32764 if (Z_TYPE(EX(This)) == IS_OBJECT) {
32765 called_scope = Z_OBJCE(EX(This));
32766 } else {
32767 called_scope = Z_CE(EX(This));
32768 }
32769 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
32770 break;
32771 EMPTY_SWITCH_DEFAULT_CASE()
32772 }
32773 ZEND_VM_NEXT_OPCODE();
32774 }
32775
ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32776 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32777 {
32778 USE_OPLINE
32779 zval *object;
32780 zval *property;
32781 zval *value;
32782 zval *zptr;
32783 void **cache_slot;
32784 zend_property_info *prop_info;
32785 zend_object *zobj;
32786 zend_string *name, *tmp_name;
32787
32788 SAVE_OPLINE();
32789 object = &EX(This);
32790 property = RT_CONSTANT(opline, opline->op2);
32791
32792 do {
32793 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
32794
32795 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32796 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
32797 object = Z_REFVAL_P(object);
32798 goto assign_op_object;
32799 }
32800 if (IS_UNUSED == IS_CV
32801 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
32802 ZVAL_UNDEFINED_OP1();
32803 }
32804 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
32805 break;
32806 }
32807
32808 assign_op_object:
32809 /* here we are sure we are dealing with an object */
32810 zobj = Z_OBJ_P(object);
32811 if (IS_CONST == IS_CONST) {
32812 name = Z_STR_P(property);
32813 } else {
32814 name = zval_try_get_tmp_string(property, &tmp_name);
32815 if (UNEXPECTED(!name)) {
32816 UNDEF_RESULT();
32817 break;
32818 }
32819 }
32820 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
32821 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
32822 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
32823 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32824 ZVAL_NULL(EX_VAR(opline->result.var));
32825 }
32826 } else {
32827 zval *orig_zptr = zptr;
32828 zend_reference *ref;
32829
32830 do {
32831 if (UNEXPECTED(Z_ISREF_P(zptr))) {
32832 ref = Z_REF_P(zptr);
32833 zptr = Z_REFVAL_P(zptr);
32834 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
32835 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
32836 break;
32837 }
32838 }
32839
32840 if (IS_CONST == IS_CONST) {
32841 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
32842 } else {
32843 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
32844 }
32845 if (prop_info) {
32846 /* special case for typed properties */
32847 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
32848 } else {
32849 zend_binary_op(zptr, zptr, value OPLINE_CC);
32850 }
32851 } while (0);
32852
32853 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32854 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
32855 }
32856 }
32857 } else {
32858 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
32859 }
32860 if (IS_CONST != IS_CONST) {
32861 zend_tmp_string_release(tmp_name);
32862 }
32863 } while (0);
32864
32865 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
32866
32867
32868 /* assign_obj has two opcodes! */
32869 ZEND_VM_NEXT_OPCODE_EX(1, 2);
32870 }
32871
32872 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32873 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32874 {
32875 USE_OPLINE
32876 zval *object;
32877 zval *property;
32878 zval *zptr;
32879 void **cache_slot;
32880 zend_property_info *prop_info;
32881 zend_object *zobj;
32882 zend_string *name, *tmp_name;
32883
32884 SAVE_OPLINE();
32885 object = &EX(This);
32886 property = RT_CONSTANT(opline, opline->op2);
32887
32888 do {
32889 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32890 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
32891 object = Z_REFVAL_P(object);
32892 goto pre_incdec_object;
32893 }
32894 if (IS_UNUSED == IS_CV
32895 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
32896 ZVAL_UNDEFINED_OP1();
32897 }
32898 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
32899 break;
32900 }
32901
32902 pre_incdec_object:
32903 /* here we are sure we are dealing with an object */
32904 zobj = Z_OBJ_P(object);
32905 if (IS_CONST == IS_CONST) {
32906 name = Z_STR_P(property);
32907 } else {
32908 name = zval_try_get_tmp_string(property, &tmp_name);
32909 if (UNEXPECTED(!name)) {
32910 UNDEF_RESULT();
32911 break;
32912 }
32913 }
32914 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
32915 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
32916 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
32917 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
32918 ZVAL_NULL(EX_VAR(opline->result.var));
32919 }
32920 } else {
32921 if (IS_CONST == IS_CONST) {
32922 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
32923 } else {
32924 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
32925 }
32926 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
32927 }
32928 } else {
32929 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
32930 }
32931 if (IS_CONST != IS_CONST) {
32932 zend_tmp_string_release(tmp_name);
32933 }
32934 } while (0);
32935
32936
32937 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
32938 }
32939
ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)32940 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
32941 {
32942 USE_OPLINE
32943 zval *object;
32944 zval *property;
32945 zval *zptr;
32946 void **cache_slot;
32947 zend_property_info *prop_info;
32948 zend_object *zobj;
32949 zend_string *name, *tmp_name;
32950
32951 SAVE_OPLINE();
32952 object = &EX(This);
32953 property = RT_CONSTANT(opline, opline->op2);
32954
32955 do {
32956 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
32957 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
32958 object = Z_REFVAL_P(object);
32959 goto post_incdec_object;
32960 }
32961 if (IS_UNUSED == IS_CV
32962 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
32963 ZVAL_UNDEFINED_OP1();
32964 }
32965 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
32966 break;
32967 }
32968
32969 post_incdec_object:
32970 /* here we are sure we are dealing with an object */
32971 zobj = Z_OBJ_P(object);
32972 if (IS_CONST == IS_CONST) {
32973 name = Z_STR_P(property);
32974 } else {
32975 name = zval_try_get_tmp_string(property, &tmp_name);
32976 if (UNEXPECTED(!name)) {
32977 ZVAL_UNDEF(EX_VAR(opline->result.var));
32978 break;
32979 }
32980 }
32981 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
32982 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
32983 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
32984 ZVAL_NULL(EX_VAR(opline->result.var));
32985 } else {
32986 if (IS_CONST == IS_CONST) {
32987 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
32988 } else {
32989 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
32990 }
32991
32992 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
32993 }
32994 } else {
32995 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
32996 }
32997 if (IS_CONST != IS_CONST) {
32998 zend_tmp_string_release(tmp_name);
32999 }
33000 } while (0);
33001
33002
33003 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33004 }
33005
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33006 static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33007 {
33008 USE_OPLINE
33009 zval *container;
33010 void **cache_slot = NULL;
33011
33012 SAVE_OPLINE();
33013 container = &EX(This);
33014
33015 if (IS_UNUSED == IS_CONST ||
33016 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
33017 do {
33018 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
33019 container = Z_REFVAL_P(container);
33020 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33021 break;
33022 }
33023 }
33024 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
33025 ZVAL_UNDEFINED_OP1();
33026 }
33027 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
33028 ZVAL_NULL(EX_VAR(opline->result.var));
33029 goto fetch_obj_r_finish;
33030 } while (0);
33031 }
33032
33033 /* here we are sure we are dealing with an object */
33034 do {
33035 zend_object *zobj = Z_OBJ_P(container);
33036 zend_string *name, *tmp_name;
33037 zval *retval;
33038
33039 if (IS_CONST == IS_CONST) {
33040 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
33041
33042 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
33043 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33044
33045 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33046 retval = OBJ_PROP(zobj, prop_offset);
33047 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
33048 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33049 goto fetch_obj_r_copy;
33050 } else {
33051 fetch_obj_r_fast_copy:
33052 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33053 ZEND_VM_NEXT_OPCODE();
33054 }
33055 }
33056 } else if (EXPECTED(zobj->properties != NULL)) {
33057 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33058 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
33059 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
33060
33061 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
33062 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
33063
33064 if (EXPECTED(p->key == name) ||
33065 (EXPECTED(p->h == ZSTR_H(name)) &&
33066 EXPECTED(p->key != NULL) &&
33067 EXPECTED(zend_string_equal_content(p->key, name)))) {
33068 retval = &p->val;
33069 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33070 goto fetch_obj_r_copy;
33071 } else {
33072 goto fetch_obj_r_fast_copy;
33073 }
33074 }
33075 }
33076 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
33077 }
33078 retval = zend_hash_find_known_hash(zobj->properties, name);
33079 if (EXPECTED(retval)) {
33080 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
33081 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
33082 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33083 goto fetch_obj_r_copy;
33084 } else {
33085 goto fetch_obj_r_fast_copy;
33086 }
33087 }
33088 }
33089 }
33090 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33091 } else {
33092 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33093 if (UNEXPECTED(!name)) {
33094 ZVAL_UNDEF(EX_VAR(opline->result.var));
33095 break;
33096 }
33097 }
33098
33099 #if ZEND_DEBUG
33100 /* For non-standard object handlers, verify a declared property type in debug builds.
33101 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
33102 zend_property_info *prop_info = NULL;
33103 if (zobj->handlers->read_property != zend_std_read_property) {
33104 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
33105 }
33106 #endif
33107 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
33108 #if ZEND_DEBUG
33109 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
33110 && ZEND_TYPE_IS_SET(prop_info->type)) {
33111 ZVAL_OPT_DEREF(retval);
33112 zend_verify_property_type(prop_info, retval, /* strict */ true);
33113 }
33114 #endif
33115
33116 if (IS_CONST != IS_CONST) {
33117 zend_tmp_string_release(tmp_name);
33118 }
33119
33120 if (retval != EX_VAR(opline->result.var)) {
33121 fetch_obj_r_copy:
33122 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33123 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
33124 zend_unwrap_reference(retval);
33125 }
33126 } while (0);
33127
33128 fetch_obj_r_finish:
33129
33130
33131 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33132 }
33133
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33134 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33135 {
33136 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33137 }
33138
ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33139 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33140 {
33141 USE_OPLINE
33142 zval *property, *container, *result;
33143
33144 SAVE_OPLINE();
33145
33146 container = &EX(This);
33147 property = RT_CONSTANT(opline, opline->op2);
33148 result = EX_VAR(opline->result.var);
33149 zend_fetch_property_address(
33150 result, container, IS_UNUSED, property, IS_CONST,
33151 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
33152 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
33153
33154 if (IS_UNUSED == IS_VAR) {
33155 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
33156 }
33157 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33158 }
33159
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33160 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33161 {
33162 USE_OPLINE
33163 zval *property, *container, *result;
33164
33165 SAVE_OPLINE();
33166 container = &EX(This);
33167 property = RT_CONSTANT(opline, opline->op2);
33168 result = EX_VAR(opline->result.var);
33169 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 OPLINE_CC EXECUTE_DATA_CC);
33170
33171 if (IS_UNUSED == IS_VAR) {
33172 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
33173 }
33174 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33175 }
33176
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33177 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33178 {
33179 USE_OPLINE
33180 zval *container;
33181 void **cache_slot = NULL;
33182
33183 SAVE_OPLINE();
33184 container = &EX(This);
33185
33186 if (IS_UNUSED == IS_CONST ||
33187 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
33188 do {
33189 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
33190 container = Z_REFVAL_P(container);
33191 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
33192 break;
33193 }
33194 }
33195 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
33196 ZVAL_UNDEFINED_OP2();
33197 }
33198 ZVAL_NULL(EX_VAR(opline->result.var));
33199 goto fetch_obj_is_finish;
33200 } while (0);
33201 }
33202
33203 /* here we are sure we are dealing with an object */
33204 do {
33205 zend_object *zobj = Z_OBJ_P(container);
33206 zend_string *name, *tmp_name;
33207 zval *retval;
33208
33209 if (IS_CONST == IS_CONST) {
33210 cache_slot = CACHE_ADDR(opline->extended_value);
33211
33212 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
33213 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33214
33215 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33216 retval = OBJ_PROP(zobj, prop_offset);
33217 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
33218 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33219 goto fetch_obj_is_copy;
33220 } else {
33221 fetch_obj_is_fast_copy:
33222 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33223 ZEND_VM_NEXT_OPCODE();
33224 }
33225 }
33226 } else if (EXPECTED(zobj->properties != NULL)) {
33227 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33228 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
33229 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
33230
33231 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
33232 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
33233
33234 if (EXPECTED(p->key == name) ||
33235 (EXPECTED(p->h == ZSTR_H(name)) &&
33236 EXPECTED(p->key != NULL) &&
33237 EXPECTED(zend_string_equal_content(p->key, name)))) {
33238 retval = &p->val;
33239 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33240 goto fetch_obj_is_copy;
33241 } else {
33242 goto fetch_obj_is_fast_copy;
33243 }
33244 }
33245 }
33246 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
33247 }
33248 retval = zend_hash_find_known_hash(zobj->properties, name);
33249 if (EXPECTED(retval)) {
33250 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
33251 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
33252 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
33253 goto fetch_obj_is_copy;
33254 } else {
33255 goto fetch_obj_is_fast_copy;
33256 }
33257 }
33258 }
33259 }
33260 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33261 } else {
33262 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33263 if (UNEXPECTED(!name)) {
33264 ZVAL_UNDEF(EX_VAR(opline->result.var));
33265 break;
33266 }
33267 }
33268
33269 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
33270
33271 if (IS_CONST != IS_CONST) {
33272 zend_tmp_string_release(tmp_name);
33273 }
33274
33275 if (retval != EX_VAR(opline->result.var)) {
33276 fetch_obj_is_copy:
33277 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
33278 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
33279 zend_unwrap_reference(retval);
33280 }
33281 } while (0);
33282
33283 fetch_obj_is_finish:
33284
33285
33286 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33287 }
33288
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33289 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33290 {
33291 #if 0
33292 USE_OPLINE
33293 #endif
33294
33295 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
33296 /* Behave like FETCH_OBJ_W */
33297 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
33298 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33299 }
33300 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33301 } else {
33302 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
33303 }
33304 }
33305
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33306 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33307 {
33308 USE_OPLINE
33309 zval *container, *property, *result;
33310
33311 SAVE_OPLINE();
33312 container = &EX(This);
33313 property = RT_CONSTANT(opline, opline->op2);
33314 result = EX_VAR(opline->result.var);
33315 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 OPLINE_CC EXECUTE_DATA_CC);
33316
33317 if (IS_UNUSED == IS_VAR) {
33318 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
33319 }
33320 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33321 }
33322
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33323 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33324 {
33325 USE_OPLINE
33326 zval *object, *value, tmp;
33327 zend_object *zobj;
33328 zend_string *name, *tmp_name;
33329 zend_refcounted *garbage = NULL;
33330
33331 SAVE_OPLINE();
33332 object = &EX(This);
33333 value = RT_CONSTANT((opline+1), (opline+1)->op1);
33334
33335 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33336 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33337 object = Z_REFVAL_P(object);
33338 goto assign_object;
33339 }
33340 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
33341 value = &EG(uninitialized_zval);
33342 goto free_and_exit_assign_obj;
33343 }
33344
33345 assign_object:
33346 zobj = Z_OBJ_P(object);
33347 if (IS_CONST == IS_CONST) {
33348 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
33349 void **cache_slot = CACHE_ADDR(opline->extended_value);
33350 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33351 zval *property_val;
33352
33353 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33354 property_val = OBJ_PROP(zobj, prop_offset);
33355 if (Z_TYPE_P(property_val) != IS_UNDEF) {
33356 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
33357
33358 if (prop_info != NULL) {
33359 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
33360 goto free_and_exit_assign_obj;
33361 } else {
33362 fast_assign_obj:
33363 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
33364 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33365 ZVAL_COPY(EX_VAR(opline->result.var), value);
33366 }
33367 goto exit_assign_obj;
33368 }
33369 }
33370 } else {
33371 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33372 if (EXPECTED(zobj->properties != NULL)) {
33373 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
33374 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
33375 GC_DELREF(zobj->properties);
33376 }
33377 zobj->properties = zend_array_dup(zobj->properties);
33378 }
33379 property_val = zend_hash_find_known_hash(zobj->properties, name);
33380 if (property_val) {
33381 goto fast_assign_obj;
33382 }
33383 }
33384
33385 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
33386 if (EXPECTED(zobj->properties == NULL)) {
33387 rebuild_object_properties(zobj);
33388 }
33389 if (IS_CONST == IS_CONST) {
33390 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
33391 Z_ADDREF_P(value);
33392 }
33393 } else if (IS_CONST != IS_TMP_VAR) {
33394 if (Z_ISREF_P(value)) {
33395 if (IS_CONST == IS_VAR) {
33396 zend_reference *ref = Z_REF_P(value);
33397 if (GC_DELREF(ref) == 0) {
33398 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
33399 efree_size(ref, sizeof(zend_reference));
33400 value = &tmp;
33401 } else {
33402 value = Z_REFVAL_P(value);
33403 Z_TRY_ADDREF_P(value);
33404 }
33405 } else {
33406 value = Z_REFVAL_P(value);
33407 Z_TRY_ADDREF_P(value);
33408 }
33409 } else if (IS_CONST == IS_CV) {
33410 Z_TRY_ADDREF_P(value);
33411 }
33412 }
33413 zend_hash_add_new(zobj->properties, name, value);
33414 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33415 ZVAL_COPY(EX_VAR(opline->result.var), value);
33416 }
33417 goto exit_assign_obj;
33418 }
33419 }
33420 }
33421 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33422 } else {
33423 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33424 if (UNEXPECTED(!name)) {
33425
33426 UNDEF_RESULT();
33427 goto exit_assign_obj;
33428 }
33429 }
33430
33431 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
33432 ZVAL_DEREF(value);
33433 }
33434
33435 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
33436
33437 if (IS_CONST != IS_CONST) {
33438 zend_tmp_string_release(tmp_name);
33439 }
33440
33441 free_and_exit_assign_obj:
33442 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
33443 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
33444 }
33445
33446 exit_assign_obj:
33447 if (garbage) {
33448 GC_DTOR_NO_REF(garbage);
33449 }
33450
33451
33452 /* assign_obj has two opcodes! */
33453 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33454 }
33455
33456 /* 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)33457 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33458 {
33459 USE_OPLINE
33460 zval *object, *value, tmp;
33461 zend_object *zobj;
33462 zend_string *name, *tmp_name;
33463 zend_refcounted *garbage = NULL;
33464
33465 SAVE_OPLINE();
33466 object = &EX(This);
33467 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
33468
33469 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33470 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33471 object = Z_REFVAL_P(object);
33472 goto assign_object;
33473 }
33474 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
33475 value = &EG(uninitialized_zval);
33476 goto free_and_exit_assign_obj;
33477 }
33478
33479 assign_object:
33480 zobj = Z_OBJ_P(object);
33481 if (IS_CONST == IS_CONST) {
33482 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
33483 void **cache_slot = CACHE_ADDR(opline->extended_value);
33484 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33485 zval *property_val;
33486
33487 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33488 property_val = OBJ_PROP(zobj, prop_offset);
33489 if (Z_TYPE_P(property_val) != IS_UNDEF) {
33490 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
33491
33492 if (prop_info != NULL) {
33493 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
33494 goto free_and_exit_assign_obj;
33495 } else {
33496 fast_assign_obj:
33497 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
33498 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33499 ZVAL_COPY(EX_VAR(opline->result.var), value);
33500 }
33501 goto exit_assign_obj;
33502 }
33503 }
33504 } else {
33505 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33506 if (EXPECTED(zobj->properties != NULL)) {
33507 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
33508 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
33509 GC_DELREF(zobj->properties);
33510 }
33511 zobj->properties = zend_array_dup(zobj->properties);
33512 }
33513 property_val = zend_hash_find_known_hash(zobj->properties, name);
33514 if (property_val) {
33515 goto fast_assign_obj;
33516 }
33517 }
33518
33519 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
33520 if (EXPECTED(zobj->properties == NULL)) {
33521 rebuild_object_properties(zobj);
33522 }
33523 if (IS_TMP_VAR == IS_CONST) {
33524 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
33525 Z_ADDREF_P(value);
33526 }
33527 } else if (IS_TMP_VAR != IS_TMP_VAR) {
33528 if (Z_ISREF_P(value)) {
33529 if (IS_TMP_VAR == IS_VAR) {
33530 zend_reference *ref = Z_REF_P(value);
33531 if (GC_DELREF(ref) == 0) {
33532 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
33533 efree_size(ref, sizeof(zend_reference));
33534 value = &tmp;
33535 } else {
33536 value = Z_REFVAL_P(value);
33537 Z_TRY_ADDREF_P(value);
33538 }
33539 } else {
33540 value = Z_REFVAL_P(value);
33541 Z_TRY_ADDREF_P(value);
33542 }
33543 } else if (IS_TMP_VAR == IS_CV) {
33544 Z_TRY_ADDREF_P(value);
33545 }
33546 }
33547 zend_hash_add_new(zobj->properties, name, value);
33548 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33549 ZVAL_COPY(EX_VAR(opline->result.var), value);
33550 }
33551 goto exit_assign_obj;
33552 }
33553 }
33554 }
33555 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33556 } else {
33557 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33558 if (UNEXPECTED(!name)) {
33559 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
33560 UNDEF_RESULT();
33561 goto exit_assign_obj;
33562 }
33563 }
33564
33565 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
33566 ZVAL_DEREF(value);
33567 }
33568
33569 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
33570
33571 if (IS_CONST != IS_CONST) {
33572 zend_tmp_string_release(tmp_name);
33573 }
33574
33575 free_and_exit_assign_obj:
33576 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
33577 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
33578 }
33579 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
33580 exit_assign_obj:
33581 if (garbage) {
33582 GC_DTOR_NO_REF(garbage);
33583 }
33584
33585
33586 /* assign_obj has two opcodes! */
33587 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33588 }
33589
33590 /* 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)33591 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33592 {
33593 USE_OPLINE
33594 zval *object, *value, tmp;
33595 zend_object *zobj;
33596 zend_string *name, *tmp_name;
33597 zend_refcounted *garbage = NULL;
33598
33599 SAVE_OPLINE();
33600 object = &EX(This);
33601 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
33602
33603 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33604 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33605 object = Z_REFVAL_P(object);
33606 goto assign_object;
33607 }
33608 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
33609 value = &EG(uninitialized_zval);
33610 goto free_and_exit_assign_obj;
33611 }
33612
33613 assign_object:
33614 zobj = Z_OBJ_P(object);
33615 if (IS_CONST == IS_CONST) {
33616 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
33617 void **cache_slot = CACHE_ADDR(opline->extended_value);
33618 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33619 zval *property_val;
33620
33621 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33622 property_val = OBJ_PROP(zobj, prop_offset);
33623 if (Z_TYPE_P(property_val) != IS_UNDEF) {
33624 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
33625
33626 if (prop_info != NULL) {
33627 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
33628 goto free_and_exit_assign_obj;
33629 } else {
33630 fast_assign_obj:
33631 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
33632 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33633 ZVAL_COPY(EX_VAR(opline->result.var), value);
33634 }
33635 goto exit_assign_obj;
33636 }
33637 }
33638 } else {
33639 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33640 if (EXPECTED(zobj->properties != NULL)) {
33641 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
33642 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
33643 GC_DELREF(zobj->properties);
33644 }
33645 zobj->properties = zend_array_dup(zobj->properties);
33646 }
33647 property_val = zend_hash_find_known_hash(zobj->properties, name);
33648 if (property_val) {
33649 goto fast_assign_obj;
33650 }
33651 }
33652
33653 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
33654 if (EXPECTED(zobj->properties == NULL)) {
33655 rebuild_object_properties(zobj);
33656 }
33657 if (IS_VAR == IS_CONST) {
33658 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
33659 Z_ADDREF_P(value);
33660 }
33661 } else if (IS_VAR != IS_TMP_VAR) {
33662 if (Z_ISREF_P(value)) {
33663 if (IS_VAR == IS_VAR) {
33664 zend_reference *ref = Z_REF_P(value);
33665 if (GC_DELREF(ref) == 0) {
33666 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
33667 efree_size(ref, sizeof(zend_reference));
33668 value = &tmp;
33669 } else {
33670 value = Z_REFVAL_P(value);
33671 Z_TRY_ADDREF_P(value);
33672 }
33673 } else {
33674 value = Z_REFVAL_P(value);
33675 Z_TRY_ADDREF_P(value);
33676 }
33677 } else if (IS_VAR == IS_CV) {
33678 Z_TRY_ADDREF_P(value);
33679 }
33680 }
33681 zend_hash_add_new(zobj->properties, name, value);
33682 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33683 ZVAL_COPY(EX_VAR(opline->result.var), value);
33684 }
33685 goto exit_assign_obj;
33686 }
33687 }
33688 }
33689 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33690 } else {
33691 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33692 if (UNEXPECTED(!name)) {
33693 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
33694 UNDEF_RESULT();
33695 goto exit_assign_obj;
33696 }
33697 }
33698
33699 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
33700 ZVAL_DEREF(value);
33701 }
33702
33703 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
33704
33705 if (IS_CONST != IS_CONST) {
33706 zend_tmp_string_release(tmp_name);
33707 }
33708
33709 free_and_exit_assign_obj:
33710 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
33711 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
33712 }
33713 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
33714 exit_assign_obj:
33715 if (garbage) {
33716 GC_DTOR_NO_REF(garbage);
33717 }
33718
33719
33720 /* assign_obj has two opcodes! */
33721 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33722 }
33723
33724 /* 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)33725 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33726 {
33727 USE_OPLINE
33728 zval *object, *value, tmp;
33729 zend_object *zobj;
33730 zend_string *name, *tmp_name;
33731 zend_refcounted *garbage = NULL;
33732
33733 SAVE_OPLINE();
33734 object = &EX(This);
33735 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
33736
33737 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
33738 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
33739 object = Z_REFVAL_P(object);
33740 goto assign_object;
33741 }
33742 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
33743 value = &EG(uninitialized_zval);
33744 goto free_and_exit_assign_obj;
33745 }
33746
33747 assign_object:
33748 zobj = Z_OBJ_P(object);
33749 if (IS_CONST == IS_CONST) {
33750 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
33751 void **cache_slot = CACHE_ADDR(opline->extended_value);
33752 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
33753 zval *property_val;
33754
33755 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
33756 property_val = OBJ_PROP(zobj, prop_offset);
33757 if (Z_TYPE_P(property_val) != IS_UNDEF) {
33758 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
33759
33760 if (prop_info != NULL) {
33761 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
33762 goto free_and_exit_assign_obj;
33763 } else {
33764 fast_assign_obj:
33765 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
33766 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33767 ZVAL_COPY(EX_VAR(opline->result.var), value);
33768 }
33769 goto exit_assign_obj;
33770 }
33771 }
33772 } else {
33773 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33774 if (EXPECTED(zobj->properties != NULL)) {
33775 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
33776 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
33777 GC_DELREF(zobj->properties);
33778 }
33779 zobj->properties = zend_array_dup(zobj->properties);
33780 }
33781 property_val = zend_hash_find_known_hash(zobj->properties, name);
33782 if (property_val) {
33783 goto fast_assign_obj;
33784 }
33785 }
33786
33787 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
33788 if (EXPECTED(zobj->properties == NULL)) {
33789 rebuild_object_properties(zobj);
33790 }
33791 if (IS_CV == IS_CONST) {
33792 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
33793 Z_ADDREF_P(value);
33794 }
33795 } else if (IS_CV != IS_TMP_VAR) {
33796 if (Z_ISREF_P(value)) {
33797 if (IS_CV == IS_VAR) {
33798 zend_reference *ref = Z_REF_P(value);
33799 if (GC_DELREF(ref) == 0) {
33800 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
33801 efree_size(ref, sizeof(zend_reference));
33802 value = &tmp;
33803 } else {
33804 value = Z_REFVAL_P(value);
33805 Z_TRY_ADDREF_P(value);
33806 }
33807 } else {
33808 value = Z_REFVAL_P(value);
33809 Z_TRY_ADDREF_P(value);
33810 }
33811 } else if (IS_CV == IS_CV) {
33812 Z_TRY_ADDREF_P(value);
33813 }
33814 }
33815 zend_hash_add_new(zobj->properties, name, value);
33816 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
33817 ZVAL_COPY(EX_VAR(opline->result.var), value);
33818 }
33819 goto exit_assign_obj;
33820 }
33821 }
33822 }
33823 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
33824 } else {
33825 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
33826 if (UNEXPECTED(!name)) {
33827
33828 UNDEF_RESULT();
33829 goto exit_assign_obj;
33830 }
33831 }
33832
33833 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
33834 ZVAL_DEREF(value);
33835 }
33836
33837 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
33838
33839 if (IS_CONST != IS_CONST) {
33840 zend_tmp_string_release(tmp_name);
33841 }
33842
33843 free_and_exit_assign_obj:
33844 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
33845 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
33846 }
33847
33848 exit_assign_obj:
33849 if (garbage) {
33850 GC_DTOR_NO_REF(garbage);
33851 }
33852
33853
33854 /* assign_obj has two opcodes! */
33855 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33856 }
33857
33858 /* 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)33859 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33860 {
33861 USE_OPLINE
33862 zval *property, *container, *value_ptr;
33863
33864 SAVE_OPLINE();
33865
33866 container = &EX(This);
33867 property = RT_CONSTANT(opline, opline->op2);
33868
33869 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
33870
33871 if (1) {
33872 if (IS_UNUSED == IS_UNUSED) {
33873 if (IS_CONST == IS_CONST) {
33874 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33875 } else {
33876 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33877 }
33878 } else {
33879 if (IS_CONST == IS_CONST) {
33880 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33881 } else {
33882 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33883 }
33884 }
33885 } else {
33886 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33887 }
33888
33889
33890 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
33891 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33892 }
33893
33894 /* 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)33895 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33896 {
33897 USE_OPLINE
33898 zval *property, *container, *value_ptr;
33899
33900 SAVE_OPLINE();
33901
33902 container = &EX(This);
33903 property = RT_CONSTANT(opline, opline->op2);
33904
33905 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
33906
33907 if (1) {
33908 if (IS_UNUSED == IS_UNUSED) {
33909 if (IS_CONST == IS_CONST) {
33910 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33911 } else {
33912 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33913 }
33914 } else {
33915 if (IS_CONST == IS_CONST) {
33916 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33917 } else {
33918 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33919 }
33920 }
33921 } else {
33922 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
33923 }
33924
33925
33926
33927 ZEND_VM_NEXT_OPCODE_EX(1, 2);
33928 }
33929
33930 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33931 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33932 {
33933 USE_OPLINE
33934 zend_string **rope;
33935 zval *var;
33936
33937 /* Compiler allocates the necessary number of zval slots to keep the rope */
33938 rope = (zend_string**)EX_VAR(opline->result.var);
33939 if (IS_CONST == IS_CONST) {
33940 var = RT_CONSTANT(opline, opline->op2);
33941 rope[0] = Z_STR_P(var);
33942 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
33943 Z_ADDREF_P(var);
33944 }
33945 } else {
33946 var = RT_CONSTANT(opline, opline->op2);
33947 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
33948 if (IS_CONST == IS_CV) {
33949 rope[0] = zend_string_copy(Z_STR_P(var));
33950 } else {
33951 rope[0] = Z_STR_P(var);
33952 }
33953 } else {
33954 SAVE_OPLINE();
33955 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
33956 ZVAL_UNDEFINED_OP2();
33957 }
33958 rope[0] = zval_get_string_func(var);
33959
33960 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33961 }
33962 }
33963 ZEND_VM_NEXT_OPCODE();
33964 }
33965
ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)33966 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
33967 {
33968 zval *class_name;
33969 USE_OPLINE
33970
33971 SAVE_OPLINE();
33972 if (IS_CONST == IS_UNUSED) {
33973 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
33974 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
33975 } else if (IS_CONST == IS_CONST) {
33976 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
33977
33978 if (UNEXPECTED(ce == NULL)) {
33979 class_name = RT_CONSTANT(opline, opline->op2);
33980 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
33981 CACHE_PTR(opline->extended_value, ce);
33982 }
33983 Z_CE_P(EX_VAR(opline->result.var)) = ce;
33984 } else {
33985 class_name = RT_CONSTANT(opline, opline->op2);
33986 try_class_name:
33987 if (Z_TYPE_P(class_name) == IS_OBJECT) {
33988 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
33989 } else if (Z_TYPE_P(class_name) == IS_STRING) {
33990 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
33991 } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
33992 class_name = Z_REFVAL_P(class_name);
33993 goto try_class_name;
33994 } else {
33995 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
33996 ZVAL_UNDEFINED_OP2();
33997 if (UNEXPECTED(EG(exception) != NULL)) {
33998 HANDLE_EXCEPTION();
33999 }
34000 }
34001 zend_throw_error(NULL, "Class name must be a valid object or a string");
34002 }
34003 }
34004
34005 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34006 }
34007
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34008 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34009 {
34010 USE_OPLINE
34011 zval *function_name;
34012 zval *object;
34013 zend_function *fbc;
34014 zend_class_entry *called_scope;
34015 zend_object *obj;
34016 zend_execute_data *call;
34017 uint32_t call_info;
34018
34019 SAVE_OPLINE();
34020
34021 object = &EX(This);
34022
34023 if (IS_CONST != IS_CONST) {
34024 function_name = RT_CONSTANT(opline, opline->op2);
34025 }
34026
34027 if (IS_CONST != IS_CONST &&
34028 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
34029 do {
34030 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
34031 function_name = Z_REFVAL_P(function_name);
34032 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
34033 break;
34034 }
34035 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
34036 ZVAL_UNDEFINED_OP2();
34037 if (UNEXPECTED(EG(exception) != NULL)) {
34038
34039 HANDLE_EXCEPTION();
34040 }
34041 }
34042 zend_throw_error(NULL, "Method name must be a string");
34043
34044
34045 HANDLE_EXCEPTION();
34046 } while (0);
34047 }
34048
34049 if (IS_UNUSED == IS_UNUSED) {
34050 obj = Z_OBJ_P(object);
34051 } else {
34052 do {
34053 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
34054 obj = Z_OBJ_P(object);
34055 } else {
34056 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
34057 zend_reference *ref = Z_REF_P(object);
34058
34059 object = &ref->val;
34060 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
34061 obj = Z_OBJ_P(object);
34062 if (IS_UNUSED & IS_VAR) {
34063 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
34064 efree_size(ref, sizeof(zend_reference));
34065 } else {
34066 Z_ADDREF_P(object);
34067 }
34068 }
34069 break;
34070 }
34071 }
34072 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
34073 object = ZVAL_UNDEFINED_OP1();
34074 if (UNEXPECTED(EG(exception) != NULL)) {
34075 if (IS_CONST != IS_CONST) {
34076
34077 }
34078 HANDLE_EXCEPTION();
34079 }
34080 }
34081 if (IS_CONST == IS_CONST) {
34082 function_name = RT_CONSTANT(opline, opline->op2);
34083 }
34084 zend_invalid_method_call(object, function_name);
34085
34086
34087 HANDLE_EXCEPTION();
34088 }
34089 } while (0);
34090 }
34091
34092 called_scope = obj->ce;
34093
34094 if (IS_CONST == IS_CONST &&
34095 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
34096 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
34097 } else {
34098 zend_object *orig_obj = obj;
34099
34100 if (IS_CONST == IS_CONST) {
34101 function_name = RT_CONSTANT(opline, opline->op2);
34102 }
34103
34104 /* First, locate the function. */
34105 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
34106 if (UNEXPECTED(fbc == NULL)) {
34107 if (EXPECTED(!EG(exception))) {
34108 zend_undefined_method(obj->ce, Z_STR_P(function_name));
34109 }
34110
34111 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
34112 zend_objects_store_del(orig_obj);
34113 }
34114 HANDLE_EXCEPTION();
34115 }
34116 if (IS_CONST == IS_CONST &&
34117 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
34118 EXPECTED(obj == orig_obj)) {
34119 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
34120 }
34121 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
34122 GC_ADDREF(obj); /* For $this pointer */
34123 if (GC_DELREF(orig_obj) == 0) {
34124 zend_objects_store_del(orig_obj);
34125 }
34126 }
34127 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
34128 init_func_run_time_cache(&fbc->op_array);
34129 }
34130 }
34131
34132 if (IS_CONST != IS_CONST) {
34133
34134 }
34135
34136 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
34137 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
34138 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
34139 zend_objects_store_del(obj);
34140 if (UNEXPECTED(EG(exception))) {
34141 HANDLE_EXCEPTION();
34142 }
34143 }
34144 /* call static method */
34145 obj = (zend_object*)called_scope;
34146 call_info = ZEND_CALL_NESTED_FUNCTION;
34147 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
34148 if (IS_UNUSED == IS_CV) {
34149 GC_ADDREF(obj); /* For $this pointer */
34150 }
34151 /* CV may be changed indirectly (e.g. when it's a reference) */
34152 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
34153 }
34154
34155 call = zend_vm_stack_push_call_frame(call_info,
34156 fbc, opline->extended_value, obj);
34157 call->prev_execute_data = EX(call);
34158 EX(call) = call;
34159
34160 ZEND_VM_NEXT_OPCODE();
34161 }
34162
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34163 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34164 {
34165 USE_OPLINE
34166 zval *function_name;
34167 zend_class_entry *ce;
34168 uint32_t call_info;
34169 zend_function *fbc;
34170 zend_execute_data *call;
34171
34172 SAVE_OPLINE();
34173
34174 if (IS_UNUSED == IS_CONST) {
34175 /* no function found. try a static method in class */
34176 ce = CACHED_PTR(opline->result.num);
34177 if (UNEXPECTED(ce == NULL)) {
34178 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);
34179 if (UNEXPECTED(ce == NULL)) {
34180
34181 HANDLE_EXCEPTION();
34182 }
34183 if (IS_CONST != IS_CONST) {
34184 CACHE_PTR(opline->result.num, ce);
34185 }
34186 }
34187 } else if (IS_UNUSED == IS_UNUSED) {
34188 ce = zend_fetch_class(NULL, opline->op1.num);
34189 if (UNEXPECTED(ce == NULL)) {
34190
34191 HANDLE_EXCEPTION();
34192 }
34193 } else {
34194 ce = Z_CE_P(EX_VAR(opline->op1.var));
34195 }
34196
34197 if (IS_UNUSED == IS_CONST &&
34198 IS_CONST == IS_CONST &&
34199 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
34200 /* nothing to do */
34201 } else if (IS_UNUSED != IS_CONST &&
34202 IS_CONST == IS_CONST &&
34203 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
34204 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
34205 } else if (IS_CONST != IS_UNUSED) {
34206 function_name = RT_CONSTANT(opline, opline->op2);
34207 if (IS_CONST != IS_CONST) {
34208 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
34209 do {
34210 if (IS_CONST & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
34211 function_name = Z_REFVAL_P(function_name);
34212 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
34213 break;
34214 }
34215 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
34216 ZVAL_UNDEFINED_OP2();
34217 if (UNEXPECTED(EG(exception) != NULL)) {
34218 HANDLE_EXCEPTION();
34219 }
34220 }
34221 zend_throw_error(NULL, "Method name must be a string");
34222
34223 HANDLE_EXCEPTION();
34224 } while (0);
34225 }
34226 }
34227
34228 if (ce->get_static_method) {
34229 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
34230 } else {
34231 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
34232 }
34233 if (UNEXPECTED(fbc == NULL)) {
34234 if (EXPECTED(!EG(exception))) {
34235 zend_undefined_method(ce, Z_STR_P(function_name));
34236 }
34237
34238 HANDLE_EXCEPTION();
34239 }
34240 if (IS_CONST == IS_CONST &&
34241 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
34242 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
34243 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
34244 }
34245 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
34246 init_func_run_time_cache(&fbc->op_array);
34247 }
34248 if (IS_CONST != IS_CONST) {
34249
34250 }
34251 } else {
34252 if (UNEXPECTED(ce->constructor == NULL)) {
34253 zend_throw_error(NULL, "Cannot call constructor");
34254 HANDLE_EXCEPTION();
34255 }
34256 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
34257 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
34258 HANDLE_EXCEPTION();
34259 }
34260 fbc = ce->constructor;
34261 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
34262 init_func_run_time_cache(&fbc->op_array);
34263 }
34264 }
34265
34266 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
34267 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
34268 ce = (zend_class_entry*)Z_OBJ(EX(This));
34269 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
34270 } else {
34271 zend_non_static_method_call(fbc);
34272 HANDLE_EXCEPTION();
34273 }
34274 } else {
34275 /* previous opcode is ZEND_FETCH_CLASS */
34276 if (IS_UNUSED == IS_UNUSED
34277 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
34278 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
34279 if (Z_TYPE(EX(This)) == IS_OBJECT) {
34280 ce = Z_OBJCE(EX(This));
34281 } else {
34282 ce = Z_CE(EX(This));
34283 }
34284 }
34285 call_info = ZEND_CALL_NESTED_FUNCTION;
34286 }
34287
34288 call = zend_vm_stack_push_call_frame(call_info,
34289 fbc, opline->extended_value, ce);
34290 call->prev_execute_data = EX(call);
34291 EX(call) = call;
34292
34293 ZEND_VM_NEXT_OPCODE();
34294 }
34295
ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34296 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34297 {
34298 USE_OPLINE
34299 uint32_t arg_num;
34300
34301 if (IS_CONST == IS_CONST) {
34302 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
34303 arg_num = zend_get_arg_offset_by_name(
34304 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
34305 if (UNEXPECTED(arg_num == 0)) {
34306 /* Treat this as a by-value argument, and throw an error during SEND. */
34307 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
34308 ZEND_VM_NEXT_OPCODE();
34309 }
34310 } else {
34311 arg_num = opline->op2.num;
34312 }
34313
34314 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
34315 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
34316 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
34317 } else {
34318 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
34319 }
34320 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
34321 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
34322 } else {
34323 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
34324 }
34325 ZEND_VM_NEXT_OPCODE();
34326 }
34327
ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34328 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34329 {
34330 USE_OPLINE
34331 zend_constant *c;
34332
34333 c = CACHED_PTR(opline->extended_value);
34334 if (EXPECTED(c != NULL) && EXPECTED(!IS_SPECIAL_CACHE_VAL(c))) {
34335 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), &c->value);
34336 ZEND_VM_NEXT_OPCODE();
34337 }
34338
34339 SAVE_OPLINE();
34340 zend_quick_get_constant(RT_CONSTANT(opline, opline->op2) + 1, opline->op1.num OPLINE_CC EXECUTE_DATA_CC);
34341 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34342 }
34343
ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34344 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34345 {
34346 zend_class_entry *ce, *scope;
34347 zend_class_constant *c;
34348 zval *value, *zv, *constant_zv;
34349 zend_string *constant_name;
34350 USE_OPLINE
34351
34352 SAVE_OPLINE();
34353
34354 do {
34355 if (IS_UNUSED == IS_CONST && IS_CONST == IS_CONST) {
34356 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
34357 value = CACHED_PTR(opline->extended_value + sizeof(void*));
34358 break;
34359 }
34360 }
34361 if (IS_UNUSED == IS_CONST) {
34362 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
34363 ce = CACHED_PTR(opline->extended_value);
34364 } else {
34365 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);
34366 if (UNEXPECTED(ce == NULL)) {
34367 ZVAL_UNDEF(EX_VAR(opline->result.var));
34368
34369 HANDLE_EXCEPTION();
34370 }
34371 CACHE_PTR(opline->extended_value, ce);
34372 }
34373 } else if (IS_UNUSED == IS_UNUSED) {
34374 ce = zend_fetch_class(NULL, opline->op1.num);
34375 if (UNEXPECTED(ce == NULL)) {
34376 ZVAL_UNDEF(EX_VAR(opline->result.var));
34377
34378 HANDLE_EXCEPTION();
34379 }
34380 } else {
34381 ce = Z_CE_P(EX_VAR(opline->op1.var));
34382 }
34383 if (IS_UNUSED != IS_CONST
34384 && IS_CONST == IS_CONST
34385 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
34386 value = CACHED_PTR(opline->extended_value + sizeof(void*));
34387 break;
34388 }
34389
34390 constant_zv = RT_CONSTANT(opline, opline->op2);
34391 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
34392 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
34393 ZVAL_UNDEF(EX_VAR(opline->result.var));
34394
34395 HANDLE_EXCEPTION();
34396 }
34397 constant_name = Z_STR_P(constant_zv);
34398 /* Magic 'class' for constant OP2 is caught at compile-time */
34399 if (IS_CONST != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
34400 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
34401
34402 ZEND_VM_NEXT_OPCODE();
34403 }
34404 zv = IS_CONST == IS_CONST
34405 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
34406 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
34407
34408 if (EXPECTED(zv != NULL)) {
34409 c = Z_PTR_P(zv);
34410 scope = EX(func)->op_array.scope;
34411 if (!zend_verify_const_access(c, scope)) {
34412 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));
34413 ZVAL_UNDEF(EX_VAR(opline->result.var));
34414
34415 HANDLE_EXCEPTION();
34416 }
34417
34418 if (ce->ce_flags & ZEND_ACC_TRAIT) {
34419 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34420 ZVAL_UNDEF(EX_VAR(opline->result.var));
34421
34422 HANDLE_EXCEPTION();
34423 }
34424
34425 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
34426 if (UNEXPECTED(is_constant_deprecated)) {
34427 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34428
34429 if (EG(exception)) {
34430 ZVAL_UNDEF(EX_VAR(opline->result.var));
34431
34432 HANDLE_EXCEPTION();
34433 }
34434 }
34435
34436 value = &c->value;
34437 // Enums require loading of all class constants to build the backed enum table
34438 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)) {
34439 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
34440 ZVAL_UNDEF(EX_VAR(opline->result.var));
34441
34442 HANDLE_EXCEPTION();
34443 }
34444 }
34445 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
34446 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
34447 ZVAL_UNDEF(EX_VAR(opline->result.var));
34448
34449 HANDLE_EXCEPTION();
34450 }
34451 }
34452 if (IS_CONST == IS_CONST && !is_constant_deprecated) {
34453 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
34454 }
34455 } else {
34456 zend_throw_error(NULL, "Undefined constant %s::%s",
34457 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34458 ZVAL_UNDEF(EX_VAR(opline->result.var));
34459
34460 HANDLE_EXCEPTION();
34461 }
34462 } while (0);
34463
34464 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
34465
34466 ZEND_VM_NEXT_OPCODE();
34467 }
34468
ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34469 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34470 {
34471 zval *array;
34472 uint32_t size;
34473 USE_OPLINE
34474
34475 array = EX_VAR(opline->result.var);
34476 if (IS_UNUSED != IS_UNUSED) {
34477 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
34478 ZVAL_ARR(array, zend_new_array(size));
34479 /* Explicitly initialize array as not-packed if flag is set */
34480 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
34481 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
34482 }
34483 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34484 } else {
34485 ZVAL_ARR(array, zend_new_array(0));
34486 ZEND_VM_NEXT_OPCODE();
34487 }
34488 }
34489
ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34490 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34491 {
34492 USE_OPLINE
34493 zval *container;
34494 zval *offset;
34495 zend_string *name, *tmp_name;
34496
34497 SAVE_OPLINE();
34498 container = &EX(This);
34499 offset = RT_CONSTANT(opline, opline->op2);
34500
34501 do {
34502 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
34503 if (Z_ISREF_P(container)) {
34504 container = Z_REFVAL_P(container);
34505 if (Z_TYPE_P(container) != IS_OBJECT) {
34506 if (IS_UNUSED == IS_CV
34507 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
34508 ZVAL_UNDEFINED_OP1();
34509 }
34510 break;
34511 }
34512 } else {
34513 break;
34514 }
34515 }
34516 if (IS_CONST == IS_CONST) {
34517 name = Z_STR_P(offset);
34518 } else {
34519 name = zval_try_get_tmp_string(offset, &tmp_name);
34520 if (UNEXPECTED(!name)) {
34521 break;
34522 }
34523 }
34524 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
34525 if (IS_CONST != IS_CONST) {
34526 zend_tmp_string_release(tmp_name);
34527 }
34528 } while (0);
34529
34530
34531 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34532 }
34533
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34534 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34535 {
34536 USE_OPLINE
34537 zval *container;
34538 int result;
34539 zval *offset;
34540 zend_string *name, *tmp_name;
34541
34542 SAVE_OPLINE();
34543 container = &EX(This);
34544 offset = RT_CONSTANT(opline, opline->op2);
34545
34546 if (IS_UNUSED == IS_CONST ||
34547 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
34548 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
34549 container = Z_REFVAL_P(container);
34550 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
34551 result = (opline->extended_value & ZEND_ISEMPTY);
34552 goto isset_object_finish;
34553 }
34554 } else {
34555 result = (opline->extended_value & ZEND_ISEMPTY);
34556 goto isset_object_finish;
34557 }
34558 }
34559
34560 if (IS_CONST == IS_CONST) {
34561 name = Z_STR_P(offset);
34562 } else {
34563 name = zval_try_get_tmp_string(offset, &tmp_name);
34564 if (UNEXPECTED(!name)) {
34565 result = 0;
34566 goto isset_object_finish;
34567 }
34568 }
34569
34570 result =
34571 (opline->extended_value & ZEND_ISEMPTY) ^
34572 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));
34573
34574 if (IS_CONST != IS_CONST) {
34575 zend_tmp_string_release(tmp_name);
34576 }
34577
34578 isset_object_finish:
34579
34580
34581 ZEND_VM_SMART_BRANCH(result, 1);
34582 }
34583
ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34584 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34585 {
34586 USE_OPLINE
34587
34588 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
34589
34590 SAVE_OPLINE();
34591 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
34592 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
34593 }
34594
34595 /* Destroy the previously yielded value */
34596 zval_ptr_dtor(&generator->value);
34597
34598 /* Destroy the previously yielded key */
34599 zval_ptr_dtor(&generator->key);
34600
34601 /* Set the new yielded value */
34602 if (IS_UNUSED != IS_UNUSED) {
34603 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
34604 /* Constants and temporary variables aren't yieldable by reference,
34605 * but we still allow them with a notice. */
34606 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
34607 zval *value;
34608
34609 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
34610
34611 value = NULL;
34612 ZVAL_COPY_VALUE(&generator->value, value);
34613 if (IS_UNUSED == IS_CONST) {
34614 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
34615 Z_ADDREF(generator->value);
34616 }
34617 }
34618 } else {
34619 zval *value_ptr = NULL;
34620
34621 /* If a function call result is yielded and the function did
34622 * not return by reference we throw a notice. */
34623 do {
34624 if (IS_UNUSED == IS_VAR) {
34625 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
34626 if (opline->extended_value == ZEND_RETURNS_FUNCTION
34627 && !Z_ISREF_P(value_ptr)) {
34628 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
34629 ZVAL_COPY(&generator->value, value_ptr);
34630 break;
34631 }
34632 }
34633 if (Z_ISREF_P(value_ptr)) {
34634 Z_ADDREF_P(value_ptr);
34635 } else {
34636 ZVAL_MAKE_REF_EX(value_ptr, 2);
34637 }
34638 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
34639 } while (0);
34640
34641 }
34642 } else {
34643 zval *value = NULL;
34644
34645 /* Consts, temporary variables and references need copying */
34646 if (IS_UNUSED == IS_CONST) {
34647 ZVAL_COPY_VALUE(&generator->value, value);
34648 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
34649 Z_ADDREF(generator->value);
34650 }
34651 } else if (IS_UNUSED == IS_TMP_VAR) {
34652 ZVAL_COPY_VALUE(&generator->value, value);
34653 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
34654 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
34655
34656 } else {
34657 ZVAL_COPY_VALUE(&generator->value, value);
34658 if (IS_UNUSED == IS_CV) {
34659 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
34660 }
34661 }
34662 }
34663 } else {
34664 /* If no value was specified yield null */
34665 ZVAL_NULL(&generator->value);
34666 }
34667
34668 /* Set the new yielded key */
34669 if (IS_CONST != IS_UNUSED) {
34670 zval *key = RT_CONSTANT(opline, opline->op2);
34671 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
34672 key = Z_REFVAL_P(key);
34673 }
34674 ZVAL_COPY(&generator->key, key);
34675
34676 if (Z_TYPE(generator->key) == IS_LONG
34677 && Z_LVAL(generator->key) > generator->largest_used_integer_key
34678 ) {
34679 generator->largest_used_integer_key = Z_LVAL(generator->key);
34680 }
34681 } else {
34682 /* If no key was specified we use auto-increment keys */
34683 generator->largest_used_integer_key++;
34684 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
34685 }
34686
34687 if (RETURN_VALUE_USED(opline)) {
34688 /* If the return value of yield is used set the send
34689 * target and initialize it to NULL */
34690 generator->send_target = EX_VAR(opline->result.var);
34691 ZVAL_NULL(generator->send_target);
34692 } else {
34693 generator->send_target = NULL;
34694 }
34695
34696 /* We increment to the next op, so we are at the correct position when the
34697 * generator is resumed. */
34698 ZEND_VM_INC_OPCODE();
34699
34700 /* The GOTO VM uses a local opline variable. We need to set the opline
34701 * variable in execute_data so we don't resume at an old position. */
34702 SAVE_OPLINE();
34703
34704 ZEND_VM_RETURN();
34705 }
34706
ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34707 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34708 {
34709 zend_class_entry *ce, *scope;
34710 zend_class_constant *c;
34711 zval *value, *zv, *constant_zv;
34712 zend_string *constant_name;
34713 USE_OPLINE
34714
34715 SAVE_OPLINE();
34716
34717 do {
34718 if (IS_UNUSED == IS_CONST && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST) {
34719 if (EXPECTED(CACHED_PTR(opline->extended_value + sizeof(void*)))) {
34720 value = CACHED_PTR(opline->extended_value + sizeof(void*));
34721 break;
34722 }
34723 }
34724 if (IS_UNUSED == IS_CONST) {
34725 if (EXPECTED(CACHED_PTR(opline->extended_value))) {
34726 ce = CACHED_PTR(opline->extended_value);
34727 } else {
34728 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);
34729 if (UNEXPECTED(ce == NULL)) {
34730 ZVAL_UNDEF(EX_VAR(opline->result.var));
34731 FREE_OP(opline->op2_type, opline->op2.var);
34732 HANDLE_EXCEPTION();
34733 }
34734 CACHE_PTR(opline->extended_value, ce);
34735 }
34736 } else if (IS_UNUSED == IS_UNUSED) {
34737 ce = zend_fetch_class(NULL, opline->op1.num);
34738 if (UNEXPECTED(ce == NULL)) {
34739 ZVAL_UNDEF(EX_VAR(opline->result.var));
34740 FREE_OP(opline->op2_type, opline->op2.var);
34741 HANDLE_EXCEPTION();
34742 }
34743 } else {
34744 ce = Z_CE_P(EX_VAR(opline->op1.var));
34745 }
34746 if (IS_UNUSED != IS_CONST
34747 && (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
34748 && EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
34749 value = CACHED_PTR(opline->extended_value + sizeof(void*));
34750 break;
34751 }
34752
34753 constant_zv = _get_zval_ptr_tmpvarcv(opline->op2_type, opline->op2, BP_VAR_R EXECUTE_DATA_CC);
34754 if (UNEXPECTED(Z_TYPE_P(constant_zv) != IS_STRING)) {
34755 zend_invalid_class_constant_type_error(Z_TYPE_P(constant_zv));
34756 ZVAL_UNDEF(EX_VAR(opline->result.var));
34757 FREE_OP(opline->op2_type, opline->op2.var);
34758 HANDLE_EXCEPTION();
34759 }
34760 constant_name = Z_STR_P(constant_zv);
34761 /* Magic 'class' for constant OP2 is caught at compile-time */
34762 if ((IS_TMP_VAR|IS_VAR|IS_CV) != IS_CONST && UNEXPECTED(zend_string_equals_literal_ci(constant_name, "class"))) {
34763 ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name);
34764 FREE_OP(opline->op2_type, opline->op2.var);
34765 ZEND_VM_NEXT_OPCODE();
34766 }
34767 zv = (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST
34768 ? zend_hash_find_known_hash(CE_CONSTANTS_TABLE(ce), constant_name)
34769 : zend_hash_find(CE_CONSTANTS_TABLE(ce), constant_name);
34770
34771 if (EXPECTED(zv != NULL)) {
34772 c = Z_PTR_P(zv);
34773 scope = EX(func)->op_array.scope;
34774 if (!zend_verify_const_access(c, scope)) {
34775 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));
34776 ZVAL_UNDEF(EX_VAR(opline->result.var));
34777 FREE_OP(opline->op2_type, opline->op2.var);
34778 HANDLE_EXCEPTION();
34779 }
34780
34781 if (ce->ce_flags & ZEND_ACC_TRAIT) {
34782 zend_throw_error(NULL, "Cannot access trait constant %s::%s directly", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34783 ZVAL_UNDEF(EX_VAR(opline->result.var));
34784 FREE_OP(opline->op2_type, opline->op2.var);
34785 HANDLE_EXCEPTION();
34786 }
34787
34788 bool is_constant_deprecated = ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_DEPRECATED;
34789 if (UNEXPECTED(is_constant_deprecated)) {
34790 zend_error(E_DEPRECATED, "Constant %s::%s is deprecated", ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34791
34792 if (EG(exception)) {
34793 ZVAL_UNDEF(EX_VAR(opline->result.var));
34794 FREE_OP(opline->op2_type, opline->op2.var);
34795 HANDLE_EXCEPTION();
34796 }
34797 }
34798
34799 value = &c->value;
34800 // Enums require loading of all class constants to build the backed enum table
34801 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)) {
34802 if (UNEXPECTED(zend_update_class_constants(ce) == FAILURE)) {
34803 ZVAL_UNDEF(EX_VAR(opline->result.var));
34804 FREE_OP(opline->op2_type, opline->op2.var);
34805 HANDLE_EXCEPTION();
34806 }
34807 }
34808 if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
34809 if (UNEXPECTED(zend_update_class_constant(c, constant_name, c->ce) != SUCCESS)) {
34810 ZVAL_UNDEF(EX_VAR(opline->result.var));
34811 FREE_OP(opline->op2_type, opline->op2.var);
34812 HANDLE_EXCEPTION();
34813 }
34814 }
34815 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && !is_constant_deprecated) {
34816 CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, value);
34817 }
34818 } else {
34819 zend_throw_error(NULL, "Undefined constant %s::%s",
34820 ZSTR_VAL(ce->name), ZSTR_VAL(constant_name));
34821 ZVAL_UNDEF(EX_VAR(opline->result.var));
34822 FREE_OP(opline->op2_type, opline->op2.var);
34823 HANDLE_EXCEPTION();
34824 }
34825 } while (0);
34826
34827 ZVAL_COPY_OR_DUP(EX_VAR(opline->result.var), value);
34828
34829 FREE_OP(opline->op2_type, opline->op2.var);
34830 ZEND_VM_NEXT_OPCODE();
34831 }
34832
ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34833 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34834 {
34835 USE_OPLINE
34836 zval *object;
34837 zval *property;
34838 zval *value;
34839 zval *zptr;
34840 void **cache_slot;
34841 zend_property_info *prop_info;
34842 zend_object *zobj;
34843 zend_string *name, *tmp_name;
34844
34845 SAVE_OPLINE();
34846 object = &EX(This);
34847 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
34848
34849 do {
34850 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
34851
34852 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34853 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34854 object = Z_REFVAL_P(object);
34855 goto assign_op_object;
34856 }
34857 if (IS_UNUSED == IS_CV
34858 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
34859 ZVAL_UNDEFINED_OP1();
34860 }
34861 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
34862 break;
34863 }
34864
34865 assign_op_object:
34866 /* here we are sure we are dealing with an object */
34867 zobj = Z_OBJ_P(object);
34868 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
34869 name = Z_STR_P(property);
34870 } else {
34871 name = zval_try_get_tmp_string(property, &tmp_name);
34872 if (UNEXPECTED(!name)) {
34873 UNDEF_RESULT();
34874 break;
34875 }
34876 }
34877 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
34878 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
34879 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
34880 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34881 ZVAL_NULL(EX_VAR(opline->result.var));
34882 }
34883 } else {
34884 zval *orig_zptr = zptr;
34885 zend_reference *ref;
34886
34887 do {
34888 if (UNEXPECTED(Z_ISREF_P(zptr))) {
34889 ref = Z_REF_P(zptr);
34890 zptr = Z_REFVAL_P(zptr);
34891 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
34892 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
34893 break;
34894 }
34895 }
34896
34897 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
34898 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
34899 } else {
34900 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
34901 }
34902 if (prop_info) {
34903 /* special case for typed properties */
34904 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
34905 } else {
34906 zend_binary_op(zptr, zptr, value OPLINE_CC);
34907 }
34908 } while (0);
34909
34910 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34911 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
34912 }
34913 }
34914 } else {
34915 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
34916 }
34917 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
34918 zend_tmp_string_release(tmp_name);
34919 }
34920 } while (0);
34921
34922 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
34923 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
34924
34925 /* assign_obj has two opcodes! */
34926 ZEND_VM_NEXT_OPCODE_EX(1, 2);
34927 }
34928
34929 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34930 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34931 {
34932 USE_OPLINE
34933 zval *object;
34934 zval *property;
34935 zval *zptr;
34936 void **cache_slot;
34937 zend_property_info *prop_info;
34938 zend_object *zobj;
34939 zend_string *name, *tmp_name;
34940
34941 SAVE_OPLINE();
34942 object = &EX(This);
34943 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
34944
34945 do {
34946 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
34947 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
34948 object = Z_REFVAL_P(object);
34949 goto pre_incdec_object;
34950 }
34951 if (IS_UNUSED == IS_CV
34952 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
34953 ZVAL_UNDEFINED_OP1();
34954 }
34955 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
34956 break;
34957 }
34958
34959 pre_incdec_object:
34960 /* here we are sure we are dealing with an object */
34961 zobj = Z_OBJ_P(object);
34962 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
34963 name = Z_STR_P(property);
34964 } else {
34965 name = zval_try_get_tmp_string(property, &tmp_name);
34966 if (UNEXPECTED(!name)) {
34967 UNDEF_RESULT();
34968 break;
34969 }
34970 }
34971 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
34972 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
34973 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
34974 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
34975 ZVAL_NULL(EX_VAR(opline->result.var));
34976 }
34977 } else {
34978 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
34979 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
34980 } else {
34981 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
34982 }
34983 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
34984 }
34985 } else {
34986 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
34987 }
34988 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
34989 zend_tmp_string_release(tmp_name);
34990 }
34991 } while (0);
34992
34993 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
34994
34995 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
34996 }
34997
ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)34998 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
34999 {
35000 USE_OPLINE
35001 zval *object;
35002 zval *property;
35003 zval *zptr;
35004 void **cache_slot;
35005 zend_property_info *prop_info;
35006 zend_object *zobj;
35007 zend_string *name, *tmp_name;
35008
35009 SAVE_OPLINE();
35010 object = &EX(This);
35011 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35012
35013 do {
35014 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35015 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35016 object = Z_REFVAL_P(object);
35017 goto post_incdec_object;
35018 }
35019 if (IS_UNUSED == IS_CV
35020 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
35021 ZVAL_UNDEFINED_OP1();
35022 }
35023 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
35024 break;
35025 }
35026
35027 post_incdec_object:
35028 /* here we are sure we are dealing with an object */
35029 zobj = Z_OBJ_P(object);
35030 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35031 name = Z_STR_P(property);
35032 } else {
35033 name = zval_try_get_tmp_string(property, &tmp_name);
35034 if (UNEXPECTED(!name)) {
35035 ZVAL_UNDEF(EX_VAR(opline->result.var));
35036 break;
35037 }
35038 }
35039 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
35040 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
35041 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
35042 ZVAL_NULL(EX_VAR(opline->result.var));
35043 } else {
35044 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35045 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
35046 } else {
35047 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
35048 }
35049
35050 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
35051 }
35052 } else {
35053 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
35054 }
35055 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35056 zend_tmp_string_release(tmp_name);
35057 }
35058 } while (0);
35059
35060 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35061
35062 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35063 }
35064
ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35065 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35066 {
35067 USE_OPLINE
35068 zval *container;
35069 void **cache_slot = NULL;
35070
35071 SAVE_OPLINE();
35072 container = &EX(This);
35073
35074 if (IS_UNUSED == IS_CONST ||
35075 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
35076 do {
35077 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
35078 container = Z_REFVAL_P(container);
35079 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
35080 break;
35081 }
35082 }
35083 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
35084 ZVAL_UNDEFINED_OP1();
35085 }
35086 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35087 ZVAL_NULL(EX_VAR(opline->result.var));
35088 goto fetch_obj_r_finish;
35089 } while (0);
35090 }
35091
35092 /* here we are sure we are dealing with an object */
35093 do {
35094 zend_object *zobj = Z_OBJ_P(container);
35095 zend_string *name, *tmp_name;
35096 zval *retval;
35097
35098 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35099 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
35100
35101 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
35102 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35103
35104 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35105 retval = OBJ_PROP(zobj, prop_offset);
35106 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
35107 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35108 goto fetch_obj_r_copy;
35109 } else {
35110 fetch_obj_r_fast_copy:
35111 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
35112 ZEND_VM_NEXT_OPCODE();
35113 }
35114 }
35115 } else if (EXPECTED(zobj->properties != NULL)) {
35116 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35117 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
35118 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
35119
35120 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
35121 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
35122
35123 if (EXPECTED(p->key == name) ||
35124 (EXPECTED(p->h == ZSTR_H(name)) &&
35125 EXPECTED(p->key != NULL) &&
35126 EXPECTED(zend_string_equal_content(p->key, name)))) {
35127 retval = &p->val;
35128 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35129 goto fetch_obj_r_copy;
35130 } else {
35131 goto fetch_obj_r_fast_copy;
35132 }
35133 }
35134 }
35135 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
35136 }
35137 retval = zend_hash_find_known_hash(zobj->properties, name);
35138 if (EXPECTED(retval)) {
35139 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
35140 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
35141 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35142 goto fetch_obj_r_copy;
35143 } else {
35144 goto fetch_obj_r_fast_copy;
35145 }
35146 }
35147 }
35148 }
35149 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35150 } else {
35151 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35152 if (UNEXPECTED(!name)) {
35153 ZVAL_UNDEF(EX_VAR(opline->result.var));
35154 break;
35155 }
35156 }
35157
35158 #if ZEND_DEBUG
35159 /* For non-standard object handlers, verify a declared property type in debug builds.
35160 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
35161 zend_property_info *prop_info = NULL;
35162 if (zobj->handlers->read_property != zend_std_read_property) {
35163 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
35164 }
35165 #endif
35166 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
35167 #if ZEND_DEBUG
35168 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
35169 && ZEND_TYPE_IS_SET(prop_info->type)) {
35170 ZVAL_OPT_DEREF(retval);
35171 zend_verify_property_type(prop_info, retval, /* strict */ true);
35172 }
35173 #endif
35174
35175 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35176 zend_tmp_string_release(tmp_name);
35177 }
35178
35179 if (retval != EX_VAR(opline->result.var)) {
35180 fetch_obj_r_copy:
35181 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
35182 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
35183 zend_unwrap_reference(retval);
35184 }
35185 } while (0);
35186
35187 fetch_obj_r_finish:
35188 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35189
35190 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35191 }
35192
ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35193 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35194 {
35195 USE_OPLINE
35196 zval *property, *container, *result;
35197
35198 SAVE_OPLINE();
35199
35200 container = &EX(This);
35201 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35202 result = EX_VAR(opline->result.var);
35203 zend_fetch_property_address(
35204 result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR),
35205 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
35206 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
35207 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35208 if (IS_UNUSED == IS_VAR) {
35209 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
35210 }
35211 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35212 }
35213
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35214 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35215 {
35216 USE_OPLINE
35217 zval *property, *container, *result;
35218
35219 SAVE_OPLINE();
35220 container = &EX(This);
35221 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35222 result = EX_VAR(opline->result.var);
35223 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 OPLINE_CC EXECUTE_DATA_CC);
35224 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35225 if (IS_UNUSED == IS_VAR) {
35226 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
35227 }
35228 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35229 }
35230
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35231 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35232 {
35233 USE_OPLINE
35234 zval *container;
35235 void **cache_slot = NULL;
35236
35237 SAVE_OPLINE();
35238 container = &EX(This);
35239
35240 if (IS_UNUSED == IS_CONST ||
35241 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
35242 do {
35243 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
35244 container = Z_REFVAL_P(container);
35245 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
35246 break;
35247 }
35248 }
35249 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
35250 ZVAL_UNDEFINED_OP2();
35251 }
35252 ZVAL_NULL(EX_VAR(opline->result.var));
35253 goto fetch_obj_is_finish;
35254 } while (0);
35255 }
35256
35257 /* here we are sure we are dealing with an object */
35258 do {
35259 zend_object *zobj = Z_OBJ_P(container);
35260 zend_string *name, *tmp_name;
35261 zval *retval;
35262
35263 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35264 cache_slot = CACHE_ADDR(opline->extended_value);
35265
35266 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
35267 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35268
35269 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35270 retval = OBJ_PROP(zobj, prop_offset);
35271 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
35272 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35273 goto fetch_obj_is_copy;
35274 } else {
35275 fetch_obj_is_fast_copy:
35276 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
35277 ZEND_VM_NEXT_OPCODE();
35278 }
35279 }
35280 } else if (EXPECTED(zobj->properties != NULL)) {
35281 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35282 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
35283 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
35284
35285 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
35286 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
35287
35288 if (EXPECTED(p->key == name) ||
35289 (EXPECTED(p->h == ZSTR_H(name)) &&
35290 EXPECTED(p->key != NULL) &&
35291 EXPECTED(zend_string_equal_content(p->key, name)))) {
35292 retval = &p->val;
35293 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35294 goto fetch_obj_is_copy;
35295 } else {
35296 goto fetch_obj_is_fast_copy;
35297 }
35298 }
35299 }
35300 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
35301 }
35302 retval = zend_hash_find_known_hash(zobj->properties, name);
35303 if (EXPECTED(retval)) {
35304 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
35305 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
35306 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
35307 goto fetch_obj_is_copy;
35308 } else {
35309 goto fetch_obj_is_fast_copy;
35310 }
35311 }
35312 }
35313 }
35314 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35315 } else {
35316 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35317 if (UNEXPECTED(!name)) {
35318 ZVAL_UNDEF(EX_VAR(opline->result.var));
35319 break;
35320 }
35321 }
35322
35323 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
35324
35325 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35326 zend_tmp_string_release(tmp_name);
35327 }
35328
35329 if (retval != EX_VAR(opline->result.var)) {
35330 fetch_obj_is_copy:
35331 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
35332 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
35333 zend_unwrap_reference(retval);
35334 }
35335 } while (0);
35336
35337 fetch_obj_is_finish:
35338 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35339
35340 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35341 }
35342
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35343 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35344 {
35345 #if 0
35346 USE_OPLINE
35347 #endif
35348
35349 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
35350 /* Behave like FETCH_OBJ_W */
35351 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
35352 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35353 }
35354 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35355 } else {
35356 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
35357 }
35358 }
35359
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35360 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35361 {
35362 USE_OPLINE
35363 zval *container, *property, *result;
35364
35365 SAVE_OPLINE();
35366 container = &EX(This);
35367 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35368 result = EX_VAR(opline->result.var);
35369 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 OPLINE_CC EXECUTE_DATA_CC);
35370 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35371 if (IS_UNUSED == IS_VAR) {
35372 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
35373 }
35374 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
35375 }
35376
ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35377 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35378 {
35379 USE_OPLINE
35380 zval *object, *value, tmp;
35381 zend_object *zobj;
35382 zend_string *name, *tmp_name;
35383 zend_refcounted *garbage = NULL;
35384
35385 SAVE_OPLINE();
35386 object = &EX(This);
35387 value = RT_CONSTANT((opline+1), (opline+1)->op1);
35388
35389 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35390 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35391 object = Z_REFVAL_P(object);
35392 goto assign_object;
35393 }
35394 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
35395 value = &EG(uninitialized_zval);
35396 goto free_and_exit_assign_obj;
35397 }
35398
35399 assign_object:
35400 zobj = Z_OBJ_P(object);
35401 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35402 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
35403 void **cache_slot = CACHE_ADDR(opline->extended_value);
35404 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35405 zval *property_val;
35406
35407 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35408 property_val = OBJ_PROP(zobj, prop_offset);
35409 if (Z_TYPE_P(property_val) != IS_UNDEF) {
35410 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
35411
35412 if (prop_info != NULL) {
35413 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
35414 goto free_and_exit_assign_obj;
35415 } else {
35416 fast_assign_obj:
35417 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
35418 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35419 ZVAL_COPY(EX_VAR(opline->result.var), value);
35420 }
35421 goto exit_assign_obj;
35422 }
35423 }
35424 } else {
35425 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35426 if (EXPECTED(zobj->properties != NULL)) {
35427 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
35428 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
35429 GC_DELREF(zobj->properties);
35430 }
35431 zobj->properties = zend_array_dup(zobj->properties);
35432 }
35433 property_val = zend_hash_find_known_hash(zobj->properties, name);
35434 if (property_val) {
35435 goto fast_assign_obj;
35436 }
35437 }
35438
35439 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
35440 if (EXPECTED(zobj->properties == NULL)) {
35441 rebuild_object_properties(zobj);
35442 }
35443 if (IS_CONST == IS_CONST) {
35444 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
35445 Z_ADDREF_P(value);
35446 }
35447 } else if (IS_CONST != IS_TMP_VAR) {
35448 if (Z_ISREF_P(value)) {
35449 if (IS_CONST == IS_VAR) {
35450 zend_reference *ref = Z_REF_P(value);
35451 if (GC_DELREF(ref) == 0) {
35452 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
35453 efree_size(ref, sizeof(zend_reference));
35454 value = &tmp;
35455 } else {
35456 value = Z_REFVAL_P(value);
35457 Z_TRY_ADDREF_P(value);
35458 }
35459 } else {
35460 value = Z_REFVAL_P(value);
35461 Z_TRY_ADDREF_P(value);
35462 }
35463 } else if (IS_CONST == IS_CV) {
35464 Z_TRY_ADDREF_P(value);
35465 }
35466 }
35467 zend_hash_add_new(zobj->properties, name, value);
35468 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35469 ZVAL_COPY(EX_VAR(opline->result.var), value);
35470 }
35471 goto exit_assign_obj;
35472 }
35473 }
35474 }
35475 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35476 } else {
35477 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35478 if (UNEXPECTED(!name)) {
35479
35480 UNDEF_RESULT();
35481 goto exit_assign_obj;
35482 }
35483 }
35484
35485 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
35486 ZVAL_DEREF(value);
35487 }
35488
35489 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
35490
35491 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35492 zend_tmp_string_release(tmp_name);
35493 }
35494
35495 free_and_exit_assign_obj:
35496 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
35497 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
35498 }
35499
35500 exit_assign_obj:
35501 if (garbage) {
35502 GC_DTOR_NO_REF(garbage);
35503 }
35504 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35505
35506 /* assign_obj has two opcodes! */
35507 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35508 }
35509
35510 /* 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)35511 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35512 {
35513 USE_OPLINE
35514 zval *object, *value, tmp;
35515 zend_object *zobj;
35516 zend_string *name, *tmp_name;
35517 zend_refcounted *garbage = NULL;
35518
35519 SAVE_OPLINE();
35520 object = &EX(This);
35521 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
35522
35523 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35524 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35525 object = Z_REFVAL_P(object);
35526 goto assign_object;
35527 }
35528 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
35529 value = &EG(uninitialized_zval);
35530 goto free_and_exit_assign_obj;
35531 }
35532
35533 assign_object:
35534 zobj = Z_OBJ_P(object);
35535 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35536 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
35537 void **cache_slot = CACHE_ADDR(opline->extended_value);
35538 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35539 zval *property_val;
35540
35541 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35542 property_val = OBJ_PROP(zobj, prop_offset);
35543 if (Z_TYPE_P(property_val) != IS_UNDEF) {
35544 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
35545
35546 if (prop_info != NULL) {
35547 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
35548 goto free_and_exit_assign_obj;
35549 } else {
35550 fast_assign_obj:
35551 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
35552 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35553 ZVAL_COPY(EX_VAR(opline->result.var), value);
35554 }
35555 goto exit_assign_obj;
35556 }
35557 }
35558 } else {
35559 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35560 if (EXPECTED(zobj->properties != NULL)) {
35561 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
35562 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
35563 GC_DELREF(zobj->properties);
35564 }
35565 zobj->properties = zend_array_dup(zobj->properties);
35566 }
35567 property_val = zend_hash_find_known_hash(zobj->properties, name);
35568 if (property_val) {
35569 goto fast_assign_obj;
35570 }
35571 }
35572
35573 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
35574 if (EXPECTED(zobj->properties == NULL)) {
35575 rebuild_object_properties(zobj);
35576 }
35577 if (IS_TMP_VAR == IS_CONST) {
35578 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
35579 Z_ADDREF_P(value);
35580 }
35581 } else if (IS_TMP_VAR != IS_TMP_VAR) {
35582 if (Z_ISREF_P(value)) {
35583 if (IS_TMP_VAR == IS_VAR) {
35584 zend_reference *ref = Z_REF_P(value);
35585 if (GC_DELREF(ref) == 0) {
35586 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
35587 efree_size(ref, sizeof(zend_reference));
35588 value = &tmp;
35589 } else {
35590 value = Z_REFVAL_P(value);
35591 Z_TRY_ADDREF_P(value);
35592 }
35593 } else {
35594 value = Z_REFVAL_P(value);
35595 Z_TRY_ADDREF_P(value);
35596 }
35597 } else if (IS_TMP_VAR == IS_CV) {
35598 Z_TRY_ADDREF_P(value);
35599 }
35600 }
35601 zend_hash_add_new(zobj->properties, name, value);
35602 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35603 ZVAL_COPY(EX_VAR(opline->result.var), value);
35604 }
35605 goto exit_assign_obj;
35606 }
35607 }
35608 }
35609 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35610 } else {
35611 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35612 if (UNEXPECTED(!name)) {
35613 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
35614 UNDEF_RESULT();
35615 goto exit_assign_obj;
35616 }
35617 }
35618
35619 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
35620 ZVAL_DEREF(value);
35621 }
35622
35623 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
35624
35625 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35626 zend_tmp_string_release(tmp_name);
35627 }
35628
35629 free_and_exit_assign_obj:
35630 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
35631 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
35632 }
35633 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
35634 exit_assign_obj:
35635 if (garbage) {
35636 GC_DTOR_NO_REF(garbage);
35637 }
35638 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35639
35640 /* assign_obj has two opcodes! */
35641 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35642 }
35643
35644 /* 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)35645 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35646 {
35647 USE_OPLINE
35648 zval *object, *value, tmp;
35649 zend_object *zobj;
35650 zend_string *name, *tmp_name;
35651 zend_refcounted *garbage = NULL;
35652
35653 SAVE_OPLINE();
35654 object = &EX(This);
35655 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
35656
35657 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35658 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35659 object = Z_REFVAL_P(object);
35660 goto assign_object;
35661 }
35662 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
35663 value = &EG(uninitialized_zval);
35664 goto free_and_exit_assign_obj;
35665 }
35666
35667 assign_object:
35668 zobj = Z_OBJ_P(object);
35669 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35670 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
35671 void **cache_slot = CACHE_ADDR(opline->extended_value);
35672 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35673 zval *property_val;
35674
35675 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35676 property_val = OBJ_PROP(zobj, prop_offset);
35677 if (Z_TYPE_P(property_val) != IS_UNDEF) {
35678 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
35679
35680 if (prop_info != NULL) {
35681 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
35682 goto free_and_exit_assign_obj;
35683 } else {
35684 fast_assign_obj:
35685 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
35686 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35687 ZVAL_COPY(EX_VAR(opline->result.var), value);
35688 }
35689 goto exit_assign_obj;
35690 }
35691 }
35692 } else {
35693 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35694 if (EXPECTED(zobj->properties != NULL)) {
35695 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
35696 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
35697 GC_DELREF(zobj->properties);
35698 }
35699 zobj->properties = zend_array_dup(zobj->properties);
35700 }
35701 property_val = zend_hash_find_known_hash(zobj->properties, name);
35702 if (property_val) {
35703 goto fast_assign_obj;
35704 }
35705 }
35706
35707 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
35708 if (EXPECTED(zobj->properties == NULL)) {
35709 rebuild_object_properties(zobj);
35710 }
35711 if (IS_VAR == IS_CONST) {
35712 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
35713 Z_ADDREF_P(value);
35714 }
35715 } else if (IS_VAR != IS_TMP_VAR) {
35716 if (Z_ISREF_P(value)) {
35717 if (IS_VAR == IS_VAR) {
35718 zend_reference *ref = Z_REF_P(value);
35719 if (GC_DELREF(ref) == 0) {
35720 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
35721 efree_size(ref, sizeof(zend_reference));
35722 value = &tmp;
35723 } else {
35724 value = Z_REFVAL_P(value);
35725 Z_TRY_ADDREF_P(value);
35726 }
35727 } else {
35728 value = Z_REFVAL_P(value);
35729 Z_TRY_ADDREF_P(value);
35730 }
35731 } else if (IS_VAR == IS_CV) {
35732 Z_TRY_ADDREF_P(value);
35733 }
35734 }
35735 zend_hash_add_new(zobj->properties, name, value);
35736 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35737 ZVAL_COPY(EX_VAR(opline->result.var), value);
35738 }
35739 goto exit_assign_obj;
35740 }
35741 }
35742 }
35743 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35744 } else {
35745 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35746 if (UNEXPECTED(!name)) {
35747 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
35748 UNDEF_RESULT();
35749 goto exit_assign_obj;
35750 }
35751 }
35752
35753 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
35754 ZVAL_DEREF(value);
35755 }
35756
35757 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
35758
35759 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35760 zend_tmp_string_release(tmp_name);
35761 }
35762
35763 free_and_exit_assign_obj:
35764 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
35765 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
35766 }
35767 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
35768 exit_assign_obj:
35769 if (garbage) {
35770 GC_DTOR_NO_REF(garbage);
35771 }
35772 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35773
35774 /* assign_obj has two opcodes! */
35775 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35776 }
35777
35778 /* 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)35779 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35780 {
35781 USE_OPLINE
35782 zval *object, *value, tmp;
35783 zend_object *zobj;
35784 zend_string *name, *tmp_name;
35785 zend_refcounted *garbage = NULL;
35786
35787 SAVE_OPLINE();
35788 object = &EX(This);
35789 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
35790
35791 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
35792 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
35793 object = Z_REFVAL_P(object);
35794 goto assign_object;
35795 }
35796 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
35797 value = &EG(uninitialized_zval);
35798 goto free_and_exit_assign_obj;
35799 }
35800
35801 assign_object:
35802 zobj = Z_OBJ_P(object);
35803 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35804 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
35805 void **cache_slot = CACHE_ADDR(opline->extended_value);
35806 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
35807 zval *property_val;
35808
35809 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
35810 property_val = OBJ_PROP(zobj, prop_offset);
35811 if (Z_TYPE_P(property_val) != IS_UNDEF) {
35812 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
35813
35814 if (prop_info != NULL) {
35815 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
35816 goto free_and_exit_assign_obj;
35817 } else {
35818 fast_assign_obj:
35819 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
35820 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35821 ZVAL_COPY(EX_VAR(opline->result.var), value);
35822 }
35823 goto exit_assign_obj;
35824 }
35825 }
35826 } else {
35827 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35828 if (EXPECTED(zobj->properties != NULL)) {
35829 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
35830 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
35831 GC_DELREF(zobj->properties);
35832 }
35833 zobj->properties = zend_array_dup(zobj->properties);
35834 }
35835 property_val = zend_hash_find_known_hash(zobj->properties, name);
35836 if (property_val) {
35837 goto fast_assign_obj;
35838 }
35839 }
35840
35841 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
35842 if (EXPECTED(zobj->properties == NULL)) {
35843 rebuild_object_properties(zobj);
35844 }
35845 if (IS_CV == IS_CONST) {
35846 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
35847 Z_ADDREF_P(value);
35848 }
35849 } else if (IS_CV != IS_TMP_VAR) {
35850 if (Z_ISREF_P(value)) {
35851 if (IS_CV == IS_VAR) {
35852 zend_reference *ref = Z_REF_P(value);
35853 if (GC_DELREF(ref) == 0) {
35854 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
35855 efree_size(ref, sizeof(zend_reference));
35856 value = &tmp;
35857 } else {
35858 value = Z_REFVAL_P(value);
35859 Z_TRY_ADDREF_P(value);
35860 }
35861 } else {
35862 value = Z_REFVAL_P(value);
35863 Z_TRY_ADDREF_P(value);
35864 }
35865 } else if (IS_CV == IS_CV) {
35866 Z_TRY_ADDREF_P(value);
35867 }
35868 }
35869 zend_hash_add_new(zobj->properties, name, value);
35870 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
35871 ZVAL_COPY(EX_VAR(opline->result.var), value);
35872 }
35873 goto exit_assign_obj;
35874 }
35875 }
35876 }
35877 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
35878 } else {
35879 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
35880 if (UNEXPECTED(!name)) {
35881
35882 UNDEF_RESULT();
35883 goto exit_assign_obj;
35884 }
35885 }
35886
35887 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
35888 ZVAL_DEREF(value);
35889 }
35890
35891 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
35892
35893 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
35894 zend_tmp_string_release(tmp_name);
35895 }
35896
35897 free_and_exit_assign_obj:
35898 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
35899 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
35900 }
35901
35902 exit_assign_obj:
35903 if (garbage) {
35904 GC_DTOR_NO_REF(garbage);
35905 }
35906 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35907
35908 /* assign_obj has two opcodes! */
35909 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35910 }
35911
35912 /* 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)35913 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35914 {
35915 USE_OPLINE
35916 zval *property, *container, *value_ptr;
35917
35918 SAVE_OPLINE();
35919
35920 container = &EX(This);
35921 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35922
35923 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
35924
35925 if (1) {
35926 if (IS_UNUSED == IS_UNUSED) {
35927 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35928 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35929 } else {
35930 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35931 }
35932 } else {
35933 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35934 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35935 } else {
35936 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35937 }
35938 }
35939 } else {
35940 zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
35941 }
35942
35943 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35944 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
35945 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35946 }
35947
35948 /* 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)35949 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35950 {
35951 USE_OPLINE
35952 zval *property, *container, *value_ptr;
35953
35954 SAVE_OPLINE();
35955
35956 container = &EX(This);
35957 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35958
35959 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
35960
35961 if (1) {
35962 if (IS_UNUSED == IS_UNUSED) {
35963 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35964 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35965 } else {
35966 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35967 }
35968 } else {
35969 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35970 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35971 } else {
35972 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
35973 }
35974 }
35975 } else {
35976 zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
35977 }
35978
35979 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
35980
35981 ZEND_VM_NEXT_OPCODE_EX(1, 2);
35982 }
35983
35984 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)35985 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
35986 {
35987 USE_OPLINE
35988 zend_string **rope;
35989 zval *var;
35990
35991 /* Compiler allocates the necessary number of zval slots to keep the rope */
35992 rope = (zend_string**)EX_VAR(opline->result.var);
35993 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
35994 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
35995 rope[0] = Z_STR_P(var);
35996 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
35997 Z_ADDREF_P(var);
35998 }
35999 } else {
36000 var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36001 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
36002 if ((IS_TMP_VAR|IS_VAR) == IS_CV) {
36003 rope[0] = zend_string_copy(Z_STR_P(var));
36004 } else {
36005 rope[0] = Z_STR_P(var);
36006 }
36007 } else {
36008 SAVE_OPLINE();
36009 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
36010 ZVAL_UNDEFINED_OP2();
36011 }
36012 rope[0] = zval_get_string_func(var);
36013 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36014 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36015 }
36016 }
36017 ZEND_VM_NEXT_OPCODE();
36018 }
36019
ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36020 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36021 {
36022 zval *class_name;
36023 USE_OPLINE
36024
36025 SAVE_OPLINE();
36026 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
36027 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
36028 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36029 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36030 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
36031
36032 if (UNEXPECTED(ce == NULL)) {
36033 class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36034 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
36035 CACHE_PTR(opline->extended_value, ce);
36036 }
36037 Z_CE_P(EX_VAR(opline->result.var)) = ce;
36038 } else {
36039 class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36040 try_class_name:
36041 if (Z_TYPE_P(class_name) == IS_OBJECT) {
36042 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
36043 } else if (Z_TYPE_P(class_name) == IS_STRING) {
36044 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
36045 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
36046 class_name = Z_REFVAL_P(class_name);
36047 goto try_class_name;
36048 } else {
36049 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
36050 ZVAL_UNDEFINED_OP2();
36051 if (UNEXPECTED(EG(exception) != NULL)) {
36052 HANDLE_EXCEPTION();
36053 }
36054 }
36055 zend_throw_error(NULL, "Class name must be a valid object or a string");
36056 }
36057 }
36058
36059 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36060 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36061 }
36062
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36063 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36064 {
36065 USE_OPLINE
36066 zval *function_name;
36067 zval *object;
36068 zend_function *fbc;
36069 zend_class_entry *called_scope;
36070 zend_object *obj;
36071 zend_execute_data *call;
36072 uint32_t call_info;
36073
36074 SAVE_OPLINE();
36075
36076 object = &EX(This);
36077
36078 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36079 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36080 }
36081
36082 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
36083 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
36084 do {
36085 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
36086 function_name = Z_REFVAL_P(function_name);
36087 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
36088 break;
36089 }
36090 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
36091 ZVAL_UNDEFINED_OP2();
36092 if (UNEXPECTED(EG(exception) != NULL)) {
36093
36094 HANDLE_EXCEPTION();
36095 }
36096 }
36097 zend_throw_error(NULL, "Method name must be a string");
36098 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36099
36100 HANDLE_EXCEPTION();
36101 } while (0);
36102 }
36103
36104 if (IS_UNUSED == IS_UNUSED) {
36105 obj = Z_OBJ_P(object);
36106 } else {
36107 do {
36108 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
36109 obj = Z_OBJ_P(object);
36110 } else {
36111 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
36112 zend_reference *ref = Z_REF_P(object);
36113
36114 object = &ref->val;
36115 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
36116 obj = Z_OBJ_P(object);
36117 if (IS_UNUSED & IS_VAR) {
36118 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
36119 efree_size(ref, sizeof(zend_reference));
36120 } else {
36121 Z_ADDREF_P(object);
36122 }
36123 }
36124 break;
36125 }
36126 }
36127 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
36128 object = ZVAL_UNDEFINED_OP1();
36129 if (UNEXPECTED(EG(exception) != NULL)) {
36130 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36131 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36132 }
36133 HANDLE_EXCEPTION();
36134 }
36135 }
36136 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36137 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36138 }
36139 zend_invalid_method_call(object, function_name);
36140 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36141
36142 HANDLE_EXCEPTION();
36143 }
36144 } while (0);
36145 }
36146
36147 called_scope = obj->ce;
36148
36149 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
36150 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
36151 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
36152 } else {
36153 zend_object *orig_obj = obj;
36154
36155 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36156 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36157 }
36158
36159 /* First, locate the function. */
36160 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));
36161 if (UNEXPECTED(fbc == NULL)) {
36162 if (EXPECTED(!EG(exception))) {
36163 zend_undefined_method(obj->ce, Z_STR_P(function_name));
36164 }
36165 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36166 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
36167 zend_objects_store_del(orig_obj);
36168 }
36169 HANDLE_EXCEPTION();
36170 }
36171 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
36172 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
36173 EXPECTED(obj == orig_obj)) {
36174 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
36175 }
36176 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
36177 GC_ADDREF(obj); /* For $this pointer */
36178 if (GC_DELREF(orig_obj) == 0) {
36179 zend_objects_store_del(orig_obj);
36180 }
36181 }
36182 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
36183 init_func_run_time_cache(&fbc->op_array);
36184 }
36185 }
36186
36187 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36188 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36189 }
36190
36191 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
36192 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
36193 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
36194 zend_objects_store_del(obj);
36195 if (UNEXPECTED(EG(exception))) {
36196 HANDLE_EXCEPTION();
36197 }
36198 }
36199 /* call static method */
36200 obj = (zend_object*)called_scope;
36201 call_info = ZEND_CALL_NESTED_FUNCTION;
36202 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
36203 if (IS_UNUSED == IS_CV) {
36204 GC_ADDREF(obj); /* For $this pointer */
36205 }
36206 /* CV may be changed indirectly (e.g. when it's a reference) */
36207 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
36208 }
36209
36210 call = zend_vm_stack_push_call_frame(call_info,
36211 fbc, opline->extended_value, obj);
36212 call->prev_execute_data = EX(call);
36213 EX(call) = call;
36214
36215 ZEND_VM_NEXT_OPCODE();
36216 }
36217
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36218 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36219 {
36220 USE_OPLINE
36221 zval *function_name;
36222 zend_class_entry *ce;
36223 uint32_t call_info;
36224 zend_function *fbc;
36225 zend_execute_data *call;
36226
36227 SAVE_OPLINE();
36228
36229 if (IS_UNUSED == IS_CONST) {
36230 /* no function found. try a static method in class */
36231 ce = CACHED_PTR(opline->result.num);
36232 if (UNEXPECTED(ce == NULL)) {
36233 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);
36234 if (UNEXPECTED(ce == NULL)) {
36235 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36236 HANDLE_EXCEPTION();
36237 }
36238 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36239 CACHE_PTR(opline->result.num, ce);
36240 }
36241 }
36242 } else if (IS_UNUSED == IS_UNUSED) {
36243 ce = zend_fetch_class(NULL, opline->op1.num);
36244 if (UNEXPECTED(ce == NULL)) {
36245 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36246 HANDLE_EXCEPTION();
36247 }
36248 } else {
36249 ce = Z_CE_P(EX_VAR(opline->op1.var));
36250 }
36251
36252 if (IS_UNUSED == IS_CONST &&
36253 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
36254 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
36255 /* nothing to do */
36256 } else if (IS_UNUSED != IS_CONST &&
36257 (IS_TMP_VAR|IS_VAR) == IS_CONST &&
36258 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
36259 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
36260 } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
36261 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36262 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36263 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
36264 do {
36265 if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
36266 function_name = Z_REFVAL_P(function_name);
36267 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
36268 break;
36269 }
36270 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
36271 ZVAL_UNDEFINED_OP2();
36272 if (UNEXPECTED(EG(exception) != NULL)) {
36273 HANDLE_EXCEPTION();
36274 }
36275 }
36276 zend_throw_error(NULL, "Method name must be a string");
36277 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36278 HANDLE_EXCEPTION();
36279 } while (0);
36280 }
36281 }
36282
36283 if (ce->get_static_method) {
36284 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
36285 } else {
36286 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));
36287 }
36288 if (UNEXPECTED(fbc == NULL)) {
36289 if (EXPECTED(!EG(exception))) {
36290 zend_undefined_method(ce, Z_STR_P(function_name));
36291 }
36292 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36293 HANDLE_EXCEPTION();
36294 }
36295 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
36296 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
36297 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
36298 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
36299 }
36300 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
36301 init_func_run_time_cache(&fbc->op_array);
36302 }
36303 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36304 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36305 }
36306 } else {
36307 if (UNEXPECTED(ce->constructor == NULL)) {
36308 zend_throw_error(NULL, "Cannot call constructor");
36309 HANDLE_EXCEPTION();
36310 }
36311 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
36312 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
36313 HANDLE_EXCEPTION();
36314 }
36315 fbc = ce->constructor;
36316 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
36317 init_func_run_time_cache(&fbc->op_array);
36318 }
36319 }
36320
36321 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
36322 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
36323 ce = (zend_class_entry*)Z_OBJ(EX(This));
36324 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
36325 } else {
36326 zend_non_static_method_call(fbc);
36327 HANDLE_EXCEPTION();
36328 }
36329 } else {
36330 /* previous opcode is ZEND_FETCH_CLASS */
36331 if (IS_UNUSED == IS_UNUSED
36332 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
36333 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
36334 if (Z_TYPE(EX(This)) == IS_OBJECT) {
36335 ce = Z_OBJCE(EX(This));
36336 } else {
36337 ce = Z_CE(EX(This));
36338 }
36339 }
36340 call_info = ZEND_CALL_NESTED_FUNCTION;
36341 }
36342
36343 call = zend_vm_stack_push_call_frame(call_info,
36344 fbc, opline->extended_value, ce);
36345 call->prev_execute_data = EX(call);
36346 EX(call) = call;
36347
36348 ZEND_VM_NEXT_OPCODE();
36349 }
36350
ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36351 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36352 {
36353 zval *array;
36354 uint32_t size;
36355 USE_OPLINE
36356
36357 array = EX_VAR(opline->result.var);
36358 if (IS_UNUSED != IS_UNUSED) {
36359 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
36360 ZVAL_ARR(array, zend_new_array(size));
36361 /* Explicitly initialize array as not-packed if flag is set */
36362 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
36363 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
36364 }
36365 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36366 } else {
36367 ZVAL_ARR(array, zend_new_array(0));
36368 ZEND_VM_NEXT_OPCODE();
36369 }
36370 }
36371
ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36372 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36373 {
36374 USE_OPLINE
36375 zval *container;
36376 zval *offset;
36377 zend_string *name, *tmp_name;
36378
36379 SAVE_OPLINE();
36380 container = &EX(This);
36381 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36382
36383 do {
36384 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
36385 if (Z_ISREF_P(container)) {
36386 container = Z_REFVAL_P(container);
36387 if (Z_TYPE_P(container) != IS_OBJECT) {
36388 if (IS_UNUSED == IS_CV
36389 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
36390 ZVAL_UNDEFINED_OP1();
36391 }
36392 break;
36393 }
36394 } else {
36395 break;
36396 }
36397 }
36398 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36399 name = Z_STR_P(offset);
36400 } else {
36401 name = zval_try_get_tmp_string(offset, &tmp_name);
36402 if (UNEXPECTED(!name)) {
36403 break;
36404 }
36405 }
36406 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));
36407 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36408 zend_tmp_string_release(tmp_name);
36409 }
36410 } while (0);
36411
36412 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36413
36414 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36415 }
36416
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36417 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36418 {
36419 USE_OPLINE
36420 zval *container;
36421 int result;
36422 zval *offset;
36423 zend_string *name, *tmp_name;
36424
36425 SAVE_OPLINE();
36426 container = &EX(This);
36427 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36428
36429 if (IS_UNUSED == IS_CONST ||
36430 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
36431 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
36432 container = Z_REFVAL_P(container);
36433 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
36434 result = (opline->extended_value & ZEND_ISEMPTY);
36435 goto isset_object_finish;
36436 }
36437 } else {
36438 result = (opline->extended_value & ZEND_ISEMPTY);
36439 goto isset_object_finish;
36440 }
36441 }
36442
36443 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
36444 name = Z_STR_P(offset);
36445 } else {
36446 name = zval_try_get_tmp_string(offset, &tmp_name);
36447 if (UNEXPECTED(!name)) {
36448 result = 0;
36449 goto isset_object_finish;
36450 }
36451 }
36452
36453 result =
36454 (opline->extended_value & ZEND_ISEMPTY) ^
36455 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));
36456
36457 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
36458 zend_tmp_string_release(tmp_name);
36459 }
36460
36461 isset_object_finish:
36462 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36463
36464 ZEND_VM_SMART_BRANCH(result, 1);
36465 }
36466
ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36467 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36468 {
36469 USE_OPLINE
36470
36471 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
36472
36473 SAVE_OPLINE();
36474 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
36475 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
36476 }
36477
36478 /* Destroy the previously yielded value */
36479 zval_ptr_dtor(&generator->value);
36480
36481 /* Destroy the previously yielded key */
36482 zval_ptr_dtor(&generator->key);
36483
36484 /* Set the new yielded value */
36485 if (IS_UNUSED != IS_UNUSED) {
36486 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
36487 /* Constants and temporary variables aren't yieldable by reference,
36488 * but we still allow them with a notice. */
36489 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
36490 zval *value;
36491
36492 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
36493
36494 value = NULL;
36495 ZVAL_COPY_VALUE(&generator->value, value);
36496 if (IS_UNUSED == IS_CONST) {
36497 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
36498 Z_ADDREF(generator->value);
36499 }
36500 }
36501 } else {
36502 zval *value_ptr = NULL;
36503
36504 /* If a function call result is yielded and the function did
36505 * not return by reference we throw a notice. */
36506 do {
36507 if (IS_UNUSED == IS_VAR) {
36508 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
36509 if (opline->extended_value == ZEND_RETURNS_FUNCTION
36510 && !Z_ISREF_P(value_ptr)) {
36511 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
36512 ZVAL_COPY(&generator->value, value_ptr);
36513 break;
36514 }
36515 }
36516 if (Z_ISREF_P(value_ptr)) {
36517 Z_ADDREF_P(value_ptr);
36518 } else {
36519 ZVAL_MAKE_REF_EX(value_ptr, 2);
36520 }
36521 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
36522 } while (0);
36523
36524 }
36525 } else {
36526 zval *value = NULL;
36527
36528 /* Consts, temporary variables and references need copying */
36529 if (IS_UNUSED == IS_CONST) {
36530 ZVAL_COPY_VALUE(&generator->value, value);
36531 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
36532 Z_ADDREF(generator->value);
36533 }
36534 } else if (IS_UNUSED == IS_TMP_VAR) {
36535 ZVAL_COPY_VALUE(&generator->value, value);
36536 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
36537 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
36538
36539 } else {
36540 ZVAL_COPY_VALUE(&generator->value, value);
36541 if (IS_UNUSED == IS_CV) {
36542 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
36543 }
36544 }
36545 }
36546 } else {
36547 /* If no value was specified yield null */
36548 ZVAL_NULL(&generator->value);
36549 }
36550
36551 /* Set the new yielded key */
36552 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
36553 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
36554 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
36555 key = Z_REFVAL_P(key);
36556 }
36557 ZVAL_COPY(&generator->key, key);
36558 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
36559
36560 if (Z_TYPE(generator->key) == IS_LONG
36561 && Z_LVAL(generator->key) > generator->largest_used_integer_key
36562 ) {
36563 generator->largest_used_integer_key = Z_LVAL(generator->key);
36564 }
36565 } else {
36566 /* If no key was specified we use auto-increment keys */
36567 generator->largest_used_integer_key++;
36568 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
36569 }
36570
36571 if (RETURN_VALUE_USED(opline)) {
36572 /* If the return value of yield is used set the send
36573 * target and initialize it to NULL */
36574 generator->send_target = EX_VAR(opline->result.var);
36575 ZVAL_NULL(generator->send_target);
36576 } else {
36577 generator->send_target = NULL;
36578 }
36579
36580 /* We increment to the next op, so we are at the correct position when the
36581 * generator is resumed. */
36582 ZEND_VM_INC_OPCODE();
36583
36584 /* The GOTO VM uses a local opline variable. We need to set the opline
36585 * variable in execute_data so we don't resume at an old position. */
36586 SAVE_OPLINE();
36587
36588 ZEND_VM_RETURN();
36589 }
36590
ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36591 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36592 {
36593 zval *class_name;
36594 USE_OPLINE
36595
36596 SAVE_OPLINE();
36597 if (IS_UNUSED == IS_UNUSED) {
36598 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
36599 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36600 } else if (IS_UNUSED == IS_CONST) {
36601 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
36602
36603 if (UNEXPECTED(ce == NULL)) {
36604 class_name = NULL;
36605 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
36606 CACHE_PTR(opline->extended_value, ce);
36607 }
36608 Z_CE_P(EX_VAR(opline->result.var)) = ce;
36609 } else {
36610 class_name = NULL;
36611 try_class_name:
36612 if (Z_TYPE_P(class_name) == IS_OBJECT) {
36613 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
36614 } else if (Z_TYPE_P(class_name) == IS_STRING) {
36615 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
36616 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
36617 class_name = Z_REFVAL_P(class_name);
36618 goto try_class_name;
36619 } else {
36620 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
36621 ZVAL_UNDEFINED_OP2();
36622 if (UNEXPECTED(EG(exception) != NULL)) {
36623 HANDLE_EXCEPTION();
36624 }
36625 }
36626 zend_throw_error(NULL, "Class name must be a valid object or a string");
36627 }
36628 }
36629
36630 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36631 }
36632
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36633 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36634 {
36635 USE_OPLINE
36636 zval *function_name;
36637 zend_class_entry *ce;
36638 uint32_t call_info;
36639 zend_function *fbc;
36640 zend_execute_data *call;
36641
36642 SAVE_OPLINE();
36643
36644 if (IS_UNUSED == IS_CONST) {
36645 /* no function found. try a static method in class */
36646 ce = CACHED_PTR(opline->result.num);
36647 if (UNEXPECTED(ce == NULL)) {
36648 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);
36649 if (UNEXPECTED(ce == NULL)) {
36650
36651 HANDLE_EXCEPTION();
36652 }
36653 if (IS_UNUSED != IS_CONST) {
36654 CACHE_PTR(opline->result.num, ce);
36655 }
36656 }
36657 } else if (IS_UNUSED == IS_UNUSED) {
36658 ce = zend_fetch_class(NULL, opline->op1.num);
36659 if (UNEXPECTED(ce == NULL)) {
36660
36661 HANDLE_EXCEPTION();
36662 }
36663 } else {
36664 ce = Z_CE_P(EX_VAR(opline->op1.var));
36665 }
36666
36667 if (IS_UNUSED == IS_CONST &&
36668 IS_UNUSED == IS_CONST &&
36669 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
36670 /* nothing to do */
36671 } else if (IS_UNUSED != IS_CONST &&
36672 IS_UNUSED == IS_CONST &&
36673 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
36674 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
36675 } else if (IS_UNUSED != IS_UNUSED) {
36676 function_name = NULL;
36677 if (IS_UNUSED != IS_CONST) {
36678 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
36679 do {
36680 if (IS_UNUSED & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
36681 function_name = Z_REFVAL_P(function_name);
36682 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
36683 break;
36684 }
36685 } else if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
36686 ZVAL_UNDEFINED_OP2();
36687 if (UNEXPECTED(EG(exception) != NULL)) {
36688 HANDLE_EXCEPTION();
36689 }
36690 }
36691 zend_throw_error(NULL, "Method name must be a string");
36692
36693 HANDLE_EXCEPTION();
36694 } while (0);
36695 }
36696 }
36697
36698 if (ce->get_static_method) {
36699 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
36700 } else {
36701 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
36702 }
36703 if (UNEXPECTED(fbc == NULL)) {
36704 if (EXPECTED(!EG(exception))) {
36705 zend_undefined_method(ce, Z_STR_P(function_name));
36706 }
36707
36708 HANDLE_EXCEPTION();
36709 }
36710 if (IS_UNUSED == IS_CONST &&
36711 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
36712 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
36713 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
36714 }
36715 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
36716 init_func_run_time_cache(&fbc->op_array);
36717 }
36718 if (IS_UNUSED != IS_CONST) {
36719
36720 }
36721 } else {
36722 if (UNEXPECTED(ce->constructor == NULL)) {
36723 zend_throw_error(NULL, "Cannot call constructor");
36724 HANDLE_EXCEPTION();
36725 }
36726 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
36727 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
36728 HANDLE_EXCEPTION();
36729 }
36730 fbc = ce->constructor;
36731 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
36732 init_func_run_time_cache(&fbc->op_array);
36733 }
36734 }
36735
36736 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
36737 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
36738 ce = (zend_class_entry*)Z_OBJ(EX(This));
36739 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
36740 } else {
36741 zend_non_static_method_call(fbc);
36742 HANDLE_EXCEPTION();
36743 }
36744 } else {
36745 /* previous opcode is ZEND_FETCH_CLASS */
36746 if (IS_UNUSED == IS_UNUSED
36747 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
36748 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
36749 if (Z_TYPE(EX(This)) == IS_OBJECT) {
36750 ce = Z_OBJCE(EX(This));
36751 } else {
36752 ce = Z_CE(EX(This));
36753 }
36754 }
36755 call_info = ZEND_CALL_NESTED_FUNCTION;
36756 }
36757
36758 call = zend_vm_stack_push_call_frame(call_info,
36759 fbc, opline->extended_value, ce);
36760 call->prev_execute_data = EX(call);
36761 EX(call) = call;
36762
36763 ZEND_VM_NEXT_OPCODE();
36764 }
36765
ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36766 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36767 {
36768 if (IS_UNUSED == IS_UNUSED) {
36769 SAVE_OPLINE();
36770 zend_verify_missing_return_type(EX(func));
36771 HANDLE_EXCEPTION();
36772 } else {
36773 /* prevents "undefined variable opline" errors */
36774 #if 0 || (IS_UNUSED != IS_UNUSED)
36775 USE_OPLINE
36776 zval *retval_ref, *retval_ptr;
36777 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
36778 retval_ref = retval_ptr = NULL;
36779
36780 if (IS_UNUSED == IS_CONST) {
36781 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
36782 retval_ref = retval_ptr = EX_VAR(opline->result.var);
36783 } else if (IS_UNUSED == IS_VAR) {
36784 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
36785 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
36786 }
36787 ZVAL_DEREF(retval_ptr);
36788 } else if (IS_UNUSED == IS_CV) {
36789 ZVAL_DEREF(retval_ptr);
36790 }
36791
36792 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
36793 ZEND_VM_NEXT_OPCODE();
36794 }
36795
36796 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
36797 SAVE_OPLINE();
36798 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
36799 if (UNEXPECTED(EG(exception))) {
36800 HANDLE_EXCEPTION();
36801 }
36802 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
36803 ZEND_VM_NEXT_OPCODE();
36804 }
36805 }
36806
36807 zend_reference *ref = NULL;
36808 void *cache_slot = CACHE_ADDR(opline->op2.num);
36809 if (UNEXPECTED(retval_ref != retval_ptr)) {
36810 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
36811 ref = Z_REF_P(retval_ref);
36812 } else {
36813 /* A cast might happen - unwrap the reference if this is a by-value return */
36814 if (Z_REFCOUNT_P(retval_ref) == 1) {
36815 ZVAL_UNREF(retval_ref);
36816 } else {
36817 Z_DELREF_P(retval_ref);
36818 ZVAL_COPY(retval_ref, retval_ptr);
36819 }
36820 retval_ptr = retval_ref;
36821 }
36822 }
36823
36824 SAVE_OPLINE();
36825 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
36826 zend_verify_return_error(EX(func), retval_ptr);
36827 HANDLE_EXCEPTION();
36828 }
36829 ZEND_VM_NEXT_OPCODE();
36830 #endif
36831 }
36832 }
36833
ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36834 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36835 {
36836 SAVE_OPLINE();
36837 zend_verify_never_error(EX(func));
36838 HANDLE_EXCEPTION();
36839 }
36840
ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36841 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36842 {
36843 USE_OPLINE
36844 uint32_t arg_num;
36845
36846 if (IS_UNUSED == IS_CONST) {
36847 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
36848 arg_num = zend_get_arg_offset_by_name(
36849 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
36850 if (UNEXPECTED(arg_num == 0)) {
36851 /* Treat this as a by-value argument, and throw an error during SEND. */
36852 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36853 ZEND_VM_NEXT_OPCODE();
36854 }
36855 } else {
36856 arg_num = opline->op2.num;
36857 }
36858
36859 if (EXPECTED(0)) {
36860 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
36861 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36862 } else {
36863 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36864 }
36865 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
36866 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36867 } else {
36868 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36869 }
36870 ZEND_VM_NEXT_OPCODE();
36871 }
36872
ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36873 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36874 {
36875 USE_OPLINE
36876 uint32_t arg_num;
36877
36878 if (IS_UNUSED == IS_CONST) {
36879 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
36880 arg_num = zend_get_arg_offset_by_name(
36881 EX(call)->func, arg_name, CACHE_ADDR(opline->result.num)) + 1;
36882 if (UNEXPECTED(arg_num == 0)) {
36883 /* Treat this as a by-value argument, and throw an error during SEND. */
36884 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36885 ZEND_VM_NEXT_OPCODE();
36886 }
36887 } else {
36888 arg_num = opline->op2.num;
36889 }
36890
36891 if (EXPECTED(1)) {
36892 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
36893 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36894 } else {
36895 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36896 }
36897 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
36898 ZEND_ADD_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36899 } else {
36900 ZEND_DEL_CALL_FLAG(EX(call), ZEND_CALL_SEND_ARG_BY_REF);
36901 }
36902 ZEND_VM_NEXT_OPCODE();
36903 }
36904
ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36905 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36906 {
36907 USE_OPLINE
36908
36909 zend_execute_data *call = execute_data->call;
36910 if (EXPECTED(!(ZEND_CALL_INFO(call) & ZEND_CALL_MAY_HAVE_UNDEF))) {
36911 ZEND_VM_NEXT_OPCODE();
36912 }
36913
36914 SAVE_OPLINE();
36915 zend_handle_undef_args(call);
36916 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
36917 }
36918
ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36919 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36920 {
36921 USE_OPLINE
36922 zval *result;
36923 zend_function *constructor;
36924 zend_class_entry *ce;
36925 zend_execute_data *call;
36926
36927 SAVE_OPLINE();
36928 if (IS_UNUSED == IS_CONST) {
36929 ce = CACHED_PTR(opline->op2.num);
36930 if (UNEXPECTED(ce == NULL)) {
36931 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);
36932 if (UNEXPECTED(ce == NULL)) {
36933 ZVAL_UNDEF(EX_VAR(opline->result.var));
36934 HANDLE_EXCEPTION();
36935 }
36936 CACHE_PTR(opline->op2.num, ce);
36937 }
36938 } else if (IS_UNUSED == IS_UNUSED) {
36939 ce = zend_fetch_class(NULL, opline->op1.num);
36940 if (UNEXPECTED(ce == NULL)) {
36941 ZVAL_UNDEF(EX_VAR(opline->result.var));
36942 HANDLE_EXCEPTION();
36943 }
36944 } else {
36945 ce = Z_CE_P(EX_VAR(opline->op1.var));
36946 }
36947
36948 result = EX_VAR(opline->result.var);
36949 if (UNEXPECTED(object_init_ex(result, ce) != SUCCESS)) {
36950 ZVAL_UNDEF(result);
36951 HANDLE_EXCEPTION();
36952 }
36953
36954 constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result));
36955 if (constructor == NULL) {
36956 if (UNEXPECTED(EG(exception))) {
36957 HANDLE_EXCEPTION();
36958 }
36959
36960 /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next
36961 * opcode is DO_FCALL in case EXT instructions are used. */
36962 if (EXPECTED(opline->extended_value == 0 && (opline+1)->opcode == ZEND_DO_FCALL)) {
36963 ZEND_VM_NEXT_OPCODE_EX(1, 2);
36964 }
36965
36966 /* Perform a dummy function call */
36967 call = zend_vm_stack_push_call_frame(
36968 ZEND_CALL_FUNCTION, (zend_function *) &zend_pass_function,
36969 opline->extended_value, NULL);
36970 } else {
36971 if (EXPECTED(constructor->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&constructor->op_array))) {
36972 init_func_run_time_cache(&constructor->op_array);
36973 }
36974 /* We are not handling overloaded classes right now */
36975 call = zend_vm_stack_push_call_frame(
36976 ZEND_CALL_FUNCTION | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_THIS,
36977 constructor,
36978 opline->extended_value,
36979 Z_OBJ_P(result));
36980 Z_ADDREF_P(result);
36981 }
36982
36983 call->prev_execute_data = EX(call);
36984 EX(call) = call;
36985 ZEND_VM_NEXT_OPCODE();
36986 }
36987
ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)36988 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
36989 {
36990 zval *array;
36991 uint32_t size;
36992 USE_OPLINE
36993
36994 array = EX_VAR(opline->result.var);
36995 if (IS_UNUSED != IS_UNUSED) {
36996 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
36997 ZVAL_ARR(array, zend_new_array(size));
36998 /* Explicitly initialize array as not-packed if flag is set */
36999 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
37000 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
37001 }
37002 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37003 } else {
37004 ZVAL_ARR(array, zend_new_array(0));
37005 ZEND_VM_NEXT_OPCODE();
37006 }
37007 }
37008
ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37009 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37010 {
37011 USE_OPLINE
37012
37013 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
37014
37015 SAVE_OPLINE();
37016 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
37017 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37018 }
37019
37020 /* Destroy the previously yielded value */
37021 zval_ptr_dtor(&generator->value);
37022
37023 /* Destroy the previously yielded key */
37024 zval_ptr_dtor(&generator->key);
37025
37026 /* Set the new yielded value */
37027 if (IS_UNUSED != IS_UNUSED) {
37028 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
37029 /* Constants and temporary variables aren't yieldable by reference,
37030 * but we still allow them with a notice. */
37031 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
37032 zval *value;
37033
37034 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37035
37036 value = NULL;
37037 ZVAL_COPY_VALUE(&generator->value, value);
37038 if (IS_UNUSED == IS_CONST) {
37039 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37040 Z_ADDREF(generator->value);
37041 }
37042 }
37043 } else {
37044 zval *value_ptr = NULL;
37045
37046 /* If a function call result is yielded and the function did
37047 * not return by reference we throw a notice. */
37048 do {
37049 if (IS_UNUSED == IS_VAR) {
37050 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
37051 if (opline->extended_value == ZEND_RETURNS_FUNCTION
37052 && !Z_ISREF_P(value_ptr)) {
37053 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
37054 ZVAL_COPY(&generator->value, value_ptr);
37055 break;
37056 }
37057 }
37058 if (Z_ISREF_P(value_ptr)) {
37059 Z_ADDREF_P(value_ptr);
37060 } else {
37061 ZVAL_MAKE_REF_EX(value_ptr, 2);
37062 }
37063 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
37064 } while (0);
37065
37066 }
37067 } else {
37068 zval *value = NULL;
37069
37070 /* Consts, temporary variables and references need copying */
37071 if (IS_UNUSED == IS_CONST) {
37072 ZVAL_COPY_VALUE(&generator->value, value);
37073 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
37074 Z_ADDREF(generator->value);
37075 }
37076 } else if (IS_UNUSED == IS_TMP_VAR) {
37077 ZVAL_COPY_VALUE(&generator->value, value);
37078 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
37079 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
37080
37081 } else {
37082 ZVAL_COPY_VALUE(&generator->value, value);
37083 if (IS_UNUSED == IS_CV) {
37084 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
37085 }
37086 }
37087 }
37088 } else {
37089 /* If no value was specified yield null */
37090 ZVAL_NULL(&generator->value);
37091 }
37092
37093 /* Set the new yielded key */
37094 if (IS_UNUSED != IS_UNUSED) {
37095 zval *key = NULL;
37096 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
37097 key = Z_REFVAL_P(key);
37098 }
37099 ZVAL_COPY(&generator->key, key);
37100
37101 if (Z_TYPE(generator->key) == IS_LONG
37102 && Z_LVAL(generator->key) > generator->largest_used_integer_key
37103 ) {
37104 generator->largest_used_integer_key = Z_LVAL(generator->key);
37105 }
37106 } else {
37107 /* If no key was specified we use auto-increment keys */
37108 generator->largest_used_integer_key++;
37109 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
37110 }
37111
37112 if (RETURN_VALUE_USED(opline)) {
37113 /* If the return value of yield is used set the send
37114 * target and initialize it to NULL */
37115 generator->send_target = EX_VAR(opline->result.var);
37116 ZVAL_NULL(generator->send_target);
37117 } else {
37118 generator->send_target = NULL;
37119 }
37120
37121 /* We increment to the next op, so we are at the correct position when the
37122 * generator is resumed. */
37123 ZEND_VM_INC_OPCODE();
37124
37125 /* The GOTO VM uses a local opline variable. We need to set the opline
37126 * variable in execute_data so we don't resume at an old position. */
37127 SAVE_OPLINE();
37128
37129 ZEND_VM_RETURN();
37130 }
37131
ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37132 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37133 {
37134 USE_OPLINE
37135
37136 if (EXPECTED(Z_TYPE(EX(This)) == IS_OBJECT)) {
37137 zval *result = EX_VAR(opline->result.var);
37138
37139 ZVAL_OBJ(result, Z_OBJ(EX(This)));
37140 Z_ADDREF_P(result);
37141 ZEND_VM_NEXT_OPCODE();
37142 } else {
37143 ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37144 }
37145 }
37146
ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37147 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37148 {
37149 USE_OPLINE
37150
37151 /* For symbol tables we need to deal with exactly the same problems as for property tables. */
37152 ZVAL_ARR(EX_VAR(opline->result.var),
37153 zend_proptable_to_symtable(&EG(symbol_table), /* always_duplicate */ 1));
37154 ZEND_VM_NEXT_OPCODE();
37155 }
37156
ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37157 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37158 {
37159 USE_OPLINE
37160
37161 ZVAL_BOOL(EX_VAR(opline->result.var),
37162 (opline->extended_value & ZEND_ISEMPTY) ^
37163 (Z_TYPE(EX(This)) == IS_OBJECT));
37164 ZEND_VM_NEXT_OPCODE();
37165 }
37166
ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37167 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37168 {
37169 USE_OPLINE
37170
37171 if (IS_UNUSED == IS_UNUSED) {
37172 SAVE_OPLINE();
37173 if (UNEXPECTED(!EX(func)->common.scope)) {
37174 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
37175 ZVAL_UNDEF(EX_VAR(opline->result.var));
37176 HANDLE_EXCEPTION();
37177 } else {
37178 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
37179 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
37180 if (UNEXPECTED(EG(exception))) {
37181 HANDLE_EXCEPTION();
37182 }
37183 ZEND_VM_NEXT_OPCODE();
37184 }
37185 } else {
37186 zval *op1;
37187
37188 SAVE_OPLINE();
37189 op1 = NULL;
37190 while (1) {
37191 if (Z_TYPE_P(op1) == IS_OBJECT) {
37192 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
37193 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
37194 op1 = Z_REFVAL_P(op1);
37195 continue;
37196 } else {
37197 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
37198 ZVAL_UNDEFINED_OP1();
37199 }
37200 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
37201 ZVAL_UNDEF(EX_VAR(opline->result.var));
37202 }
37203 break;
37204 }
37205
37206 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37207 }
37208 }
37209
ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37210 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37211 {
37212 USE_OPLINE
37213
37214 if (Z_TYPE(EX(This)) == IS_OBJECT) {
37215 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE(EX(This))->name);
37216 } else if (Z_CE(EX(This))) {
37217 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_CE(EX(This))->name);
37218 } else {
37219 ZEND_ASSERT(!EX(func)->common.scope);
37220 SAVE_OPLINE();
37221 zend_throw_error(NULL, "get_called_class() must be called from within a class");
37222 ZVAL_UNDEF(EX_VAR(opline->result.var));
37223 HANDLE_EXCEPTION();
37224 }
37225 ZEND_VM_NEXT_OPCODE();
37226 }
37227
ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37228 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37229 {
37230 USE_OPLINE
37231
37232 ZVAL_LONG(EX_VAR(opline->result.var), EX_NUM_ARGS());
37233 ZEND_VM_NEXT_OPCODE();
37234 }
37235
ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37236 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37237 {
37238 USE_OPLINE
37239 zend_array *ht;
37240 uint32_t arg_count, result_size, skip;
37241
37242 arg_count = EX_NUM_ARGS();
37243 if (IS_UNUSED == IS_CONST) {
37244 skip = Z_LVAL_P(RT_CONSTANT(opline, opline->op1));
37245 if (arg_count < skip) {
37246 result_size = 0;
37247 } else {
37248 result_size = arg_count - skip;
37249 }
37250 } else {
37251 skip = 0;
37252 result_size = arg_count;
37253 }
37254
37255 if (result_size) {
37256 SAVE_OPLINE();
37257 uint32_t first_extra_arg = EX(func)->op_array.num_args;
37258
37259 ht = zend_new_array(result_size);
37260 ZVAL_ARR(EX_VAR(opline->result.var), ht);
37261 zend_hash_real_init_packed(ht);
37262 ZEND_HASH_FILL_PACKED(ht) {
37263 zval *p, *q;
37264 uint32_t i = skip;
37265 p = EX_VAR_NUM(i);
37266 if (arg_count > first_extra_arg) {
37267 while (i < first_extra_arg) {
37268 q = p;
37269 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
37270 ZVAL_DEREF(q);
37271 if (Z_OPT_REFCOUNTED_P(q)) {
37272 Z_ADDREF_P(q);
37273 }
37274 ZEND_HASH_FILL_SET(q);
37275 } else {
37276 ZEND_HASH_FILL_SET_NULL();
37277 }
37278 ZEND_HASH_FILL_NEXT();
37279 p++;
37280 i++;
37281 }
37282 if (skip < first_extra_arg) {
37283 skip = 0;
37284 } else {
37285 skip -= first_extra_arg;
37286 }
37287 p = EX_VAR_NUM(EX(func)->op_array.last_var + EX(func)->op_array.T + skip);
37288 }
37289 while (i < arg_count) {
37290 q = p;
37291 if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) {
37292 ZVAL_DEREF(q);
37293 if (Z_OPT_REFCOUNTED_P(q)) {
37294 Z_ADDREF_P(q);
37295 }
37296 ZEND_HASH_FILL_SET(q);
37297 } else {
37298 ZEND_HASH_FILL_SET_NULL();
37299 }
37300 ZEND_HASH_FILL_NEXT();
37301 p++;
37302 i++;
37303 }
37304 } ZEND_HASH_FILL_END();
37305 ht->nNumOfElements = result_size;
37306 } else {
37307 ZVAL_EMPTY_ARRAY(EX_VAR(opline->result.var));
37308 }
37309 ZEND_VM_NEXT_OPCODE();
37310 }
37311
37312 /* 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)37313 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37314 {
37315 USE_OPLINE
37316 zend_execute_data *call = EX(call);
37317
37318 zend_closure_from_frame(EX_VAR(opline->result.var), call);
37319
37320 if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) {
37321 OBJ_RELEASE(Z_OBJ(call->This));
37322 }
37323
37324 EX(call) = call->prev_execute_data;
37325
37326 zend_vm_stack_free_call_frame(call);
37327
37328 ZEND_VM_NEXT_OPCODE();
37329 }
37330
ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37331 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37332 {
37333 USE_OPLINE
37334 SAVE_OPLINE();
37335 zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline);
37336 ZVAL_NULL(EX_VAR(opline->result.var));
37337 function(EX_VAR(opline->result.var));
37338 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37339 }
37340
ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37341 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37342 {
37343 USE_OPLINE
37344 zval *object;
37345 zval *property;
37346 zval *value;
37347 zval *zptr;
37348 void **cache_slot;
37349 zend_property_info *prop_info;
37350 zend_object *zobj;
37351 zend_string *name, *tmp_name;
37352
37353 SAVE_OPLINE();
37354 object = &EX(This);
37355 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37356
37357 do {
37358 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
37359
37360 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
37361 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
37362 object = Z_REFVAL_P(object);
37363 goto assign_op_object;
37364 }
37365 if (IS_UNUSED == IS_CV
37366 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
37367 ZVAL_UNDEFINED_OP1();
37368 }
37369 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
37370 break;
37371 }
37372
37373 assign_op_object:
37374 /* here we are sure we are dealing with an object */
37375 zobj = Z_OBJ_P(object);
37376 if (IS_CV == IS_CONST) {
37377 name = Z_STR_P(property);
37378 } else {
37379 name = zval_try_get_tmp_string(property, &tmp_name);
37380 if (UNEXPECTED(!name)) {
37381 UNDEF_RESULT();
37382 break;
37383 }
37384 }
37385 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
37386 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
37387 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
37388 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
37389 ZVAL_NULL(EX_VAR(opline->result.var));
37390 }
37391 } else {
37392 zval *orig_zptr = zptr;
37393 zend_reference *ref;
37394
37395 do {
37396 if (UNEXPECTED(Z_ISREF_P(zptr))) {
37397 ref = Z_REF_P(zptr);
37398 zptr = Z_REFVAL_P(zptr);
37399 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
37400 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
37401 break;
37402 }
37403 }
37404
37405 if (IS_CV == IS_CONST) {
37406 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
37407 } else {
37408 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
37409 }
37410 if (prop_info) {
37411 /* special case for typed properties */
37412 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
37413 } else {
37414 zend_binary_op(zptr, zptr, value OPLINE_CC);
37415 }
37416 } while (0);
37417
37418 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
37419 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
37420 }
37421 }
37422 } else {
37423 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
37424 }
37425 if (IS_CV != IS_CONST) {
37426 zend_tmp_string_release(tmp_name);
37427 }
37428 } while (0);
37429
37430 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
37431
37432
37433 /* assign_obj has two opcodes! */
37434 ZEND_VM_NEXT_OPCODE_EX(1, 2);
37435 }
37436
37437 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37438 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37439 {
37440 USE_OPLINE
37441 zval *object;
37442 zval *property;
37443 zval *zptr;
37444 void **cache_slot;
37445 zend_property_info *prop_info;
37446 zend_object *zobj;
37447 zend_string *name, *tmp_name;
37448
37449 SAVE_OPLINE();
37450 object = &EX(This);
37451 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37452
37453 do {
37454 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
37455 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
37456 object = Z_REFVAL_P(object);
37457 goto pre_incdec_object;
37458 }
37459 if (IS_UNUSED == IS_CV
37460 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
37461 ZVAL_UNDEFINED_OP1();
37462 }
37463 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
37464 break;
37465 }
37466
37467 pre_incdec_object:
37468 /* here we are sure we are dealing with an object */
37469 zobj = Z_OBJ_P(object);
37470 if (IS_CV == IS_CONST) {
37471 name = Z_STR_P(property);
37472 } else {
37473 name = zval_try_get_tmp_string(property, &tmp_name);
37474 if (UNEXPECTED(!name)) {
37475 UNDEF_RESULT();
37476 break;
37477 }
37478 }
37479 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
37480 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
37481 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
37482 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
37483 ZVAL_NULL(EX_VAR(opline->result.var));
37484 }
37485 } else {
37486 if (IS_CV == IS_CONST) {
37487 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
37488 } else {
37489 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
37490 }
37491 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
37492 }
37493 } else {
37494 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
37495 }
37496 if (IS_CV != IS_CONST) {
37497 zend_tmp_string_release(tmp_name);
37498 }
37499 } while (0);
37500
37501
37502 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37503 }
37504
ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37505 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37506 {
37507 USE_OPLINE
37508 zval *object;
37509 zval *property;
37510 zval *zptr;
37511 void **cache_slot;
37512 zend_property_info *prop_info;
37513 zend_object *zobj;
37514 zend_string *name, *tmp_name;
37515
37516 SAVE_OPLINE();
37517 object = &EX(This);
37518 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37519
37520 do {
37521 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
37522 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
37523 object = Z_REFVAL_P(object);
37524 goto post_incdec_object;
37525 }
37526 if (IS_UNUSED == IS_CV
37527 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
37528 ZVAL_UNDEFINED_OP1();
37529 }
37530 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
37531 break;
37532 }
37533
37534 post_incdec_object:
37535 /* here we are sure we are dealing with an object */
37536 zobj = Z_OBJ_P(object);
37537 if (IS_CV == IS_CONST) {
37538 name = Z_STR_P(property);
37539 } else {
37540 name = zval_try_get_tmp_string(property, &tmp_name);
37541 if (UNEXPECTED(!name)) {
37542 ZVAL_UNDEF(EX_VAR(opline->result.var));
37543 break;
37544 }
37545 }
37546 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
37547 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
37548 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
37549 ZVAL_NULL(EX_VAR(opline->result.var));
37550 } else {
37551 if (IS_CV == IS_CONST) {
37552 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
37553 } else {
37554 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
37555 }
37556
37557 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
37558 }
37559 } else {
37560 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
37561 }
37562 if (IS_CV != IS_CONST) {
37563 zend_tmp_string_release(tmp_name);
37564 }
37565 } while (0);
37566
37567
37568 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37569 }
37570
ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37571 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37572 {
37573 USE_OPLINE
37574 zval *container;
37575 void **cache_slot = NULL;
37576
37577 SAVE_OPLINE();
37578 container = &EX(This);
37579
37580 if (IS_UNUSED == IS_CONST ||
37581 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
37582 do {
37583 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
37584 container = Z_REFVAL_P(container);
37585 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
37586 break;
37587 }
37588 }
37589 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
37590 ZVAL_UNDEFINED_OP1();
37591 }
37592 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37593 ZVAL_NULL(EX_VAR(opline->result.var));
37594 goto fetch_obj_r_finish;
37595 } while (0);
37596 }
37597
37598 /* here we are sure we are dealing with an object */
37599 do {
37600 zend_object *zobj = Z_OBJ_P(container);
37601 zend_string *name, *tmp_name;
37602 zval *retval;
37603
37604 if (IS_CV == IS_CONST) {
37605 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
37606
37607 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
37608 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
37609
37610 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
37611 retval = OBJ_PROP(zobj, prop_offset);
37612 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
37613 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37614 goto fetch_obj_r_copy;
37615 } else {
37616 fetch_obj_r_fast_copy:
37617 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
37618 ZEND_VM_NEXT_OPCODE();
37619 }
37620 }
37621 } else if (EXPECTED(zobj->properties != NULL)) {
37622 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37623 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
37624 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
37625
37626 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
37627 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
37628
37629 if (EXPECTED(p->key == name) ||
37630 (EXPECTED(p->h == ZSTR_H(name)) &&
37631 EXPECTED(p->key != NULL) &&
37632 EXPECTED(zend_string_equal_content(p->key, name)))) {
37633 retval = &p->val;
37634 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37635 goto fetch_obj_r_copy;
37636 } else {
37637 goto fetch_obj_r_fast_copy;
37638 }
37639 }
37640 }
37641 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
37642 }
37643 retval = zend_hash_find_known_hash(zobj->properties, name);
37644 if (EXPECTED(retval)) {
37645 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
37646 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
37647 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37648 goto fetch_obj_r_copy;
37649 } else {
37650 goto fetch_obj_r_fast_copy;
37651 }
37652 }
37653 }
37654 }
37655 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37656 } else {
37657 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
37658 if (UNEXPECTED(!name)) {
37659 ZVAL_UNDEF(EX_VAR(opline->result.var));
37660 break;
37661 }
37662 }
37663
37664 #if ZEND_DEBUG
37665 /* For non-standard object handlers, verify a declared property type in debug builds.
37666 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
37667 zend_property_info *prop_info = NULL;
37668 if (zobj->handlers->read_property != zend_std_read_property) {
37669 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
37670 }
37671 #endif
37672 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
37673 #if ZEND_DEBUG
37674 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
37675 && ZEND_TYPE_IS_SET(prop_info->type)) {
37676 ZVAL_OPT_DEREF(retval);
37677 zend_verify_property_type(prop_info, retval, /* strict */ true);
37678 }
37679 #endif
37680
37681 if (IS_CV != IS_CONST) {
37682 zend_tmp_string_release(tmp_name);
37683 }
37684
37685 if (retval != EX_VAR(opline->result.var)) {
37686 fetch_obj_r_copy:
37687 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
37688 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
37689 zend_unwrap_reference(retval);
37690 }
37691 } while (0);
37692
37693 fetch_obj_r_finish:
37694
37695
37696 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37697 }
37698
ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37699 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37700 {
37701 USE_OPLINE
37702 zval *property, *container, *result;
37703
37704 SAVE_OPLINE();
37705
37706 container = &EX(This);
37707 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37708 result = EX_VAR(opline->result.var);
37709 zend_fetch_property_address(
37710 result, container, IS_UNUSED, property, IS_CV,
37711 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
37712 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
37713
37714 if (IS_UNUSED == IS_VAR) {
37715 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
37716 }
37717 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37718 }
37719
ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37720 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37721 {
37722 USE_OPLINE
37723 zval *property, *container, *result;
37724
37725 SAVE_OPLINE();
37726 container = &EX(This);
37727 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37728 result = EX_VAR(opline->result.var);
37729 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 OPLINE_CC EXECUTE_DATA_CC);
37730
37731 if (IS_UNUSED == IS_VAR) {
37732 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
37733 }
37734 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37735 }
37736
ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37737 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37738 {
37739 USE_OPLINE
37740 zval *container;
37741 void **cache_slot = NULL;
37742
37743 SAVE_OPLINE();
37744 container = &EX(This);
37745
37746 if (IS_UNUSED == IS_CONST ||
37747 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
37748 do {
37749 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
37750 container = Z_REFVAL_P(container);
37751 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
37752 break;
37753 }
37754 }
37755 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
37756 ZVAL_UNDEFINED_OP2();
37757 }
37758 ZVAL_NULL(EX_VAR(opline->result.var));
37759 goto fetch_obj_is_finish;
37760 } while (0);
37761 }
37762
37763 /* here we are sure we are dealing with an object */
37764 do {
37765 zend_object *zobj = Z_OBJ_P(container);
37766 zend_string *name, *tmp_name;
37767 zval *retval;
37768
37769 if (IS_CV == IS_CONST) {
37770 cache_slot = CACHE_ADDR(opline->extended_value);
37771
37772 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
37773 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
37774
37775 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
37776 retval = OBJ_PROP(zobj, prop_offset);
37777 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
37778 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37779 goto fetch_obj_is_copy;
37780 } else {
37781 fetch_obj_is_fast_copy:
37782 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
37783 ZEND_VM_NEXT_OPCODE();
37784 }
37785 }
37786 } else if (EXPECTED(zobj->properties != NULL)) {
37787 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37788 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
37789 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
37790
37791 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
37792 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
37793
37794 if (EXPECTED(p->key == name) ||
37795 (EXPECTED(p->h == ZSTR_H(name)) &&
37796 EXPECTED(p->key != NULL) &&
37797 EXPECTED(zend_string_equal_content(p->key, name)))) {
37798 retval = &p->val;
37799 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37800 goto fetch_obj_is_copy;
37801 } else {
37802 goto fetch_obj_is_fast_copy;
37803 }
37804 }
37805 }
37806 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
37807 }
37808 retval = zend_hash_find_known_hash(zobj->properties, name);
37809 if (EXPECTED(retval)) {
37810 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
37811 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
37812 if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
37813 goto fetch_obj_is_copy;
37814 } else {
37815 goto fetch_obj_is_fast_copy;
37816 }
37817 }
37818 }
37819 }
37820 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37821 } else {
37822 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
37823 if (UNEXPECTED(!name)) {
37824 ZVAL_UNDEF(EX_VAR(opline->result.var));
37825 break;
37826 }
37827 }
37828
37829 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
37830
37831 if (IS_CV != IS_CONST) {
37832 zend_tmp_string_release(tmp_name);
37833 }
37834
37835 if (retval != EX_VAR(opline->result.var)) {
37836 fetch_obj_is_copy:
37837 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
37838 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
37839 zend_unwrap_reference(retval);
37840 }
37841 } while (0);
37842
37843 fetch_obj_is_finish:
37844
37845
37846 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37847 }
37848
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37849 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37850 {
37851 #if 0
37852 USE_OPLINE
37853 #endif
37854
37855 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
37856 /* Behave like FETCH_OBJ_W */
37857 if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
37858 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37859 }
37860 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37861 } else {
37862 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
37863 }
37864 }
37865
ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37866 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37867 {
37868 USE_OPLINE
37869 zval *container, *property, *result;
37870
37871 SAVE_OPLINE();
37872 container = &EX(This);
37873 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
37874 result = EX_VAR(opline->result.var);
37875 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 OPLINE_CC EXECUTE_DATA_CC);
37876
37877 if (IS_UNUSED == IS_VAR) {
37878 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
37879 }
37880 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
37881 }
37882
ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)37883 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
37884 {
37885 USE_OPLINE
37886 zval *object, *value, tmp;
37887 zend_object *zobj;
37888 zend_string *name, *tmp_name;
37889 zend_refcounted *garbage = NULL;
37890
37891 SAVE_OPLINE();
37892 object = &EX(This);
37893 value = RT_CONSTANT((opline+1), (opline+1)->op1);
37894
37895 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
37896 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
37897 object = Z_REFVAL_P(object);
37898 goto assign_object;
37899 }
37900 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
37901 value = &EG(uninitialized_zval);
37902 goto free_and_exit_assign_obj;
37903 }
37904
37905 assign_object:
37906 zobj = Z_OBJ_P(object);
37907 if (IS_CV == IS_CONST) {
37908 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
37909 void **cache_slot = CACHE_ADDR(opline->extended_value);
37910 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
37911 zval *property_val;
37912
37913 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
37914 property_val = OBJ_PROP(zobj, prop_offset);
37915 if (Z_TYPE_P(property_val) != IS_UNDEF) {
37916 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
37917
37918 if (prop_info != NULL) {
37919 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
37920 goto free_and_exit_assign_obj;
37921 } else {
37922 fast_assign_obj:
37923 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
37924 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
37925 ZVAL_COPY(EX_VAR(opline->result.var), value);
37926 }
37927 goto exit_assign_obj;
37928 }
37929 }
37930 } else {
37931 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37932 if (EXPECTED(zobj->properties != NULL)) {
37933 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
37934 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
37935 GC_DELREF(zobj->properties);
37936 }
37937 zobj->properties = zend_array_dup(zobj->properties);
37938 }
37939 property_val = zend_hash_find_known_hash(zobj->properties, name);
37940 if (property_val) {
37941 goto fast_assign_obj;
37942 }
37943 }
37944
37945 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
37946 if (EXPECTED(zobj->properties == NULL)) {
37947 rebuild_object_properties(zobj);
37948 }
37949 if (IS_CONST == IS_CONST) {
37950 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
37951 Z_ADDREF_P(value);
37952 }
37953 } else if (IS_CONST != IS_TMP_VAR) {
37954 if (Z_ISREF_P(value)) {
37955 if (IS_CONST == IS_VAR) {
37956 zend_reference *ref = Z_REF_P(value);
37957 if (GC_DELREF(ref) == 0) {
37958 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
37959 efree_size(ref, sizeof(zend_reference));
37960 value = &tmp;
37961 } else {
37962 value = Z_REFVAL_P(value);
37963 Z_TRY_ADDREF_P(value);
37964 }
37965 } else {
37966 value = Z_REFVAL_P(value);
37967 Z_TRY_ADDREF_P(value);
37968 }
37969 } else if (IS_CONST == IS_CV) {
37970 Z_TRY_ADDREF_P(value);
37971 }
37972 }
37973 zend_hash_add_new(zobj->properties, name, value);
37974 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
37975 ZVAL_COPY(EX_VAR(opline->result.var), value);
37976 }
37977 goto exit_assign_obj;
37978 }
37979 }
37980 }
37981 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
37982 } else {
37983 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
37984 if (UNEXPECTED(!name)) {
37985
37986 UNDEF_RESULT();
37987 goto exit_assign_obj;
37988 }
37989 }
37990
37991 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
37992 ZVAL_DEREF(value);
37993 }
37994
37995 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
37996
37997 if (IS_CV != IS_CONST) {
37998 zend_tmp_string_release(tmp_name);
37999 }
38000
38001 free_and_exit_assign_obj:
38002 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
38003 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
38004 }
38005
38006 exit_assign_obj:
38007 if (garbage) {
38008 GC_DTOR_NO_REF(garbage);
38009 }
38010
38011
38012 /* assign_obj has two opcodes! */
38013 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38014 }
38015
38016 /* 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)38017 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38018 {
38019 USE_OPLINE
38020 zval *object, *value, tmp;
38021 zend_object *zobj;
38022 zend_string *name, *tmp_name;
38023 zend_refcounted *garbage = NULL;
38024
38025 SAVE_OPLINE();
38026 object = &EX(This);
38027 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
38028
38029 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38030 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38031 object = Z_REFVAL_P(object);
38032 goto assign_object;
38033 }
38034 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
38035 value = &EG(uninitialized_zval);
38036 goto free_and_exit_assign_obj;
38037 }
38038
38039 assign_object:
38040 zobj = Z_OBJ_P(object);
38041 if (IS_CV == IS_CONST) {
38042 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
38043 void **cache_slot = CACHE_ADDR(opline->extended_value);
38044 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38045 zval *property_val;
38046
38047 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38048 property_val = OBJ_PROP(zobj, prop_offset);
38049 if (Z_TYPE_P(property_val) != IS_UNDEF) {
38050 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
38051
38052 if (prop_info != NULL) {
38053 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
38054 goto free_and_exit_assign_obj;
38055 } else {
38056 fast_assign_obj:
38057 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
38058 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38059 ZVAL_COPY(EX_VAR(opline->result.var), value);
38060 }
38061 goto exit_assign_obj;
38062 }
38063 }
38064 } else {
38065 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38066 if (EXPECTED(zobj->properties != NULL)) {
38067 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
38068 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
38069 GC_DELREF(zobj->properties);
38070 }
38071 zobj->properties = zend_array_dup(zobj->properties);
38072 }
38073 property_val = zend_hash_find_known_hash(zobj->properties, name);
38074 if (property_val) {
38075 goto fast_assign_obj;
38076 }
38077 }
38078
38079 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
38080 if (EXPECTED(zobj->properties == NULL)) {
38081 rebuild_object_properties(zobj);
38082 }
38083 if (IS_TMP_VAR == IS_CONST) {
38084 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
38085 Z_ADDREF_P(value);
38086 }
38087 } else if (IS_TMP_VAR != IS_TMP_VAR) {
38088 if (Z_ISREF_P(value)) {
38089 if (IS_TMP_VAR == IS_VAR) {
38090 zend_reference *ref = Z_REF_P(value);
38091 if (GC_DELREF(ref) == 0) {
38092 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
38093 efree_size(ref, sizeof(zend_reference));
38094 value = &tmp;
38095 } else {
38096 value = Z_REFVAL_P(value);
38097 Z_TRY_ADDREF_P(value);
38098 }
38099 } else {
38100 value = Z_REFVAL_P(value);
38101 Z_TRY_ADDREF_P(value);
38102 }
38103 } else if (IS_TMP_VAR == IS_CV) {
38104 Z_TRY_ADDREF_P(value);
38105 }
38106 }
38107 zend_hash_add_new(zobj->properties, name, value);
38108 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38109 ZVAL_COPY(EX_VAR(opline->result.var), value);
38110 }
38111 goto exit_assign_obj;
38112 }
38113 }
38114 }
38115 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38116 } else {
38117 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38118 if (UNEXPECTED(!name)) {
38119 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
38120 UNDEF_RESULT();
38121 goto exit_assign_obj;
38122 }
38123 }
38124
38125 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
38126 ZVAL_DEREF(value);
38127 }
38128
38129 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
38130
38131 if (IS_CV != IS_CONST) {
38132 zend_tmp_string_release(tmp_name);
38133 }
38134
38135 free_and_exit_assign_obj:
38136 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
38137 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
38138 }
38139 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
38140 exit_assign_obj:
38141 if (garbage) {
38142 GC_DTOR_NO_REF(garbage);
38143 }
38144
38145
38146 /* assign_obj has two opcodes! */
38147 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38148 }
38149
38150 /* 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)38151 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38152 {
38153 USE_OPLINE
38154 zval *object, *value, tmp;
38155 zend_object *zobj;
38156 zend_string *name, *tmp_name;
38157 zend_refcounted *garbage = NULL;
38158
38159 SAVE_OPLINE();
38160 object = &EX(This);
38161 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
38162
38163 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38164 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38165 object = Z_REFVAL_P(object);
38166 goto assign_object;
38167 }
38168 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
38169 value = &EG(uninitialized_zval);
38170 goto free_and_exit_assign_obj;
38171 }
38172
38173 assign_object:
38174 zobj = Z_OBJ_P(object);
38175 if (IS_CV == IS_CONST) {
38176 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
38177 void **cache_slot = CACHE_ADDR(opline->extended_value);
38178 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38179 zval *property_val;
38180
38181 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38182 property_val = OBJ_PROP(zobj, prop_offset);
38183 if (Z_TYPE_P(property_val) != IS_UNDEF) {
38184 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
38185
38186 if (prop_info != NULL) {
38187 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
38188 goto free_and_exit_assign_obj;
38189 } else {
38190 fast_assign_obj:
38191 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
38192 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38193 ZVAL_COPY(EX_VAR(opline->result.var), value);
38194 }
38195 goto exit_assign_obj;
38196 }
38197 }
38198 } else {
38199 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38200 if (EXPECTED(zobj->properties != NULL)) {
38201 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
38202 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
38203 GC_DELREF(zobj->properties);
38204 }
38205 zobj->properties = zend_array_dup(zobj->properties);
38206 }
38207 property_val = zend_hash_find_known_hash(zobj->properties, name);
38208 if (property_val) {
38209 goto fast_assign_obj;
38210 }
38211 }
38212
38213 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
38214 if (EXPECTED(zobj->properties == NULL)) {
38215 rebuild_object_properties(zobj);
38216 }
38217 if (IS_VAR == IS_CONST) {
38218 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
38219 Z_ADDREF_P(value);
38220 }
38221 } else if (IS_VAR != IS_TMP_VAR) {
38222 if (Z_ISREF_P(value)) {
38223 if (IS_VAR == IS_VAR) {
38224 zend_reference *ref = Z_REF_P(value);
38225 if (GC_DELREF(ref) == 0) {
38226 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
38227 efree_size(ref, sizeof(zend_reference));
38228 value = &tmp;
38229 } else {
38230 value = Z_REFVAL_P(value);
38231 Z_TRY_ADDREF_P(value);
38232 }
38233 } else {
38234 value = Z_REFVAL_P(value);
38235 Z_TRY_ADDREF_P(value);
38236 }
38237 } else if (IS_VAR == IS_CV) {
38238 Z_TRY_ADDREF_P(value);
38239 }
38240 }
38241 zend_hash_add_new(zobj->properties, name, value);
38242 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38243 ZVAL_COPY(EX_VAR(opline->result.var), value);
38244 }
38245 goto exit_assign_obj;
38246 }
38247 }
38248 }
38249 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38250 } else {
38251 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38252 if (UNEXPECTED(!name)) {
38253 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
38254 UNDEF_RESULT();
38255 goto exit_assign_obj;
38256 }
38257 }
38258
38259 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
38260 ZVAL_DEREF(value);
38261 }
38262
38263 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
38264
38265 if (IS_CV != IS_CONST) {
38266 zend_tmp_string_release(tmp_name);
38267 }
38268
38269 free_and_exit_assign_obj:
38270 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
38271 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
38272 }
38273 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
38274 exit_assign_obj:
38275 if (garbage) {
38276 GC_DTOR_NO_REF(garbage);
38277 }
38278
38279
38280 /* assign_obj has two opcodes! */
38281 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38282 }
38283
38284 /* 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)38285 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38286 {
38287 USE_OPLINE
38288 zval *object, *value, tmp;
38289 zend_object *zobj;
38290 zend_string *name, *tmp_name;
38291 zend_refcounted *garbage = NULL;
38292
38293 SAVE_OPLINE();
38294 object = &EX(This);
38295 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
38296
38297 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
38298 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
38299 object = Z_REFVAL_P(object);
38300 goto assign_object;
38301 }
38302 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
38303 value = &EG(uninitialized_zval);
38304 goto free_and_exit_assign_obj;
38305 }
38306
38307 assign_object:
38308 zobj = Z_OBJ_P(object);
38309 if (IS_CV == IS_CONST) {
38310 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
38311 void **cache_slot = CACHE_ADDR(opline->extended_value);
38312 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
38313 zval *property_val;
38314
38315 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
38316 property_val = OBJ_PROP(zobj, prop_offset);
38317 if (Z_TYPE_P(property_val) != IS_UNDEF) {
38318 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
38319
38320 if (prop_info != NULL) {
38321 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
38322 goto free_and_exit_assign_obj;
38323 } else {
38324 fast_assign_obj:
38325 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
38326 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38327 ZVAL_COPY(EX_VAR(opline->result.var), value);
38328 }
38329 goto exit_assign_obj;
38330 }
38331 }
38332 } else {
38333 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38334 if (EXPECTED(zobj->properties != NULL)) {
38335 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
38336 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
38337 GC_DELREF(zobj->properties);
38338 }
38339 zobj->properties = zend_array_dup(zobj->properties);
38340 }
38341 property_val = zend_hash_find_known_hash(zobj->properties, name);
38342 if (property_val) {
38343 goto fast_assign_obj;
38344 }
38345 }
38346
38347 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
38348 if (EXPECTED(zobj->properties == NULL)) {
38349 rebuild_object_properties(zobj);
38350 }
38351 if (IS_CV == IS_CONST) {
38352 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
38353 Z_ADDREF_P(value);
38354 }
38355 } else if (IS_CV != IS_TMP_VAR) {
38356 if (Z_ISREF_P(value)) {
38357 if (IS_CV == IS_VAR) {
38358 zend_reference *ref = Z_REF_P(value);
38359 if (GC_DELREF(ref) == 0) {
38360 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
38361 efree_size(ref, sizeof(zend_reference));
38362 value = &tmp;
38363 } else {
38364 value = Z_REFVAL_P(value);
38365 Z_TRY_ADDREF_P(value);
38366 }
38367 } else {
38368 value = Z_REFVAL_P(value);
38369 Z_TRY_ADDREF_P(value);
38370 }
38371 } else if (IS_CV == IS_CV) {
38372 Z_TRY_ADDREF_P(value);
38373 }
38374 }
38375 zend_hash_add_new(zobj->properties, name, value);
38376 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
38377 ZVAL_COPY(EX_VAR(opline->result.var), value);
38378 }
38379 goto exit_assign_obj;
38380 }
38381 }
38382 }
38383 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
38384 } else {
38385 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
38386 if (UNEXPECTED(!name)) {
38387
38388 UNDEF_RESULT();
38389 goto exit_assign_obj;
38390 }
38391 }
38392
38393 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
38394 ZVAL_DEREF(value);
38395 }
38396
38397 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
38398
38399 if (IS_CV != IS_CONST) {
38400 zend_tmp_string_release(tmp_name);
38401 }
38402
38403 free_and_exit_assign_obj:
38404 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
38405 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
38406 }
38407
38408 exit_assign_obj:
38409 if (garbage) {
38410 GC_DTOR_NO_REF(garbage);
38411 }
38412
38413
38414 /* assign_obj has two opcodes! */
38415 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38416 }
38417
38418 /* 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)38419 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38420 {
38421 USE_OPLINE
38422 zval *property, *container, *value_ptr;
38423
38424 SAVE_OPLINE();
38425
38426 container = &EX(This);
38427 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38428
38429 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
38430
38431 if (1) {
38432 if (IS_UNUSED == IS_UNUSED) {
38433 if (IS_CV == IS_CONST) {
38434 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38435 } else {
38436 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38437 }
38438 } else {
38439 if (IS_CV == IS_CONST) {
38440 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38441 } else {
38442 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38443 }
38444 }
38445 } else {
38446 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38447 }
38448
38449
38450 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
38451 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38452 }
38453
38454 /* 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)38455 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38456 {
38457 USE_OPLINE
38458 zval *property, *container, *value_ptr;
38459
38460 SAVE_OPLINE();
38461
38462 container = &EX(This);
38463 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38464
38465 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
38466
38467 if (1) {
38468 if (IS_UNUSED == IS_UNUSED) {
38469 if (IS_CV == IS_CONST) {
38470 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38471 } else {
38472 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38473 }
38474 } else {
38475 if (IS_CV == IS_CONST) {
38476 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38477 } else {
38478 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38479 }
38480 }
38481 } else {
38482 zend_assign_to_property_reference(container, IS_UNUSED, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
38483 }
38484
38485
38486
38487 ZEND_VM_NEXT_OPCODE_EX(1, 2);
38488 }
38489
38490 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38491 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38492 {
38493 USE_OPLINE
38494 zend_string **rope;
38495 zval *var;
38496
38497 /* Compiler allocates the necessary number of zval slots to keep the rope */
38498 rope = (zend_string**)EX_VAR(opline->result.var);
38499 if (IS_CV == IS_CONST) {
38500 var = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38501 rope[0] = Z_STR_P(var);
38502 if (UNEXPECTED(Z_REFCOUNTED_P(var))) {
38503 Z_ADDREF_P(var);
38504 }
38505 } else {
38506 var = EX_VAR(opline->op2.var);
38507 if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) {
38508 if (IS_CV == IS_CV) {
38509 rope[0] = zend_string_copy(Z_STR_P(var));
38510 } else {
38511 rope[0] = Z_STR_P(var);
38512 }
38513 } else {
38514 SAVE_OPLINE();
38515 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) {
38516 ZVAL_UNDEFINED_OP2();
38517 }
38518 rope[0] = zval_get_string_func(var);
38519
38520 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38521 }
38522 }
38523 ZEND_VM_NEXT_OPCODE();
38524 }
38525
ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38526 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38527 {
38528 zval *class_name;
38529 USE_OPLINE
38530
38531 SAVE_OPLINE();
38532 if (IS_CV == IS_UNUSED) {
38533 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num);
38534 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38535 } else if (IS_CV == IS_CONST) {
38536 zend_class_entry *ce = CACHED_PTR(opline->extended_value);
38537
38538 if (UNEXPECTED(ce == NULL)) {
38539 class_name = EX_VAR(opline->op2.var);
38540 ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num);
38541 CACHE_PTR(opline->extended_value, ce);
38542 }
38543 Z_CE_P(EX_VAR(opline->result.var)) = ce;
38544 } else {
38545 class_name = EX_VAR(opline->op2.var);
38546 try_class_name:
38547 if (Z_TYPE_P(class_name) == IS_OBJECT) {
38548 Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
38549 } else if (Z_TYPE_P(class_name) == IS_STRING) {
38550 Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num);
38551 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) {
38552 class_name = Z_REFVAL_P(class_name);
38553 goto try_class_name;
38554 } else {
38555 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) {
38556 ZVAL_UNDEFINED_OP2();
38557 if (UNEXPECTED(EG(exception) != NULL)) {
38558 HANDLE_EXCEPTION();
38559 }
38560 }
38561 zend_throw_error(NULL, "Class name must be a valid object or a string");
38562 }
38563 }
38564
38565 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38566 }
38567
ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38568 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38569 {
38570 USE_OPLINE
38571 zval *function_name;
38572 zval *object;
38573 zend_function *fbc;
38574 zend_class_entry *called_scope;
38575 zend_object *obj;
38576 zend_execute_data *call;
38577 uint32_t call_info;
38578
38579 SAVE_OPLINE();
38580
38581 object = &EX(This);
38582
38583 if (IS_CV != IS_CONST) {
38584 function_name = EX_VAR(opline->op2.var);
38585 }
38586
38587 if (IS_CV != IS_CONST &&
38588 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
38589 do {
38590 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
38591 function_name = Z_REFVAL_P(function_name);
38592 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
38593 break;
38594 }
38595 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
38596 ZVAL_UNDEFINED_OP2();
38597 if (UNEXPECTED(EG(exception) != NULL)) {
38598
38599 HANDLE_EXCEPTION();
38600 }
38601 }
38602 zend_throw_error(NULL, "Method name must be a string");
38603
38604
38605 HANDLE_EXCEPTION();
38606 } while (0);
38607 }
38608
38609 if (IS_UNUSED == IS_UNUSED) {
38610 obj = Z_OBJ_P(object);
38611 } else {
38612 do {
38613 if (IS_UNUSED != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
38614 obj = Z_OBJ_P(object);
38615 } else {
38616 if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
38617 zend_reference *ref = Z_REF_P(object);
38618
38619 object = &ref->val;
38620 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
38621 obj = Z_OBJ_P(object);
38622 if (IS_UNUSED & IS_VAR) {
38623 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
38624 efree_size(ref, sizeof(zend_reference));
38625 } else {
38626 Z_ADDREF_P(object);
38627 }
38628 }
38629 break;
38630 }
38631 }
38632 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
38633 object = ZVAL_UNDEFINED_OP1();
38634 if (UNEXPECTED(EG(exception) != NULL)) {
38635 if (IS_CV != IS_CONST) {
38636
38637 }
38638 HANDLE_EXCEPTION();
38639 }
38640 }
38641 if (IS_CV == IS_CONST) {
38642 function_name = EX_VAR(opline->op2.var);
38643 }
38644 zend_invalid_method_call(object, function_name);
38645
38646
38647 HANDLE_EXCEPTION();
38648 }
38649 } while (0);
38650 }
38651
38652 called_scope = obj->ce;
38653
38654 if (IS_CV == IS_CONST &&
38655 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
38656 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
38657 } else {
38658 zend_object *orig_obj = obj;
38659
38660 if (IS_CV == IS_CONST) {
38661 function_name = EX_VAR(opline->op2.var);
38662 }
38663
38664 /* First, locate the function. */
38665 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
38666 if (UNEXPECTED(fbc == NULL)) {
38667 if (EXPECTED(!EG(exception))) {
38668 zend_undefined_method(obj->ce, Z_STR_P(function_name));
38669 }
38670
38671 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
38672 zend_objects_store_del(orig_obj);
38673 }
38674 HANDLE_EXCEPTION();
38675 }
38676 if (IS_CV == IS_CONST &&
38677 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
38678 EXPECTED(obj == orig_obj)) {
38679 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
38680 }
38681 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
38682 GC_ADDREF(obj); /* For $this pointer */
38683 if (GC_DELREF(orig_obj) == 0) {
38684 zend_objects_store_del(orig_obj);
38685 }
38686 }
38687 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
38688 init_func_run_time_cache(&fbc->op_array);
38689 }
38690 }
38691
38692 if (IS_CV != IS_CONST) {
38693
38694 }
38695
38696 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
38697 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
38698 if ((IS_UNUSED & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
38699 zend_objects_store_del(obj);
38700 if (UNEXPECTED(EG(exception))) {
38701 HANDLE_EXCEPTION();
38702 }
38703 }
38704 /* call static method */
38705 obj = (zend_object*)called_scope;
38706 call_info = ZEND_CALL_NESTED_FUNCTION;
38707 } else if (IS_UNUSED & (IS_VAR|IS_TMP_VAR|IS_CV)) {
38708 if (IS_UNUSED == IS_CV) {
38709 GC_ADDREF(obj); /* For $this pointer */
38710 }
38711 /* CV may be changed indirectly (e.g. when it's a reference) */
38712 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
38713 }
38714
38715 call = zend_vm_stack_push_call_frame(call_info,
38716 fbc, opline->extended_value, obj);
38717 call->prev_execute_data = EX(call);
38718 EX(call) = call;
38719
38720 ZEND_VM_NEXT_OPCODE();
38721 }
38722
ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38723 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38724 {
38725 USE_OPLINE
38726 zval *function_name;
38727 zend_class_entry *ce;
38728 uint32_t call_info;
38729 zend_function *fbc;
38730 zend_execute_data *call;
38731
38732 SAVE_OPLINE();
38733
38734 if (IS_UNUSED == IS_CONST) {
38735 /* no function found. try a static method in class */
38736 ce = CACHED_PTR(opline->result.num);
38737 if (UNEXPECTED(ce == NULL)) {
38738 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);
38739 if (UNEXPECTED(ce == NULL)) {
38740
38741 HANDLE_EXCEPTION();
38742 }
38743 if (IS_CV != IS_CONST) {
38744 CACHE_PTR(opline->result.num, ce);
38745 }
38746 }
38747 } else if (IS_UNUSED == IS_UNUSED) {
38748 ce = zend_fetch_class(NULL, opline->op1.num);
38749 if (UNEXPECTED(ce == NULL)) {
38750
38751 HANDLE_EXCEPTION();
38752 }
38753 } else {
38754 ce = Z_CE_P(EX_VAR(opline->op1.var));
38755 }
38756
38757 if (IS_UNUSED == IS_CONST &&
38758 IS_CV == IS_CONST &&
38759 EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) {
38760 /* nothing to do */
38761 } else if (IS_UNUSED != IS_CONST &&
38762 IS_CV == IS_CONST &&
38763 EXPECTED(CACHED_PTR(opline->result.num) == ce)) {
38764 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
38765 } else if (IS_CV != IS_UNUSED) {
38766 function_name = EX_VAR(opline->op2.var);
38767 if (IS_CV != IS_CONST) {
38768 if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
38769 do {
38770 if (IS_CV & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) {
38771 function_name = Z_REFVAL_P(function_name);
38772 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
38773 break;
38774 }
38775 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
38776 ZVAL_UNDEFINED_OP2();
38777 if (UNEXPECTED(EG(exception) != NULL)) {
38778 HANDLE_EXCEPTION();
38779 }
38780 }
38781 zend_throw_error(NULL, "Method name must be a string");
38782
38783 HANDLE_EXCEPTION();
38784 } while (0);
38785 }
38786 }
38787
38788 if (ce->get_static_method) {
38789 fbc = ce->get_static_method(ce, Z_STR_P(function_name));
38790 } else {
38791 fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
38792 }
38793 if (UNEXPECTED(fbc == NULL)) {
38794 if (EXPECTED(!EG(exception))) {
38795 zend_undefined_method(ce, Z_STR_P(function_name));
38796 }
38797
38798 HANDLE_EXCEPTION();
38799 }
38800 if (IS_CV == IS_CONST &&
38801 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
38802 EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) {
38803 CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc);
38804 }
38805 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
38806 init_func_run_time_cache(&fbc->op_array);
38807 }
38808 if (IS_CV != IS_CONST) {
38809
38810 }
38811 } else {
38812 if (UNEXPECTED(ce->constructor == NULL)) {
38813 zend_throw_error(NULL, "Cannot call constructor");
38814 HANDLE_EXCEPTION();
38815 }
38816 if (Z_TYPE(EX(This)) == IS_OBJECT && Z_OBJ(EX(This))->ce != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
38817 zend_throw_error(NULL, "Cannot call private %s::__construct()", ZSTR_VAL(ce->name));
38818 HANDLE_EXCEPTION();
38819 }
38820 fbc = ce->constructor;
38821 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
38822 init_func_run_time_cache(&fbc->op_array);
38823 }
38824 }
38825
38826 if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
38827 if (Z_TYPE(EX(This)) == IS_OBJECT && instanceof_function(Z_OBJCE(EX(This)), ce)) {
38828 ce = (zend_class_entry*)Z_OBJ(EX(This));
38829 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
38830 } else {
38831 zend_non_static_method_call(fbc);
38832 HANDLE_EXCEPTION();
38833 }
38834 } else {
38835 /* previous opcode is ZEND_FETCH_CLASS */
38836 if (IS_UNUSED == IS_UNUSED
38837 && ((opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_PARENT ||
38838 (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF)) {
38839 if (Z_TYPE(EX(This)) == IS_OBJECT) {
38840 ce = Z_OBJCE(EX(This));
38841 } else {
38842 ce = Z_CE(EX(This));
38843 }
38844 }
38845 call_info = ZEND_CALL_NESTED_FUNCTION;
38846 }
38847
38848 call = zend_vm_stack_push_call_frame(call_info,
38849 fbc, opline->extended_value, ce);
38850 call->prev_execute_data = EX(call);
38851 EX(call) = call;
38852
38853 ZEND_VM_NEXT_OPCODE();
38854 }
38855
ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38856 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38857 {
38858 zval *array;
38859 uint32_t size;
38860 USE_OPLINE
38861
38862 array = EX_VAR(opline->result.var);
38863 if (IS_UNUSED != IS_UNUSED) {
38864 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
38865 ZVAL_ARR(array, zend_new_array(size));
38866 /* Explicitly initialize array as not-packed if flag is set */
38867 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
38868 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
38869 }
38870 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38871 } else {
38872 ZVAL_ARR(array, zend_new_array(0));
38873 ZEND_VM_NEXT_OPCODE();
38874 }
38875 }
38876
ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38877 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38878 {
38879 USE_OPLINE
38880 zval *container;
38881 zval *offset;
38882 zend_string *name, *tmp_name;
38883
38884 SAVE_OPLINE();
38885 container = &EX(This);
38886 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38887
38888 do {
38889 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
38890 if (Z_ISREF_P(container)) {
38891 container = Z_REFVAL_P(container);
38892 if (Z_TYPE_P(container) != IS_OBJECT) {
38893 if (IS_UNUSED == IS_CV
38894 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
38895 ZVAL_UNDEFINED_OP1();
38896 }
38897 break;
38898 }
38899 } else {
38900 break;
38901 }
38902 }
38903 if (IS_CV == IS_CONST) {
38904 name = Z_STR_P(offset);
38905 } else {
38906 name = zval_try_get_tmp_string(offset, &tmp_name);
38907 if (UNEXPECTED(!name)) {
38908 break;
38909 }
38910 }
38911 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
38912 if (IS_CV != IS_CONST) {
38913 zend_tmp_string_release(tmp_name);
38914 }
38915 } while (0);
38916
38917
38918 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
38919 }
38920
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38921 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38922 {
38923 USE_OPLINE
38924 zval *container;
38925 int result;
38926 zval *offset;
38927 zend_string *name, *tmp_name;
38928
38929 SAVE_OPLINE();
38930 container = &EX(This);
38931 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
38932
38933 if (IS_UNUSED == IS_CONST ||
38934 (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
38935 if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
38936 container = Z_REFVAL_P(container);
38937 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
38938 result = (opline->extended_value & ZEND_ISEMPTY);
38939 goto isset_object_finish;
38940 }
38941 } else {
38942 result = (opline->extended_value & ZEND_ISEMPTY);
38943 goto isset_object_finish;
38944 }
38945 }
38946
38947 if (IS_CV == IS_CONST) {
38948 name = Z_STR_P(offset);
38949 } else {
38950 name = zval_try_get_tmp_string(offset, &tmp_name);
38951 if (UNEXPECTED(!name)) {
38952 result = 0;
38953 goto isset_object_finish;
38954 }
38955 }
38956
38957 result =
38958 (opline->extended_value & ZEND_ISEMPTY) ^
38959 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));
38960
38961 if (IS_CV != IS_CONST) {
38962 zend_tmp_string_release(tmp_name);
38963 }
38964
38965 isset_object_finish:
38966
38967
38968 ZEND_VM_SMART_BRANCH(result, 1);
38969 }
38970
ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)38971 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
38972 {
38973 USE_OPLINE
38974
38975 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
38976
38977 SAVE_OPLINE();
38978 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
38979 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
38980 }
38981
38982 /* Destroy the previously yielded value */
38983 zval_ptr_dtor(&generator->value);
38984
38985 /* Destroy the previously yielded key */
38986 zval_ptr_dtor(&generator->key);
38987
38988 /* Set the new yielded value */
38989 if (IS_UNUSED != IS_UNUSED) {
38990 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
38991 /* Constants and temporary variables aren't yieldable by reference,
38992 * but we still allow them with a notice. */
38993 if (IS_UNUSED & (IS_CONST|IS_TMP_VAR)) {
38994 zval *value;
38995
38996 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
38997
38998 value = NULL;
38999 ZVAL_COPY_VALUE(&generator->value, value);
39000 if (IS_UNUSED == IS_CONST) {
39001 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
39002 Z_ADDREF(generator->value);
39003 }
39004 }
39005 } else {
39006 zval *value_ptr = NULL;
39007
39008 /* If a function call result is yielded and the function did
39009 * not return by reference we throw a notice. */
39010 do {
39011 if (IS_UNUSED == IS_VAR) {
39012 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
39013 if (opline->extended_value == ZEND_RETURNS_FUNCTION
39014 && !Z_ISREF_P(value_ptr)) {
39015 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
39016 ZVAL_COPY(&generator->value, value_ptr);
39017 break;
39018 }
39019 }
39020 if (Z_ISREF_P(value_ptr)) {
39021 Z_ADDREF_P(value_ptr);
39022 } else {
39023 ZVAL_MAKE_REF_EX(value_ptr, 2);
39024 }
39025 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
39026 } while (0);
39027
39028 }
39029 } else {
39030 zval *value = NULL;
39031
39032 /* Consts, temporary variables and references need copying */
39033 if (IS_UNUSED == IS_CONST) {
39034 ZVAL_COPY_VALUE(&generator->value, value);
39035 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
39036 Z_ADDREF(generator->value);
39037 }
39038 } else if (IS_UNUSED == IS_TMP_VAR) {
39039 ZVAL_COPY_VALUE(&generator->value, value);
39040 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
39041 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
39042
39043 } else {
39044 ZVAL_COPY_VALUE(&generator->value, value);
39045 if (IS_UNUSED == IS_CV) {
39046 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
39047 }
39048 }
39049 }
39050 } else {
39051 /* If no value was specified yield null */
39052 ZVAL_NULL(&generator->value);
39053 }
39054
39055 /* Set the new yielded key */
39056 if (IS_CV != IS_UNUSED) {
39057 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
39058 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
39059 key = Z_REFVAL_P(key);
39060 }
39061 ZVAL_COPY(&generator->key, key);
39062
39063 if (Z_TYPE(generator->key) == IS_LONG
39064 && Z_LVAL(generator->key) > generator->largest_used_integer_key
39065 ) {
39066 generator->largest_used_integer_key = Z_LVAL(generator->key);
39067 }
39068 } else {
39069 /* If no key was specified we use auto-increment keys */
39070 generator->largest_used_integer_key++;
39071 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
39072 }
39073
39074 if (RETURN_VALUE_USED(opline)) {
39075 /* If the return value of yield is used set the send
39076 * target and initialize it to NULL */
39077 generator->send_target = EX_VAR(opline->result.var);
39078 ZVAL_NULL(generator->send_target);
39079 } else {
39080 generator->send_target = NULL;
39081 }
39082
39083 /* We increment to the next op, so we are at the correct position when the
39084 * generator is resumed. */
39085 ZEND_VM_INC_OPCODE();
39086
39087 /* The GOTO VM uses a local opline variable. We need to set the opline
39088 * variable in execute_data so we don't resume at an old position. */
39089 SAVE_OPLINE();
39090
39091 ZEND_VM_RETURN();
39092 }
39093
ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39094 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39095 {
39096 USE_OPLINE
39097 zval *val;
39098
39099 val = EX_VAR(opline->op1.var);
39100 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39101 ZVAL_FALSE(EX_VAR(opline->result.var));
39102 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39103 /* The result and op1 can be the same cv zval */
39104 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
39105 ZVAL_TRUE(EX_VAR(opline->result.var));
39106 if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
39107 SAVE_OPLINE();
39108 ZVAL_UNDEFINED_OP1();
39109 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39110 }
39111 } else {
39112 SAVE_OPLINE();
39113 ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
39114
39115 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39116 }
39117 ZEND_VM_NEXT_OPCODE();
39118 }
39119
zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)39120 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
39121 {
39122 USE_OPLINE
39123 zval *var_ptr;
39124
39125 var_ptr = EX_VAR(opline->op1.var);
39126
39127 SAVE_OPLINE();
39128 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
39129 ZVAL_UNDEFINED_OP1();
39130 ZVAL_NULL(var_ptr);
39131 }
39132
39133 do {
39134 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
39135 zend_reference *ref = Z_REF_P(var_ptr);
39136 var_ptr = Z_REFVAL_P(var_ptr);
39137 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
39138 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
39139 break;
39140 }
39141 }
39142 increment_function(var_ptr);
39143 } while (0);
39144
39145 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39146 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
39147 }
39148
39149 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39150 }
39151
ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39152 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39153 {
39154 USE_OPLINE
39155 zval *var_ptr;
39156
39157 var_ptr = EX_VAR(opline->op1.var);
39158
39159 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
39160 fast_long_increment_function(var_ptr);
39161 if (UNEXPECTED(0)) {
39162 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
39163 }
39164 ZEND_VM_NEXT_OPCODE();
39165 }
39166
39167 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39168 }
39169
ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39170 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39171 {
39172 USE_OPLINE
39173 zval *var_ptr;
39174
39175 var_ptr = EX_VAR(opline->op1.var);
39176
39177 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
39178 fast_long_increment_function(var_ptr);
39179 if (UNEXPECTED(1)) {
39180 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
39181 }
39182 ZEND_VM_NEXT_OPCODE();
39183 }
39184
39185 ZEND_VM_TAIL_CALL(zend_pre_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39186 }
39187
zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)39188 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
39189 {
39190 USE_OPLINE
39191 zval *var_ptr;
39192
39193 var_ptr = EX_VAR(opline->op1.var);
39194
39195 SAVE_OPLINE();
39196 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
39197 ZVAL_UNDEFINED_OP1();
39198 ZVAL_NULL(var_ptr);
39199 }
39200
39201 do {
39202 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
39203 zend_reference *ref = Z_REF_P(var_ptr);
39204 var_ptr = Z_REFVAL_P(var_ptr);
39205
39206 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
39207 zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
39208 break;
39209 }
39210 }
39211 decrement_function(var_ptr);
39212 } while (0);
39213
39214 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
39215 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
39216 }
39217
39218 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39219 }
39220
ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39221 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39222 {
39223 USE_OPLINE
39224 zval *var_ptr;
39225
39226 var_ptr = EX_VAR(opline->op1.var);
39227
39228 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
39229 fast_long_decrement_function(var_ptr);
39230 if (UNEXPECTED(0)) {
39231 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
39232 }
39233 ZEND_VM_NEXT_OPCODE();
39234 }
39235
39236 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39237 }
39238
ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39239 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39240 {
39241 USE_OPLINE
39242 zval *var_ptr;
39243
39244 var_ptr = EX_VAR(opline->op1.var);
39245
39246 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
39247 fast_long_decrement_function(var_ptr);
39248 if (UNEXPECTED(1)) {
39249 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
39250 }
39251 ZEND_VM_NEXT_OPCODE();
39252 }
39253
39254 ZEND_VM_TAIL_CALL(zend_pre_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39255 }
39256
zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)39257 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
39258 {
39259 USE_OPLINE
39260 zval *var_ptr;
39261
39262 var_ptr = EX_VAR(opline->op1.var);
39263
39264 SAVE_OPLINE();
39265 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
39266 ZVAL_UNDEFINED_OP1();
39267 ZVAL_NULL(var_ptr);
39268 }
39269
39270 do {
39271 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
39272 zend_reference *ref = Z_REF_P(var_ptr);
39273 var_ptr = Z_REFVAL_P(var_ptr);
39274
39275 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
39276 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
39277 break;
39278 }
39279 }
39280 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
39281
39282 increment_function(var_ptr);
39283 } while (0);
39284
39285 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39286 }
39287
ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39288 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39289 {
39290 USE_OPLINE
39291 zval *var_ptr;
39292
39293 var_ptr = EX_VAR(opline->op1.var);
39294
39295 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
39296 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
39297 fast_long_increment_function(var_ptr);
39298 ZEND_VM_NEXT_OPCODE();
39299 }
39300
39301 ZEND_VM_TAIL_CALL(zend_post_inc_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39302 }
39303
zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)39304 static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
39305 {
39306 USE_OPLINE
39307 zval *var_ptr;
39308
39309 var_ptr = EX_VAR(opline->op1.var);
39310
39311 SAVE_OPLINE();
39312 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
39313 ZVAL_UNDEFINED_OP1();
39314 ZVAL_NULL(var_ptr);
39315 }
39316
39317 do {
39318 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
39319 zend_reference *ref = Z_REF_P(var_ptr);
39320 var_ptr = Z_REFVAL_P(var_ptr);
39321
39322 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
39323 zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
39324 break;
39325 }
39326 }
39327 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
39328
39329 decrement_function(var_ptr);
39330 } while (0);
39331
39332 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39333 }
39334
ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39335 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39336 {
39337 USE_OPLINE
39338 zval *var_ptr;
39339
39340 var_ptr = EX_VAR(opline->op1.var);
39341
39342 if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
39343 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
39344 fast_long_decrement_function(var_ptr);
39345 ZEND_VM_NEXT_OPCODE();
39346 }
39347
39348 ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39349 }
39350
ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39351 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39352 {
39353 USE_OPLINE
39354 zval *z;
39355
39356 SAVE_OPLINE();
39357 z = EX_VAR(opline->op1.var);
39358
39359 if (Z_TYPE_P(z) == IS_STRING) {
39360 zend_string *str = Z_STR_P(z);
39361
39362 if (ZSTR_LEN(str) != 0) {
39363 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
39364 }
39365 } else {
39366 zend_string *str = zval_get_string_func(z);
39367
39368 if (ZSTR_LEN(str) != 0) {
39369 zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
39370 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
39371 ZVAL_UNDEFINED_OP1();
39372 }
39373 zend_string_release_ex(str, 0);
39374 }
39375
39376 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39377 }
39378
ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39379 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39380 {
39381 USE_OPLINE
39382 zval *val;
39383 uint8_t op1_type;
39384
39385 val = EX_VAR(opline->op1.var);
39386
39387 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39388 ZEND_VM_NEXT_OPCODE();
39389 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39390 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
39391 SAVE_OPLINE();
39392 ZVAL_UNDEFINED_OP1();
39393 if (UNEXPECTED(EG(exception))) {
39394 HANDLE_EXCEPTION();
39395 }
39396 }
39397 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
39398 }
39399
39400 SAVE_OPLINE();
39401 op1_type = IS_CV;
39402 if (i_zend_is_true(val)) {
39403 opline++;
39404 } else {
39405 opline = OP_JMP_ADDR(opline, opline->op2);
39406 }
39407 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
39408 zval_ptr_dtor_nogc(val);
39409 }
39410 ZEND_VM_JMP(opline);
39411 }
39412
ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39413 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39414 {
39415 USE_OPLINE
39416 zval *val;
39417 uint8_t op1_type;
39418
39419 val = EX_VAR(opline->op1.var);
39420
39421 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39422 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
39423 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39424 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
39425 SAVE_OPLINE();
39426 ZVAL_UNDEFINED_OP1();
39427 if (UNEXPECTED(EG(exception))) {
39428 HANDLE_EXCEPTION();
39429 }
39430 }
39431 ZEND_VM_NEXT_OPCODE();
39432 }
39433
39434 SAVE_OPLINE();
39435 op1_type = IS_CV;
39436 if (i_zend_is_true(val)) {
39437 opline = OP_JMP_ADDR(opline, opline->op2);
39438 } else {
39439 opline++;
39440 }
39441 if (op1_type & (IS_TMP_VAR|IS_VAR)) {
39442 zval_ptr_dtor_nogc(val);
39443 }
39444 ZEND_VM_JMP(opline);
39445 }
39446
ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39447 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39448 {
39449 USE_OPLINE
39450 zval *val;
39451 bool ret;
39452
39453 val = EX_VAR(opline->op1.var);
39454
39455 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39456 ZVAL_TRUE(EX_VAR(opline->result.var));
39457 ZEND_VM_NEXT_OPCODE();
39458 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39459 ZVAL_FALSE(EX_VAR(opline->result.var));
39460 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
39461 SAVE_OPLINE();
39462 ZVAL_UNDEFINED_OP1();
39463 if (UNEXPECTED(EG(exception))) {
39464 HANDLE_EXCEPTION();
39465 }
39466 }
39467 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
39468 }
39469
39470 SAVE_OPLINE();
39471 ret = i_zend_is_true(val);
39472
39473 if (ret) {
39474 ZVAL_TRUE(EX_VAR(opline->result.var));
39475 opline++;
39476 } else {
39477 ZVAL_FALSE(EX_VAR(opline->result.var));
39478 opline = OP_JMP_ADDR(opline, opline->op2);
39479 }
39480 ZEND_VM_JMP(opline);
39481 }
39482
ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39483 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39484 {
39485 USE_OPLINE
39486 zval *val;
39487 bool ret;
39488
39489 val = EX_VAR(opline->op1.var);
39490
39491 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39492 ZVAL_TRUE(EX_VAR(opline->result.var));
39493 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
39494 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39495 ZVAL_FALSE(EX_VAR(opline->result.var));
39496 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) {
39497 SAVE_OPLINE();
39498 ZVAL_UNDEFINED_OP1();
39499 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39500 } else {
39501 ZEND_VM_NEXT_OPCODE();
39502 }
39503 }
39504
39505 SAVE_OPLINE();
39506 ret = i_zend_is_true(val);
39507
39508 if (ret) {
39509 ZVAL_TRUE(EX_VAR(opline->result.var));
39510 opline = OP_JMP_ADDR(opline, opline->op2);
39511 } else {
39512 ZVAL_FALSE(EX_VAR(opline->result.var));
39513 opline++;
39514 }
39515 ZEND_VM_JMP(opline);
39516 }
39517
ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39518 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39519 {
39520 USE_OPLINE
39521 zval *retval_ptr;
39522 zval *return_value;
39523
39524 retval_ptr = EX_VAR(opline->op1.var);
39525 return_value = EX(return_value);
39526
39527 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
39528 SAVE_OPLINE();
39529 retval_ptr = ZVAL_UNDEFINED_OP1();
39530 if (return_value) {
39531 ZVAL_NULL(return_value);
39532 }
39533 } else if (!return_value) {
39534 if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
39535 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
39536 SAVE_OPLINE();
39537 rc_dtor_func(Z_COUNTED_P(retval_ptr));
39538 }
39539 }
39540 } else {
39541 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
39542 ZVAL_COPY_VALUE(return_value, retval_ptr);
39543 if (IS_CV == IS_CONST) {
39544 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
39545 Z_ADDREF_P(return_value);
39546 }
39547 }
39548 } else if (IS_CV == IS_CV) {
39549 do {
39550 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
39551 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
39552 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
39553 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
39554 ZVAL_COPY_VALUE(return_value, retval_ptr);
39555 if (GC_MAY_LEAK(ref)) {
39556 SAVE_OPLINE();
39557 gc_possible_root(ref);
39558 }
39559 ZVAL_NULL(retval_ptr);
39560 break;
39561 } else {
39562 Z_ADDREF_P(retval_ptr);
39563 }
39564 } else {
39565 retval_ptr = Z_REFVAL_P(retval_ptr);
39566 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
39567 Z_ADDREF_P(retval_ptr);
39568 }
39569 }
39570 }
39571 ZVAL_COPY_VALUE(return_value, retval_ptr);
39572 } while (0);
39573 } else /* if (IS_CV == IS_VAR) */ {
39574 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
39575 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
39576
39577 retval_ptr = Z_REFVAL_P(retval_ptr);
39578 ZVAL_COPY_VALUE(return_value, retval_ptr);
39579 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
39580 efree_size(ref, sizeof(zend_reference));
39581 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
39582 Z_ADDREF_P(retval_ptr);
39583 }
39584 } else {
39585 ZVAL_COPY_VALUE(return_value, retval_ptr);
39586 }
39587 }
39588 }
39589
39590
39591
39592 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39593 }
39594
ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39595 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39596 {
39597 USE_OPLINE
39598 zval *retval_ptr;
39599 zval *return_value;
39600
39601 SAVE_OPLINE();
39602
39603 return_value = EX(return_value);
39604
39605 do {
39606 if ((IS_CV & (IS_CONST|IS_TMP_VAR)) ||
39607 (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
39608 /* Not supposed to happen, but we'll allow it */
39609 zend_error(E_NOTICE, "Only variable references should be returned by reference");
39610
39611 retval_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
39612 if (!return_value) {
39613
39614 } else {
39615 if (IS_CV == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
39616 ZVAL_COPY_VALUE(return_value, retval_ptr);
39617 break;
39618 }
39619
39620 ZVAL_NEW_REF(return_value, retval_ptr);
39621 if (IS_CV == IS_CONST) {
39622 Z_TRY_ADDREF_P(retval_ptr);
39623 }
39624 }
39625 break;
39626 }
39627
39628 retval_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
39629
39630 if (IS_CV == IS_VAR) {
39631 ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
39632 if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
39633 zend_error(E_NOTICE, "Only variable references should be returned by reference");
39634 if (return_value) {
39635 ZVAL_NEW_REF(return_value, retval_ptr);
39636 } else {
39637
39638 }
39639 break;
39640 }
39641 }
39642
39643 if (return_value) {
39644 if (Z_ISREF_P(retval_ptr)) {
39645 Z_ADDREF_P(retval_ptr);
39646 } else {
39647 ZVAL_MAKE_REF_EX(retval_ptr, 2);
39648 }
39649 ZVAL_REF(return_value, Z_REF_P(retval_ptr));
39650 }
39651
39652 } while (0);
39653
39654
39655 ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
39656 }
39657
ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39658 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39659 {
39660 USE_OPLINE
39661 zval *retval;
39662
39663 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
39664
39665 SAVE_OPLINE();
39666 retval = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
39667
39668 /* Copy return value into generator->retval */
39669 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
39670 ZVAL_COPY_VALUE(&generator->retval, retval);
39671 if (IS_CV == IS_CONST) {
39672 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
39673 Z_ADDREF(generator->retval);
39674 }
39675 }
39676 } else if (IS_CV == IS_CV) {
39677 ZVAL_COPY_DEREF(&generator->retval, retval);
39678 } else /* if (IS_CV == IS_VAR) */ {
39679 if (UNEXPECTED(Z_ISREF_P(retval))) {
39680 zend_refcounted *ref = Z_COUNTED_P(retval);
39681
39682 retval = Z_REFVAL_P(retval);
39683 ZVAL_COPY_VALUE(&generator->retval, retval);
39684 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
39685 efree_size(ref, sizeof(zend_reference));
39686 } else if (Z_OPT_REFCOUNTED_P(retval)) {
39687 Z_ADDREF_P(retval);
39688 }
39689 } else {
39690 ZVAL_COPY_VALUE(&generator->retval, retval);
39691 }
39692 }
39693
39694 EG(current_execute_data) = EX(prev_execute_data);
39695
39696 /* Close the generator to free up resources */
39697 zend_generator_close(generator, 1);
39698
39699 /* Pass execution back to handling code */
39700 ZEND_VM_RETURN();
39701 }
39702
ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39703 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39704 {
39705 USE_OPLINE
39706 zval *value;
39707
39708 SAVE_OPLINE();
39709 value = EX_VAR(opline->op1.var);
39710
39711 do {
39712 if (IS_CV == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
39713 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
39714 value = Z_REFVAL_P(value);
39715 if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) {
39716 break;
39717 }
39718 }
39719 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
39720 ZVAL_UNDEFINED_OP1();
39721 if (UNEXPECTED(EG(exception) != NULL)) {
39722 HANDLE_EXCEPTION();
39723 }
39724 }
39725 zend_throw_error(NULL, "Can only throw objects");
39726
39727 HANDLE_EXCEPTION();
39728 }
39729 } while (0);
39730
39731 zend_exception_save();
39732 Z_TRY_ADDREF_P(value);
39733 zend_throw_exception_object(value);
39734 zend_exception_restore();
39735
39736 HANDLE_EXCEPTION();
39737 }
39738
ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39739 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39740 {
39741 USE_OPLINE
39742 zval *arg, *param;
39743
39744 SAVE_OPLINE();
39745
39746 arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
39747 param = ZEND_CALL_VAR(EX(call), opline->result.var);
39748 if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) {
39749 zend_param_must_be_ref(EX(call)->func, opline->op2.num);
39750 Z_TRY_ADDREF_P(arg);
39751 ZVAL_NEW_REF(param, arg);
39752 } else {
39753 ZVAL_COPY(param, arg);
39754 }
39755
39756 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39757 }
39758
ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39759 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39760 {
39761 USE_OPLINE
39762 zval *val;
39763
39764 val = EX_VAR(opline->op1.var);
39765 if (Z_TYPE_INFO_P(val) == IS_TRUE) {
39766 ZVAL_TRUE(EX_VAR(opline->result.var));
39767 } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
39768 /* The result and op1 can be the same cv zval */
39769 const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
39770 ZVAL_FALSE(EX_VAR(opline->result.var));
39771 if (IS_CV == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
39772 SAVE_OPLINE();
39773 ZVAL_UNDEFINED_OP1();
39774 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39775 }
39776 } else {
39777 SAVE_OPLINE();
39778 ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val));
39779
39780 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39781 }
39782 ZEND_VM_NEXT_OPCODE();
39783 }
39784
ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39785 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39786 {
39787 USE_OPLINE
39788 zval *obj;
39789 zend_object *zobj;
39790 zend_class_entry *ce, *scope;
39791 zend_function *clone;
39792 zend_object_clone_obj_t clone_call;
39793
39794 SAVE_OPLINE();
39795 obj = EX_VAR(opline->op1.var);
39796
39797 do {
39798 if (IS_CV == IS_CONST ||
39799 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
39800 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
39801 obj = Z_REFVAL_P(obj);
39802 if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
39803 break;
39804 }
39805 }
39806 ZVAL_UNDEF(EX_VAR(opline->result.var));
39807 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) {
39808 ZVAL_UNDEFINED_OP1();
39809 if (UNEXPECTED(EG(exception) != NULL)) {
39810 HANDLE_EXCEPTION();
39811 }
39812 }
39813 zend_throw_error(NULL, "__clone method called on non-object");
39814
39815 HANDLE_EXCEPTION();
39816 }
39817 } while (0);
39818
39819 zobj = Z_OBJ_P(obj);
39820 ce = zobj->ce;
39821 clone = ce->clone;
39822 clone_call = zobj->handlers->clone_obj;
39823 if (UNEXPECTED(clone_call == NULL)) {
39824 zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name));
39825
39826 ZVAL_UNDEF(EX_VAR(opline->result.var));
39827 HANDLE_EXCEPTION();
39828 }
39829
39830 if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) {
39831 scope = EX(func)->op_array.scope;
39832 if (clone->common.scope != scope) {
39833 if (UNEXPECTED(clone->common.fn_flags & ZEND_ACC_PRIVATE)
39834 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), scope))) {
39835 zend_wrong_clone_call(clone, scope);
39836
39837 ZVAL_UNDEF(EX_VAR(opline->result.var));
39838 HANDLE_EXCEPTION();
39839 }
39840 }
39841 }
39842
39843 ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj));
39844
39845 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39846 }
39847
ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39848 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39849 {
39850 USE_OPLINE
39851 zval *expr;
39852 zval *result = EX_VAR(opline->result.var);
39853 HashTable *ht;
39854
39855 SAVE_OPLINE();
39856 expr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
39857
39858 switch (opline->extended_value) {
39859 case IS_LONG:
39860 ZVAL_LONG(result, zval_get_long(expr));
39861 break;
39862 case IS_DOUBLE:
39863 ZVAL_DOUBLE(result, zval_get_double(expr));
39864 break;
39865 case IS_STRING:
39866 ZVAL_STR(result, zval_get_string(expr));
39867 break;
39868 default:
39869 ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead");
39870 if (IS_CV & (IS_VAR|IS_CV)) {
39871 ZVAL_DEREF(expr);
39872 }
39873 /* If value is already of correct type, return it directly */
39874 if (Z_TYPE_P(expr) == opline->extended_value) {
39875 ZVAL_COPY_VALUE(result, expr);
39876 if (IS_CV == IS_CONST) {
39877 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
39878 } else if (IS_CV != IS_TMP_VAR) {
39879 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
39880 }
39881
39882 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39883 }
39884
39885 if (opline->extended_value == IS_ARRAY) {
39886 if (IS_CV == IS_CONST || Z_TYPE_P(expr) != IS_OBJECT || Z_OBJCE_P(expr) == zend_ce_closure) {
39887 if (Z_TYPE_P(expr) != IS_NULL) {
39888 ZVAL_ARR(result, zend_new_array(1));
39889 expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
39890 if (IS_CV == IS_CONST) {
39891 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
39892 } else {
39893 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
39894 }
39895 } else {
39896 ZVAL_EMPTY_ARRAY(result);
39897 }
39898 } else if (Z_OBJ_P(expr)->properties == NULL
39899 && Z_OBJ_HT_P(expr)->get_properties_for == NULL
39900 && Z_OBJ_HT_P(expr)->get_properties == zend_std_get_properties) {
39901 /* Optimized version without rebuilding properties HashTable */
39902 ZVAL_ARR(result, zend_std_build_object_properties_array(Z_OBJ_P(expr)));
39903 } else {
39904 HashTable *obj_ht = zend_get_properties_for(expr, ZEND_PROP_PURPOSE_ARRAY_CAST);
39905 if (obj_ht) {
39906 /* fast copy */
39907 ZVAL_ARR(result, zend_proptable_to_symtable(obj_ht,
39908 (Z_OBJCE_P(expr)->default_properties_count ||
39909 Z_OBJ_P(expr)->handlers != &std_object_handlers ||
39910 GC_IS_RECURSIVE(obj_ht))));
39911 zend_release_properties(obj_ht);
39912 } else {
39913 ZVAL_EMPTY_ARRAY(result);
39914 }
39915 }
39916 } else {
39917 ZEND_ASSERT(opline->extended_value == IS_OBJECT);
39918 ZVAL_OBJ(result, zend_objects_new(zend_standard_class_def));
39919 if (Z_TYPE_P(expr) == IS_ARRAY) {
39920 ht = zend_symtable_to_proptable(Z_ARR_P(expr));
39921 if (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) {
39922 /* TODO: try not to duplicate immutable arrays as well ??? */
39923 ht = zend_array_dup(ht);
39924 }
39925 Z_OBJ_P(result)->properties = ht;
39926 } else if (Z_TYPE_P(expr) != IS_NULL) {
39927 Z_OBJ_P(result)->properties = ht = zend_new_array(1);
39928 expr = zend_hash_add_new(ht, ZSTR_KNOWN(ZEND_STR_SCALAR), expr);
39929 if (IS_CV == IS_CONST) {
39930 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(expr))) Z_ADDREF_P(expr);
39931 } else {
39932 if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
39933 }
39934 }
39935 }
39936 }
39937
39938 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
39939 }
39940
ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)39941 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
39942 {
39943 USE_OPLINE
39944 zend_op_array *new_op_array;
39945 zval *inc_filename;
39946
39947 SAVE_OPLINE();
39948 inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
39949 new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
39950 if (UNEXPECTED(EG(exception) != NULL)) {
39951
39952 if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
39953 destroy_op_array(new_op_array);
39954 efree_size(new_op_array, sizeof(zend_op_array));
39955 }
39956 UNDEF_RESULT();
39957 HANDLE_EXCEPTION();
39958 } else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
39959 if (RETURN_VALUE_USED(opline)) {
39960 ZVAL_TRUE(EX_VAR(opline->result.var));
39961 }
39962 } else if (UNEXPECTED(new_op_array == NULL)) {
39963 if (RETURN_VALUE_USED(opline)) {
39964 ZVAL_FALSE(EX_VAR(opline->result.var));
39965 }
39966 } else if (new_op_array->last == 1
39967 && new_op_array->opcodes[0].opcode == ZEND_RETURN
39968 && new_op_array->opcodes[0].op1_type == IS_CONST
39969 && EXPECTED(zend_execute_ex == execute_ex)) {
39970 if (RETURN_VALUE_USED(opline)) {
39971 const zend_op *op = new_op_array->opcodes;
39972
39973 ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1));
39974 }
39975 zend_destroy_static_vars(new_op_array);
39976 destroy_op_array(new_op_array);
39977 efree_size(new_op_array, sizeof(zend_op_array));
39978 } else {
39979 zval *return_value = NULL;
39980 zend_execute_data *call;
39981 if (RETURN_VALUE_USED(opline)) {
39982 return_value = EX_VAR(opline->result.var);
39983 }
39984
39985 new_op_array->scope = EX(func)->op_array.scope;
39986
39987 call = zend_vm_stack_push_call_frame(
39988 (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
39989 (zend_function*)new_op_array, 0,
39990 Z_PTR(EX(This)));
39991
39992 if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
39993 call->symbol_table = EX(symbol_table);
39994 } else {
39995 call->symbol_table = zend_rebuild_symbol_table();
39996 }
39997
39998 call->prev_execute_data = execute_data;
39999 i_init_code_execute_data(call, new_op_array, return_value);
40000
40001 if (EXPECTED(zend_execute_ex == execute_ex)) {
40002
40003 ZEND_VM_ENTER();
40004 } else {
40005 ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
40006 zend_execute_ex(call);
40007 zend_vm_stack_free_call_frame(call);
40008 }
40009
40010 zend_destroy_static_vars(new_op_array);
40011 destroy_op_array(new_op_array);
40012 efree_size(new_op_array, sizeof(zend_op_array));
40013 if (UNEXPECTED(EG(exception) != NULL)) {
40014 zend_rethrow_exception(execute_data);
40015
40016 UNDEF_RESULT();
40017 HANDLE_EXCEPTION();
40018 }
40019 }
40020
40021 ZEND_VM_NEXT_OPCODE();
40022 }
40023
ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40024 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40025 {
40026 USE_OPLINE
40027 zval *array_ptr, *result;
40028
40029 SAVE_OPLINE();
40030
40031 array_ptr = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40032 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
40033 result = EX_VAR(opline->result.var);
40034 ZVAL_COPY_VALUE(result, array_ptr);
40035 if (IS_CV != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) {
40036 Z_ADDREF_P(array_ptr);
40037 }
40038 Z_FE_POS_P(result) = 0;
40039
40040 ZEND_VM_NEXT_OPCODE();
40041 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
40042 zend_object *zobj = Z_OBJ_P(array_ptr);
40043 if (!zobj->ce->get_iterator) {
40044 HashTable *properties = zobj->properties;
40045 if (properties) {
40046 if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) {
40047 if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) {
40048 GC_DELREF(properties);
40049 }
40050 properties = zobj->properties = zend_array_dup(properties);
40051 }
40052 } else {
40053 properties = zobj->handlers->get_properties(zobj);
40054 }
40055
40056 result = EX_VAR(opline->result.var);
40057 ZVAL_COPY_VALUE(result, array_ptr);
40058 if (IS_CV != IS_TMP_VAR) {
40059 Z_ADDREF_P(array_ptr);
40060 }
40061
40062 if (zend_hash_num_elements(properties) == 0) {
40063 Z_FE_ITER_P(result) = (uint32_t) -1;
40064
40065 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
40066 }
40067
40068 Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0);
40069
40070 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40071 } else {
40072 bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC);
40073
40074 if (UNEXPECTED(EG(exception))) {
40075 HANDLE_EXCEPTION();
40076 } else if (is_empty) {
40077 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40078 } else {
40079 ZEND_VM_NEXT_OPCODE();
40080 }
40081 }
40082 } else {
40083 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
40084 ZVAL_UNDEF(EX_VAR(opline->result.var));
40085 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
40086
40087 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
40088 }
40089 }
40090
ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40091 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40092 {
40093 USE_OPLINE
40094 zval *array_ptr, *array_ref;
40095
40096 SAVE_OPLINE();
40097
40098 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
40099 array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40100 if (Z_ISREF_P(array_ref)) {
40101 array_ptr = Z_REFVAL_P(array_ref);
40102 }
40103 } else {
40104 array_ref = array_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40105 }
40106
40107 if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) {
40108 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
40109 if (array_ptr == array_ref) {
40110 ZVAL_NEW_REF(array_ref, array_ref);
40111 array_ptr = Z_REFVAL_P(array_ref);
40112 }
40113 Z_ADDREF_P(array_ref);
40114 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
40115 } else {
40116 array_ref = EX_VAR(opline->result.var);
40117 ZVAL_NEW_REF(array_ref, array_ptr);
40118 array_ptr = Z_REFVAL_P(array_ref);
40119 }
40120 if (IS_CV == IS_CONST) {
40121 ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr)));
40122 } else {
40123 SEPARATE_ARRAY(array_ptr);
40124 }
40125 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0);
40126
40127 ZEND_VM_NEXT_OPCODE();
40128 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) {
40129 if (!Z_OBJCE_P(array_ptr)->get_iterator) {
40130 HashTable *properties;
40131 if (IS_CV == IS_VAR || IS_CV == IS_CV) {
40132 if (array_ptr == array_ref) {
40133 ZVAL_NEW_REF(array_ref, array_ref);
40134 array_ptr = Z_REFVAL_P(array_ref);
40135 }
40136 Z_ADDREF_P(array_ref);
40137 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
40138 } else {
40139 array_ptr = EX_VAR(opline->result.var);
40140 ZVAL_COPY_VALUE(array_ptr, array_ref);
40141 }
40142 if (Z_OBJ_P(array_ptr)->properties
40143 && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) {
40144 if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) {
40145 GC_DELREF(Z_OBJ_P(array_ptr)->properties);
40146 }
40147 Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties);
40148 }
40149
40150 properties = Z_OBJPROP_P(array_ptr);
40151 if (zend_hash_num_elements(properties) == 0) {
40152 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1;
40153
40154 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
40155 }
40156
40157 Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0);
40158
40159 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40160 } else {
40161 bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC);
40162
40163 if (UNEXPECTED(EG(exception))) {
40164 HANDLE_EXCEPTION();
40165 } else if (is_empty) {
40166 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40167 } else {
40168 ZEND_VM_NEXT_OPCODE();
40169 }
40170 }
40171 } else {
40172 zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr));
40173 ZVAL_UNDEF(EX_VAR(opline->result.var));
40174 Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1;
40175
40176 ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2));
40177 }
40178 }
40179
ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40180 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40181 {
40182 USE_OPLINE
40183 zval *value;
40184 zend_reference *ref = NULL;
40185 bool ret;
40186
40187 SAVE_OPLINE();
40188 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40189
40190 if ((IS_CV == IS_VAR || IS_CV == IS_CV) && Z_ISREF_P(value)) {
40191 if (IS_CV == IS_VAR) {
40192 ref = Z_REF_P(value);
40193 }
40194 value = Z_REFVAL_P(value);
40195 }
40196
40197 ret = i_zend_is_true(value);
40198
40199 if (UNEXPECTED(EG(exception))) {
40200
40201 ZVAL_UNDEF(EX_VAR(opline->result.var));
40202 HANDLE_EXCEPTION();
40203 }
40204
40205 if (ret) {
40206 zval *result = EX_VAR(opline->result.var);
40207
40208 ZVAL_COPY_VALUE(result, value);
40209 if (IS_CV == IS_CONST) {
40210 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
40211 } else if (IS_CV == IS_CV) {
40212 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
40213 } else if (IS_CV == IS_VAR && ref) {
40214 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40215 efree_size(ref, sizeof(zend_reference));
40216 } else if (Z_OPT_REFCOUNTED_P(result)) {
40217 Z_ADDREF_P(result);
40218 }
40219 }
40220 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40221 }
40222
40223 ZEND_VM_NEXT_OPCODE();
40224 }
40225
ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40226 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40227 {
40228 USE_OPLINE
40229 zval *value;
40230 zend_reference *ref = NULL;
40231
40232 SAVE_OPLINE();
40233 value = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
40234
40235 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
40236 if (IS_CV & IS_VAR) {
40237 ref = Z_REF_P(value);
40238 }
40239 value = Z_REFVAL_P(value);
40240 }
40241
40242 if (Z_TYPE_P(value) > IS_NULL) {
40243 zval *result = EX_VAR(opline->result.var);
40244 ZVAL_COPY_VALUE(result, value);
40245 if (IS_CV == IS_CONST) {
40246 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result);
40247 } else if (IS_CV == IS_CV) {
40248 if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result);
40249 } else if ((IS_CV & IS_VAR) && ref) {
40250 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40251 efree_size(ref, sizeof(zend_reference));
40252 } else if (Z_OPT_REFCOUNTED_P(result)) {
40253 Z_ADDREF_P(result);
40254 }
40255 }
40256 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40257 }
40258
40259 if ((IS_CV & IS_VAR) && ref) {
40260 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
40261 efree_size(ref, sizeof(zend_reference));
40262 }
40263 }
40264 ZEND_VM_NEXT_OPCODE();
40265 }
40266
ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40267 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40268 {
40269 USE_OPLINE
40270 zval *val, *result;
40271
40272 val = EX_VAR(opline->op1.var);
40273
40274 if (Z_TYPE_P(val) > IS_NULL) {
40275 do {
40276 if ((IS_CV == IS_CV || IS_CV == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) {
40277 val = Z_REFVAL_P(val);
40278 if (Z_TYPE_P(val) <= IS_NULL) {
40279
40280 break;
40281 }
40282 }
40283 ZEND_VM_NEXT_OPCODE();
40284 } while (0);
40285 }
40286
40287 result = EX_VAR(opline->result.var);
40288 uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK;
40289 if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) {
40290 ZVAL_NULL(result);
40291 if (IS_CV == IS_CV
40292 && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF)
40293 && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0
40294 ) {
40295 SAVE_OPLINE();
40296 ZVAL_UNDEFINED_OP1();
40297 if (UNEXPECTED(EG(exception) != NULL)) {
40298 HANDLE_EXCEPTION();
40299 }
40300 }
40301 } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
40302 ZVAL_FALSE(result);
40303 } else {
40304 ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
40305 ZVAL_TRUE(result);
40306 }
40307
40308 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0);
40309 }
40310
ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40311 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40312 {
40313 USE_OPLINE
40314 zval *value;
40315 zval *result = EX_VAR(opline->result.var);
40316
40317 value = EX_VAR(opline->op1.var);
40318 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
40319 SAVE_OPLINE();
40320 ZVAL_UNDEFINED_OP1();
40321 ZVAL_NULL(result);
40322 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40323 }
40324
40325 if (IS_CV == IS_CV) {
40326 ZVAL_COPY_DEREF(result, value);
40327 } else if (IS_CV == IS_VAR) {
40328 if (UNEXPECTED(Z_ISREF_P(value))) {
40329 ZVAL_COPY_VALUE(result, Z_REFVAL_P(value));
40330 if (UNEXPECTED(Z_DELREF_P(value) == 0)) {
40331 efree_size(Z_REF_P(value), sizeof(zend_reference));
40332 } else if (Z_OPT_REFCOUNTED_P(result)) {
40333 Z_ADDREF_P(result);
40334 }
40335 } else {
40336 ZVAL_COPY_VALUE(result, value);
40337 }
40338 } else {
40339 ZVAL_COPY_VALUE(result, value);
40340 if (IS_CV == IS_CONST) {
40341 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) {
40342 Z_ADDREF_P(result);
40343 }
40344 }
40345 }
40346 ZEND_VM_NEXT_OPCODE();
40347 }
40348
ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40349 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40350 {
40351 USE_OPLINE
40352 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
40353 zval *val;
40354
40355 SAVE_OPLINE();
40356 val = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40357
40358 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
40359 zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator");
40360
40361 UNDEF_RESULT();
40362 HANDLE_EXCEPTION();
40363 }
40364
40365 yield_from_try_again:
40366 if (Z_TYPE_P(val) == IS_ARRAY) {
40367 ZVAL_COPY_VALUE(&generator->values, val);
40368 if (Z_OPT_REFCOUNTED_P(val)) {
40369 Z_ADDREF_P(val);
40370 }
40371 Z_FE_POS(generator->values) = 0;
40372
40373 } else if (IS_CV != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) {
40374 zend_class_entry *ce = Z_OBJCE_P(val);
40375 if (ce == zend_ce_generator) {
40376 zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val);
40377
40378 Z_ADDREF_P(val);
40379
40380 if (UNEXPECTED(new_gen->execute_data == NULL)) {
40381 zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue");
40382 zval_ptr_dtor(val);
40383 UNDEF_RESULT();
40384 HANDLE_EXCEPTION();
40385 } else if (Z_ISUNDEF(new_gen->retval)) {
40386 if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) {
40387 zend_throw_error(NULL, "Impossible to yield from the Generator being currently run");
40388 zval_ptr_dtor(val);
40389 UNDEF_RESULT();
40390 HANDLE_EXCEPTION();
40391 } else {
40392 zend_generator_yield_from(generator, new_gen);
40393 }
40394 } else {
40395 if (RETURN_VALUE_USED(opline)) {
40396 ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval);
40397 }
40398 ZEND_VM_NEXT_OPCODE();
40399 }
40400 } else {
40401 zend_object_iterator *iter = ce->get_iterator(ce, val, 0);
40402
40403 if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) {
40404 if (!EG(exception)) {
40405 zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name));
40406 }
40407 UNDEF_RESULT();
40408 HANDLE_EXCEPTION();
40409 }
40410
40411 iter->index = 0;
40412 if (iter->funcs->rewind) {
40413 iter->funcs->rewind(iter);
40414 if (UNEXPECTED(EG(exception) != NULL)) {
40415 OBJ_RELEASE(&iter->std);
40416 UNDEF_RESULT();
40417 HANDLE_EXCEPTION();
40418 }
40419 }
40420
40421 ZVAL_OBJ(&generator->values, &iter->std);
40422 }
40423 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) {
40424 val = Z_REFVAL_P(val);
40425 goto yield_from_try_again;
40426 } else {
40427 zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables");
40428
40429 UNDEF_RESULT();
40430 HANDLE_EXCEPTION();
40431 }
40432
40433 /* This is the default return value
40434 * when the expression is a Generator, it will be overwritten in zend_generator_resume() */
40435 if (RETURN_VALUE_USED(opline)) {
40436 ZVAL_NULL(EX_VAR(opline->result.var));
40437 }
40438
40439 /* This generator has no send target (though the generator we delegate to might have one) */
40440 generator->send_target = NULL;
40441
40442 /* We increment to the next op, so we are at the correct position when the
40443 * generator is resumed. */
40444 ZEND_VM_INC_OPCODE();
40445
40446 /* The GOTO VM uses a local opline variable. We need to set the opline
40447 * variable in execute_data so we don't resume at an old position. */
40448 SAVE_OPLINE();
40449
40450 ZEND_VM_RETURN();
40451 }
40452
ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40453 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40454 {
40455 USE_OPLINE
40456 zval *value;
40457
40458 value = EX_VAR(opline->op1.var);
40459 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
40460 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
40461 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
40462 zval_ptr_dtor_str(value);
40463 }
40464 ZEND_VM_NEXT_OPCODE();
40465 } else {
40466 bool strict;
40467
40468 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) {
40469 value = Z_REFVAL_P(value);
40470 if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) {
40471 ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value));
40472
40473 ZEND_VM_NEXT_OPCODE();
40474 }
40475 }
40476
40477 SAVE_OPLINE();
40478 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
40479 value = ZVAL_UNDEFINED_OP1();
40480 }
40481 strict = EX_USES_STRICT_TYPES();
40482 do {
40483 if (EXPECTED(!strict)) {
40484 zend_string *str;
40485 zval tmp;
40486
40487 if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) {
40488 zend_error(E_DEPRECATED,
40489 "strlen(): Passing null to parameter #1 ($string) of type string is deprecated");
40490 ZVAL_LONG(EX_VAR(opline->result.var), 0);
40491 if (UNEXPECTED(EG(exception))) {
40492 HANDLE_EXCEPTION();
40493 }
40494 break;
40495 }
40496
40497 ZVAL_COPY(&tmp, value);
40498 if (zend_parse_arg_str_weak(&tmp, &str, 1)) {
40499 ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str));
40500 zval_ptr_dtor(&tmp);
40501 break;
40502 }
40503 zval_ptr_dtor(&tmp);
40504 }
40505 if (!EG(exception)) {
40506 zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value));
40507 }
40508 ZVAL_UNDEF(EX_VAR(opline->result.var));
40509 } while (0);
40510 }
40511
40512 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40513 }
40514
ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40515 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40516 {
40517 USE_OPLINE
40518 zval *value;
40519 int result = 0;
40520
40521 value = EX_VAR(opline->op1.var);
40522 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
40523 type_check_resource:
40524 if (opline->extended_value != MAY_BE_RESOURCE
40525 || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) {
40526 result = 1;
40527 }
40528 } else if ((IS_CV & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) {
40529 value = Z_REFVAL_P(value);
40530 if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) {
40531 goto type_check_resource;
40532 }
40533 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
40534 result = ((1 << IS_NULL) & opline->extended_value) != 0;
40535 SAVE_OPLINE();
40536 ZVAL_UNDEFINED_OP1();
40537 if (UNEXPECTED(EG(exception))) {
40538 ZVAL_UNDEF(EX_VAR(opline->result.var));
40539 HANDLE_EXCEPTION();
40540 }
40541 }
40542 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
40543 SAVE_OPLINE();
40544
40545 ZEND_VM_SMART_BRANCH(result, 1);
40546 } else {
40547 ZEND_VM_SMART_BRANCH(result, 0);
40548 }
40549 }
40550
ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40551 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40552 {
40553 uint32_t fetch_type;
40554 zend_class_entry *called_scope, *scope;
40555 USE_OPLINE
40556
40557 if (IS_CV != IS_UNUSED) {
40558 SAVE_OPLINE();
40559 zval *op = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40560 if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) {
40561 ZVAL_DEREF(op);
40562 if (Z_TYPE_P(op) != IS_OBJECT) {
40563 zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op));
40564 ZVAL_UNDEF(EX_VAR(opline->result.var));
40565
40566 HANDLE_EXCEPTION();
40567 }
40568 }
40569
40570 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name);
40571
40572 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40573 }
40574
40575 fetch_type = opline->op1.num;
40576 scope = EX(func)->op_array.scope;
40577 if (UNEXPECTED(scope == NULL)) {
40578 SAVE_OPLINE();
40579 zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
40580 fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
40581 fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
40582 ZVAL_UNDEF(EX_VAR(opline->result.var));
40583 HANDLE_EXCEPTION();
40584 }
40585
40586 switch (fetch_type) {
40587 case ZEND_FETCH_CLASS_SELF:
40588 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name);
40589 break;
40590 case ZEND_FETCH_CLASS_PARENT:
40591 if (UNEXPECTED(scope->parent == NULL)) {
40592 SAVE_OPLINE();
40593 zend_throw_error(NULL,
40594 "Cannot use \"parent\" when current class scope has no parent");
40595 ZVAL_UNDEF(EX_VAR(opline->result.var));
40596 HANDLE_EXCEPTION();
40597 }
40598 ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name);
40599 break;
40600 case ZEND_FETCH_CLASS_STATIC:
40601 if (Z_TYPE(EX(This)) == IS_OBJECT) {
40602 called_scope = Z_OBJCE(EX(This));
40603 } else {
40604 called_scope = Z_CE(EX(This));
40605 }
40606 ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name);
40607 break;
40608 EMPTY_SWITCH_DEFAULT_CASE()
40609 }
40610 ZEND_VM_NEXT_OPCODE();
40611 }
40612
ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40613 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40614 {
40615 USE_OPLINE
40616 HashTable *ht;
40617 zval *value;
40618 zval *variable_ptr;
40619
40620 variable_ptr = EX_VAR(opline->op1.var);
40621
40622 SAVE_OPLINE();
40623
40624 ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
40625 if (!ht) {
40626 ht = zend_array_dup(EX(func)->op_array.static_variables);
40627 ZEND_MAP_PTR_SET(EX(func)->op_array.static_variables_ptr, ht);
40628 }
40629 ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
40630
40631 value = (zval*)((char*)ht->arData + (opline->extended_value & ~(ZEND_BIND_REF|ZEND_BIND_IMPLICIT|ZEND_BIND_EXPLICIT)));
40632
40633 if (opline->extended_value & ZEND_BIND_REF) {
40634 i_zval_ptr_dtor(variable_ptr);
40635 if (UNEXPECTED(!Z_ISREF_P(value))) {
40636 zend_reference *ref = (zend_reference*)emalloc(sizeof(zend_reference));
40637 GC_SET_REFCOUNT(ref, 2);
40638 GC_TYPE_INFO(ref) = GC_REFERENCE;
40639 if (opline->op2_type == IS_UNUSED) {
40640 ZVAL_COPY_VALUE(&ref->val, value);
40641 } else {
40642 ZEND_ASSERT(!Z_REFCOUNTED_P(value));
40643 ZVAL_COPY(&ref->val, get_zval_ptr_deref(opline->op2_type, opline->op2, BP_VAR_R));
40644 FREE_OP(opline->op2_type, opline->op2.var);
40645 }
40646 ref->sources.ptr = NULL;
40647 Z_REF_P(value) = ref;
40648 Z_TYPE_INFO_P(value) = IS_REFERENCE_EX;
40649 ZVAL_REF(variable_ptr, ref);
40650 } else {
40651 Z_ADDREF_P(value);
40652 ZVAL_REF(variable_ptr, Z_REF_P(value));
40653 if (opline->op2_type != IS_UNUSED) {
40654 FREE_OP(opline->op2_type, opline->op2.var);
40655 }
40656 }
40657 } else {
40658 i_zval_ptr_dtor(variable_ptr);
40659 ZVAL_COPY(variable_ptr, value);
40660 }
40661
40662 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40663 }
40664
ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40665 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40666 {
40667 USE_OPLINE
40668 HashTable *ht;
40669 zval *value;
40670 zval *variable_ptr;
40671
40672 variable_ptr = EX_VAR(opline->op1.var);
40673
40674 ht = ZEND_MAP_PTR_GET(EX(func)->op_array.static_variables_ptr);
40675 if (!ht) {
40676 ZEND_VM_NEXT_OPCODE();
40677 }
40678 ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
40679
40680 value = (zval*)((char*)ht->arData + opline->extended_value);
40681 if (Z_TYPE_EXTRA_P(value) & IS_STATIC_VAR_UNINITIALIZED) {
40682 ZEND_VM_NEXT_OPCODE();
40683 } else {
40684 SAVE_OPLINE();
40685 zval_ptr_dtor(variable_ptr);
40686 ZEND_ASSERT(Z_TYPE_P(value) == IS_REFERENCE);
40687 Z_ADDREF_P(value);
40688 ZVAL_REF(variable_ptr, Z_REF_P(value));
40689 ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 1);
40690 }
40691 }
40692
ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40693 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)
40694 {
40695 USE_OPLINE
40696 zval *var_ptr;
40697
40698 var_ptr = EX_VAR(opline->op1.var);
40699 Z_LVAL_P(var_ptr)++;
40700 if (UNEXPECTED(0)) {
40701 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40702 }
40703 ZEND_VM_NEXT_OPCODE();
40704 }
40705
ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40706 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)
40707 {
40708 USE_OPLINE
40709 zval *var_ptr;
40710
40711 var_ptr = EX_VAR(opline->op1.var);
40712 Z_LVAL_P(var_ptr)++;
40713 if (UNEXPECTED(1)) {
40714 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40715 }
40716 ZEND_VM_NEXT_OPCODE();
40717 }
40718
ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40719 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40720 {
40721 USE_OPLINE
40722 zval *var_ptr;
40723
40724 var_ptr = EX_VAR(opline->op1.var);
40725 fast_long_increment_function(var_ptr);
40726 if (UNEXPECTED(0)) {
40727 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40728 }
40729 ZEND_VM_NEXT_OPCODE();
40730 }
40731
ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40732 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40733 {
40734 USE_OPLINE
40735 zval *var_ptr;
40736
40737 var_ptr = EX_VAR(opline->op1.var);
40738 fast_long_increment_function(var_ptr);
40739 if (UNEXPECTED(1)) {
40740 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40741 }
40742 ZEND_VM_NEXT_OPCODE();
40743 }
40744
ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40745 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)
40746 {
40747 USE_OPLINE
40748 zval *var_ptr;
40749
40750 var_ptr = EX_VAR(opline->op1.var);
40751 Z_LVAL_P(var_ptr)--;
40752 if (UNEXPECTED(0)) {
40753 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40754 }
40755 ZEND_VM_NEXT_OPCODE();
40756 }
40757
ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40758 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)
40759 {
40760 USE_OPLINE
40761 zval *var_ptr;
40762
40763 var_ptr = EX_VAR(opline->op1.var);
40764 Z_LVAL_P(var_ptr)--;
40765 if (UNEXPECTED(1)) {
40766 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40767 }
40768 ZEND_VM_NEXT_OPCODE();
40769 }
40770
ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40771 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40772 {
40773 USE_OPLINE
40774 zval *var_ptr;
40775
40776 var_ptr = EX_VAR(opline->op1.var);
40777 fast_long_decrement_function(var_ptr);
40778 if (UNEXPECTED(0)) {
40779 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40780 }
40781 ZEND_VM_NEXT_OPCODE();
40782 }
40783
ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40784 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40785 {
40786 USE_OPLINE
40787 zval *var_ptr;
40788
40789 var_ptr = EX_VAR(opline->op1.var);
40790 fast_long_decrement_function(var_ptr);
40791 if (UNEXPECTED(1)) {
40792 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
40793 }
40794 ZEND_VM_NEXT_OPCODE();
40795 }
40796
ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40797 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40798 {
40799 USE_OPLINE
40800 zval *var_ptr;
40801
40802 var_ptr = EX_VAR(opline->op1.var);
40803 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40804 Z_LVAL_P(var_ptr)++;
40805 ZEND_VM_NEXT_OPCODE();
40806 }
40807
ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40808 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40809 {
40810 USE_OPLINE
40811 zval *var_ptr;
40812
40813 var_ptr = EX_VAR(opline->op1.var);
40814 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40815 fast_long_increment_function(var_ptr);
40816 ZEND_VM_NEXT_OPCODE();
40817 }
40818
ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40819 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40820 {
40821 USE_OPLINE
40822 zval *var_ptr;
40823
40824 var_ptr = EX_VAR(opline->op1.var);
40825 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40826 Z_LVAL_P(var_ptr)--;
40827 ZEND_VM_NEXT_OPCODE();
40828 }
40829
ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40830 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40831 {
40832 USE_OPLINE
40833 zval *var_ptr;
40834
40835 var_ptr = EX_VAR(opline->op1.var);
40836 ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
40837 fast_long_decrement_function(var_ptr);
40838 ZEND_VM_NEXT_OPCODE();
40839 }
40840
ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40841 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40842 {
40843 USE_OPLINE
40844 zval *varptr, *arg;
40845
40846 varptr = EX_VAR(opline->op1.var);
40847 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
40848
40849 if (IS_CV == IS_CV) {
40850 ZVAL_COPY(arg, varptr);
40851 } else /* if (IS_CV == IS_VAR) */ {
40852 ZVAL_COPY_VALUE(arg, varptr);
40853 }
40854
40855 ZEND_VM_NEXT_OPCODE();
40856 }
40857
ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40858 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40859 {
40860 USE_OPLINE
40861 zval *op1, *op2;
40862
40863 SAVE_OPLINE();
40864 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40865 op2 = RT_CONSTANT(opline, opline->op2);
40866 div_function(EX_VAR(opline->result.var), op1, op2);
40867
40868
40869 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40870 }
40871
ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40872 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40873 {
40874 USE_OPLINE
40875 zval *op1, *op2;
40876
40877 SAVE_OPLINE();
40878 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40879 op2 = RT_CONSTANT(opline, opline->op2);
40880 pow_function(EX_VAR(opline->result.var), op1, op2);
40881
40882
40883 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40884 }
40885
ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40886 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40887 {
40888 USE_OPLINE
40889 zval *op1, *op2;
40890
40891 op1 = EX_VAR(opline->op1.var);
40892 op2 = RT_CONSTANT(opline, opline->op2);
40893
40894 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
40895 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
40896 zend_string *op1_str = Z_STR_P(op1);
40897 zend_string *op2_str = Z_STR_P(op2);
40898 zend_string *str;
40899 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
40900
40901 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
40902 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
40903 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
40904 } else {
40905 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
40906 }
40907 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
40908 zend_string_release_ex(op1_str, 0);
40909 }
40910 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
40911 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
40912 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
40913 } else {
40914 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
40915 }
40916 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
40917 zend_string_release_ex(op2_str, 0);
40918 }
40919 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
40920 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
40921 size_t len = ZSTR_LEN(op1_str);
40922
40923 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
40924 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
40925 }
40926 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
40927 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
40928 GC_ADD_FLAGS(str, flags);
40929 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
40930 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
40931 zend_string_release_ex(op2_str, 0);
40932 }
40933 } else {
40934 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
40935 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
40936 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
40937 GC_ADD_FLAGS(str, flags);
40938 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
40939 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
40940 zend_string_release_ex(op1_str, 0);
40941 }
40942 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
40943 zend_string_release_ex(op2_str, 0);
40944 }
40945 }
40946 ZEND_VM_NEXT_OPCODE();
40947 } else {
40948 SAVE_OPLINE();
40949
40950 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
40951 op1 = ZVAL_UNDEFINED_OP1();
40952 }
40953 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
40954 op2 = ZVAL_UNDEFINED_OP2();
40955 }
40956 concat_function(EX_VAR(opline->result.var), op1, op2);
40957
40958
40959 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
40960 }
40961 }
40962
ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40963 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40964 {
40965 USE_OPLINE
40966 zval *op1, *op2;
40967 bool result;
40968
40969 SAVE_OPLINE();
40970 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40971 op2 = RT_CONSTANT(opline, opline->op2);
40972 result = fast_is_identical_function(op1, op2);
40973
40974
40975 ZEND_VM_SMART_BRANCH(result, 1);
40976 }
40977
ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40978 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40979 {
40980 USE_OPLINE
40981 zval *op1, *op2;
40982 bool result;
40983
40984 SAVE_OPLINE();
40985 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
40986 op2 = RT_CONSTANT(opline, opline->op2);
40987 result = fast_is_not_identical_function(op1, op2);
40988
40989
40990 ZEND_VM_SMART_BRANCH(result, 1);
40991 }
40992
ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)40993 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
40994 {
40995 USE_OPLINE
40996 zval *op1, *op2;
40997 double d1, d2;
40998
40999 op1 = EX_VAR(opline->op1.var);
41000 op2 = RT_CONSTANT(opline, opline->op2);
41001 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41002 /* pass */
41003 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41004 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41005 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
41006 is_equal_true:
41007 ZEND_VM_SMART_BRANCH_TRUE_NONE();
41008 } else {
41009 is_equal_false:
41010 ZEND_VM_SMART_BRANCH_FALSE_NONE();
41011 }
41012 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41013 d1 = (double)Z_LVAL_P(op1);
41014 d2 = Z_DVAL_P(op2);
41015 goto is_equal_double;
41016 }
41017 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41018 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41019 d1 = Z_DVAL_P(op1);
41020 d2 = Z_DVAL_P(op2);
41021 is_equal_double:
41022 if (d1 == d2) {
41023 goto is_equal_true;
41024 } else {
41025 goto is_equal_false;
41026 }
41027 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41028 d1 = Z_DVAL_P(op1);
41029 d2 = (double)Z_LVAL_P(op2);
41030 goto is_equal_double;
41031 }
41032 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41033 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41034 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41035 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41036 zval_ptr_dtor_str(op1);
41037 }
41038 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41039 zval_ptr_dtor_str(op2);
41040 }
41041 if (result) {
41042 goto is_equal_true;
41043 } else {
41044 goto is_equal_false;
41045 }
41046 }
41047 }
41048 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41049 }
41050
ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41051 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41052 {
41053 USE_OPLINE
41054 zval *op1, *op2;
41055 double d1, d2;
41056
41057 op1 = EX_VAR(opline->op1.var);
41058 op2 = RT_CONSTANT(opline, opline->op2);
41059 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41060 /* pass */
41061 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41062 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41063 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
41064 is_equal_true:
41065 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
41066 } else {
41067 is_equal_false:
41068 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
41069 }
41070 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41071 d1 = (double)Z_LVAL_P(op1);
41072 d2 = Z_DVAL_P(op2);
41073 goto is_equal_double;
41074 }
41075 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41076 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41077 d1 = Z_DVAL_P(op1);
41078 d2 = Z_DVAL_P(op2);
41079 is_equal_double:
41080 if (d1 == d2) {
41081 goto is_equal_true;
41082 } else {
41083 goto is_equal_false;
41084 }
41085 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41086 d1 = Z_DVAL_P(op1);
41087 d2 = (double)Z_LVAL_P(op2);
41088 goto is_equal_double;
41089 }
41090 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41091 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41092 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41093 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41094 zval_ptr_dtor_str(op1);
41095 }
41096 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41097 zval_ptr_dtor_str(op2);
41098 }
41099 if (result) {
41100 goto is_equal_true;
41101 } else {
41102 goto is_equal_false;
41103 }
41104 }
41105 }
41106 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41107 }
41108
ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41109 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41110 {
41111 USE_OPLINE
41112 zval *op1, *op2;
41113 double d1, d2;
41114
41115 op1 = EX_VAR(opline->op1.var);
41116 op2 = RT_CONSTANT(opline, opline->op2);
41117 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41118 /* pass */
41119 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41120 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41121 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
41122 is_equal_true:
41123 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
41124 } else {
41125 is_equal_false:
41126 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
41127 }
41128 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41129 d1 = (double)Z_LVAL_P(op1);
41130 d2 = Z_DVAL_P(op2);
41131 goto is_equal_double;
41132 }
41133 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41134 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41135 d1 = Z_DVAL_P(op1);
41136 d2 = Z_DVAL_P(op2);
41137 is_equal_double:
41138 if (d1 == d2) {
41139 goto is_equal_true;
41140 } else {
41141 goto is_equal_false;
41142 }
41143 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41144 d1 = Z_DVAL_P(op1);
41145 d2 = (double)Z_LVAL_P(op2);
41146 goto is_equal_double;
41147 }
41148 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41149 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41150 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41151 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41152 zval_ptr_dtor_str(op1);
41153 }
41154 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41155 zval_ptr_dtor_str(op2);
41156 }
41157 if (result) {
41158 goto is_equal_true;
41159 } else {
41160 goto is_equal_false;
41161 }
41162 }
41163 }
41164 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41165 }
41166
ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41167 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41168 {
41169 USE_OPLINE
41170 zval *op1, *op2;
41171 double d1, d2;
41172
41173 op1 = EX_VAR(opline->op1.var);
41174 op2 = RT_CONSTANT(opline, opline->op2);
41175 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41176 /* pass */
41177 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41178 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41179 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
41180 is_not_equal_true:
41181 ZEND_VM_SMART_BRANCH_TRUE_NONE();
41182 } else {
41183 is_not_equal_false:
41184 ZEND_VM_SMART_BRANCH_FALSE_NONE();
41185 }
41186 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41187 d1 = (double)Z_LVAL_P(op1);
41188 d2 = Z_DVAL_P(op2);
41189 goto is_not_equal_double;
41190 }
41191 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41192 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41193 d1 = Z_DVAL_P(op1);
41194 d2 = Z_DVAL_P(op2);
41195 is_not_equal_double:
41196 if (d1 != d2) {
41197 goto is_not_equal_true;
41198 } else {
41199 goto is_not_equal_false;
41200 }
41201 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41202 d1 = Z_DVAL_P(op1);
41203 d2 = (double)Z_LVAL_P(op2);
41204 goto is_not_equal_double;
41205 }
41206 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41207 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41208 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41209 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41210 zval_ptr_dtor_str(op1);
41211 }
41212 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41213 zval_ptr_dtor_str(op2);
41214 }
41215 if (!result) {
41216 goto is_not_equal_true;
41217 } else {
41218 goto is_not_equal_false;
41219 }
41220 }
41221 }
41222 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41223 }
41224
ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41225 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41226 {
41227 USE_OPLINE
41228 zval *op1, *op2;
41229 double d1, d2;
41230
41231 op1 = EX_VAR(opline->op1.var);
41232 op2 = RT_CONSTANT(opline, opline->op2);
41233 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41234 /* pass */
41235 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41236 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41237 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
41238 is_not_equal_true:
41239 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
41240 } else {
41241 is_not_equal_false:
41242 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
41243 }
41244 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41245 d1 = (double)Z_LVAL_P(op1);
41246 d2 = Z_DVAL_P(op2);
41247 goto is_not_equal_double;
41248 }
41249 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41250 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41251 d1 = Z_DVAL_P(op1);
41252 d2 = Z_DVAL_P(op2);
41253 is_not_equal_double:
41254 if (d1 != d2) {
41255 goto is_not_equal_true;
41256 } else {
41257 goto is_not_equal_false;
41258 }
41259 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41260 d1 = Z_DVAL_P(op1);
41261 d2 = (double)Z_LVAL_P(op2);
41262 goto is_not_equal_double;
41263 }
41264 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41265 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41266 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41267 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41268 zval_ptr_dtor_str(op1);
41269 }
41270 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41271 zval_ptr_dtor_str(op2);
41272 }
41273 if (!result) {
41274 goto is_not_equal_true;
41275 } else {
41276 goto is_not_equal_false;
41277 }
41278 }
41279 }
41280 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41281 }
41282
ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41283 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41284 {
41285 USE_OPLINE
41286 zval *op1, *op2;
41287 double d1, d2;
41288
41289 op1 = EX_VAR(opline->op1.var);
41290 op2 = RT_CONSTANT(opline, opline->op2);
41291 if (1 && IS_CV == IS_CONST && IS_CONST == IS_CONST) {
41292 /* pass */
41293 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
41294 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41295 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
41296 is_not_equal_true:
41297 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
41298 } else {
41299 is_not_equal_false:
41300 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
41301 }
41302 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41303 d1 = (double)Z_LVAL_P(op1);
41304 d2 = Z_DVAL_P(op2);
41305 goto is_not_equal_double;
41306 }
41307 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
41308 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
41309 d1 = Z_DVAL_P(op1);
41310 d2 = Z_DVAL_P(op2);
41311 is_not_equal_double:
41312 if (d1 != d2) {
41313 goto is_not_equal_true;
41314 } else {
41315 goto is_not_equal_false;
41316 }
41317 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
41318 d1 = Z_DVAL_P(op1);
41319 d2 = (double)Z_LVAL_P(op2);
41320 goto is_not_equal_double;
41321 }
41322 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
41323 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
41324 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
41325 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
41326 zval_ptr_dtor_str(op1);
41327 }
41328 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
41329 zval_ptr_dtor_str(op2);
41330 }
41331 if (!result) {
41332 goto is_not_equal_true;
41333 } else {
41334 goto is_not_equal_false;
41335 }
41336 }
41337 }
41338 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
41339 }
41340
ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41341 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41342 {
41343 USE_OPLINE
41344 zval *op1, *op2;
41345
41346 SAVE_OPLINE();
41347 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41348 op2 = RT_CONSTANT(opline, opline->op2);
41349 compare_function(EX_VAR(opline->result.var), op1, op2);
41350
41351
41352 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41353 }
41354
ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41355 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41356 {
41357 USE_OPLINE
41358 zval *op1, *op2;
41359
41360 SAVE_OPLINE();
41361 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
41362 op2 = RT_CONSTANT(opline, opline->op2);
41363 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
41364
41365
41366 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41367 }
41368
ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41369 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41370 {
41371 USE_OPLINE
41372 zval *object;
41373 zval *property;
41374 zval *value;
41375 zval *zptr;
41376 void **cache_slot;
41377 zend_property_info *prop_info;
41378 zend_object *zobj;
41379 zend_string *name, *tmp_name;
41380
41381 SAVE_OPLINE();
41382 object = EX_VAR(opline->op1.var);
41383 property = RT_CONSTANT(opline, opline->op2);
41384
41385 do {
41386 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
41387
41388 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
41389 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
41390 object = Z_REFVAL_P(object);
41391 goto assign_op_object;
41392 }
41393 if (IS_CV == IS_CV
41394 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
41395 ZVAL_UNDEFINED_OP1();
41396 }
41397 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
41398 break;
41399 }
41400
41401 assign_op_object:
41402 /* here we are sure we are dealing with an object */
41403 zobj = Z_OBJ_P(object);
41404 if (IS_CONST == IS_CONST) {
41405 name = Z_STR_P(property);
41406 } else {
41407 name = zval_try_get_tmp_string(property, &tmp_name);
41408 if (UNEXPECTED(!name)) {
41409 UNDEF_RESULT();
41410 break;
41411 }
41412 }
41413 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
41414 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
41415 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
41416 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41417 ZVAL_NULL(EX_VAR(opline->result.var));
41418 }
41419 } else {
41420 zval *orig_zptr = zptr;
41421 zend_reference *ref;
41422
41423 do {
41424 if (UNEXPECTED(Z_ISREF_P(zptr))) {
41425 ref = Z_REF_P(zptr);
41426 zptr = Z_REFVAL_P(zptr);
41427 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
41428 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
41429 break;
41430 }
41431 }
41432
41433 if (IS_CONST == IS_CONST) {
41434 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
41435 } else {
41436 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
41437 }
41438 if (prop_info) {
41439 /* special case for typed properties */
41440 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
41441 } else {
41442 zend_binary_op(zptr, zptr, value OPLINE_CC);
41443 }
41444 } while (0);
41445
41446 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41447 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
41448 }
41449 }
41450 } else {
41451 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
41452 }
41453 if (IS_CONST != IS_CONST) {
41454 zend_tmp_string_release(tmp_name);
41455 }
41456 } while (0);
41457
41458 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
41459
41460
41461 /* assign_obj has two opcodes! */
41462 ZEND_VM_NEXT_OPCODE_EX(1, 2);
41463 }
41464
41465 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41466 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41467 {
41468 USE_OPLINE
41469 zval *var_ptr;
41470 zval *value, *container, *dim;
41471 HashTable *ht;
41472
41473 SAVE_OPLINE();
41474 container = EX_VAR(opline->op1.var);
41475
41476 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
41477 assign_dim_op_array:
41478 SEPARATE_ARRAY(container);
41479 ht = Z_ARRVAL_P(container);
41480 assign_dim_op_new_array:
41481 dim = RT_CONSTANT(opline, opline->op2);
41482 if (IS_CONST == IS_UNUSED) {
41483 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
41484 if (UNEXPECTED(!var_ptr)) {
41485 zend_cannot_add_element();
41486 goto assign_dim_op_ret_null;
41487 }
41488 } else {
41489 if (IS_CONST == IS_CONST) {
41490 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
41491 } else {
41492 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
41493 }
41494 if (UNEXPECTED(!var_ptr)) {
41495 goto assign_dim_op_ret_null;
41496 }
41497 }
41498
41499 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
41500
41501 do {
41502 if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
41503 zend_reference *ref = Z_REF_P(var_ptr);
41504 var_ptr = Z_REFVAL_P(var_ptr);
41505 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
41506 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
41507 break;
41508 }
41509 }
41510 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
41511 } while (0);
41512
41513 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41514 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
41515 }
41516 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
41517 } else {
41518 if (EXPECTED(Z_ISREF_P(container))) {
41519 container = Z_REFVAL_P(container);
41520 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
41521 goto assign_dim_op_array;
41522 }
41523 }
41524
41525 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
41526 zend_object *obj = Z_OBJ_P(container);
41527
41528 dim = RT_CONSTANT(opline, opline->op2);
41529 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
41530 dim++;
41531 }
41532 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
41533 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
41534 uint8_t old_type;
41535
41536 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
41537 ZVAL_UNDEFINED_OP1();
41538 }
41539 ht = zend_new_array(8);
41540 old_type = Z_TYPE_P(container);
41541 ZVAL_ARR(container, ht);
41542 if (UNEXPECTED(old_type == IS_FALSE)) {
41543 GC_ADDREF(ht);
41544 zend_false_to_array_deprecated();
41545 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
41546 zend_array_destroy(ht);
41547 goto assign_dim_op_ret_null;
41548 }
41549 }
41550 goto assign_dim_op_new_array;
41551 } else {
41552 dim = RT_CONSTANT(opline, opline->op2);
41553 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
41554 assign_dim_op_ret_null:
41555 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
41556 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41557 ZVAL_NULL(EX_VAR(opline->result.var));
41558 }
41559 }
41560 }
41561
41562
41563 ZEND_VM_NEXT_OPCODE_EX(1, 2);
41564 }
41565
ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41566 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41567 {
41568 USE_OPLINE
41569 zval *var_ptr;
41570 zval *value;
41571
41572 SAVE_OPLINE();
41573 value = RT_CONSTANT(opline, opline->op2);
41574 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
41575
41576 do {
41577 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
41578 zend_reference *ref = Z_REF_P(var_ptr);
41579 var_ptr = Z_REFVAL_P(var_ptr);
41580 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
41581 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
41582 break;
41583 }
41584 }
41585 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
41586 } while (0);
41587
41588 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41589 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
41590 }
41591
41592
41593 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41594 }
41595
ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41596 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41597 {
41598 USE_OPLINE
41599 zval *object;
41600 zval *property;
41601 zval *zptr;
41602 void **cache_slot;
41603 zend_property_info *prop_info;
41604 zend_object *zobj;
41605 zend_string *name, *tmp_name;
41606
41607 SAVE_OPLINE();
41608 object = EX_VAR(opline->op1.var);
41609 property = RT_CONSTANT(opline, opline->op2);
41610
41611 do {
41612 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
41613 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
41614 object = Z_REFVAL_P(object);
41615 goto pre_incdec_object;
41616 }
41617 if (IS_CV == IS_CV
41618 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
41619 ZVAL_UNDEFINED_OP1();
41620 }
41621 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
41622 break;
41623 }
41624
41625 pre_incdec_object:
41626 /* here we are sure we are dealing with an object */
41627 zobj = Z_OBJ_P(object);
41628 if (IS_CONST == IS_CONST) {
41629 name = Z_STR_P(property);
41630 } else {
41631 name = zval_try_get_tmp_string(property, &tmp_name);
41632 if (UNEXPECTED(!name)) {
41633 UNDEF_RESULT();
41634 break;
41635 }
41636 }
41637 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
41638 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
41639 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
41640 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
41641 ZVAL_NULL(EX_VAR(opline->result.var));
41642 }
41643 } else {
41644 if (IS_CONST == IS_CONST) {
41645 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
41646 } else {
41647 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
41648 }
41649 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
41650 }
41651 } else {
41652 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
41653 }
41654 if (IS_CONST != IS_CONST) {
41655 zend_tmp_string_release(tmp_name);
41656 }
41657 } while (0);
41658
41659
41660 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41661 }
41662
ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41663 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41664 {
41665 USE_OPLINE
41666 zval *object;
41667 zval *property;
41668 zval *zptr;
41669 void **cache_slot;
41670 zend_property_info *prop_info;
41671 zend_object *zobj;
41672 zend_string *name, *tmp_name;
41673
41674 SAVE_OPLINE();
41675 object = EX_VAR(opline->op1.var);
41676 property = RT_CONSTANT(opline, opline->op2);
41677
41678 do {
41679 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
41680 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
41681 object = Z_REFVAL_P(object);
41682 goto post_incdec_object;
41683 }
41684 if (IS_CV == IS_CV
41685 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
41686 ZVAL_UNDEFINED_OP1();
41687 }
41688 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
41689 break;
41690 }
41691
41692 post_incdec_object:
41693 /* here we are sure we are dealing with an object */
41694 zobj = Z_OBJ_P(object);
41695 if (IS_CONST == IS_CONST) {
41696 name = Z_STR_P(property);
41697 } else {
41698 name = zval_try_get_tmp_string(property, &tmp_name);
41699 if (UNEXPECTED(!name)) {
41700 ZVAL_UNDEF(EX_VAR(opline->result.var));
41701 break;
41702 }
41703 }
41704 cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
41705 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
41706 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
41707 ZVAL_NULL(EX_VAR(opline->result.var));
41708 } else {
41709 if (IS_CONST == IS_CONST) {
41710 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
41711 } else {
41712 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
41713 }
41714
41715 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
41716 }
41717 } else {
41718 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
41719 }
41720 if (IS_CONST != IS_CONST) {
41721 zend_tmp_string_release(tmp_name);
41722 }
41723 } while (0);
41724
41725
41726 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41727 }
41728
ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41729 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41730 {
41731 USE_OPLINE
41732 zval *container, *dim, *value;
41733
41734 SAVE_OPLINE();
41735 container = EX_VAR(opline->op1.var);
41736 dim = RT_CONSTANT(opline, opline->op2);
41737 if (IS_CV != IS_CONST) {
41738 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
41739 fetch_dim_r_array:
41740 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC);
41741 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
41742 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
41743 container = Z_REFVAL_P(container);
41744 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
41745 goto fetch_dim_r_array;
41746 } else {
41747 goto fetch_dim_r_slow;
41748 }
41749 } else {
41750 fetch_dim_r_slow:
41751 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
41752 dim++;
41753 }
41754 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
41755 }
41756 } else {
41757 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
41758 }
41759
41760
41761 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41762 }
41763
ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41764 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41765 {
41766 USE_OPLINE
41767 zval *container;
41768
41769 SAVE_OPLINE();
41770 container = EX_VAR(opline->op1.var);
41771 zend_fetch_dimension_address_W(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
41772
41773 if (IS_CV == IS_VAR) {
41774 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
41775 }
41776 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41777 }
41778
ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41779 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41780 {
41781 USE_OPLINE
41782 zval *container;
41783
41784 SAVE_OPLINE();
41785 container = EX_VAR(opline->op1.var);
41786 zend_fetch_dimension_address_RW(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
41787
41788 if (IS_CV == IS_VAR) {
41789 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
41790 }
41791 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41792 }
41793
ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41794 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41795 {
41796 USE_OPLINE
41797 zval *container;
41798
41799 SAVE_OPLINE();
41800 container = EX_VAR(opline->op1.var);
41801 zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
41802
41803
41804 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41805 }
41806
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41807 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41808 {
41809 #if 0
41810 USE_OPLINE
41811 #endif
41812
41813 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
41814 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
41815 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
41816 }
41817 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
41818 } else {
41819 if (IS_CONST == IS_UNUSED) {
41820 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
41821 }
41822 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
41823 }
41824 }
41825
ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41826 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41827 {
41828 USE_OPLINE
41829 zval *container;
41830
41831 SAVE_OPLINE();
41832 container = EX_VAR(opline->op1.var);
41833 zend_fetch_dimension_address_UNSET(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC);
41834
41835 if (IS_CV == IS_VAR) {
41836 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
41837 }
41838 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41839 }
41840
ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41841 static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41842 {
41843 USE_OPLINE
41844 zval *container;
41845 void **cache_slot = NULL;
41846
41847 SAVE_OPLINE();
41848 container = EX_VAR(opline->op1.var);
41849
41850 if (IS_CV == IS_CONST ||
41851 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
41852 do {
41853 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
41854 container = Z_REFVAL_P(container);
41855 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
41856 break;
41857 }
41858 }
41859 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
41860 ZVAL_UNDEFINED_OP1();
41861 }
41862 zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2));
41863 ZVAL_NULL(EX_VAR(opline->result.var));
41864 goto fetch_obj_r_finish;
41865 } while (0);
41866 }
41867
41868 /* here we are sure we are dealing with an object */
41869 do {
41870 zend_object *zobj = Z_OBJ_P(container);
41871 zend_string *name, *tmp_name;
41872 zval *retval;
41873
41874 if (IS_CONST == IS_CONST) {
41875 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
41876
41877 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
41878 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
41879
41880 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
41881 retval = OBJ_PROP(zobj, prop_offset);
41882 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
41883 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
41884 goto fetch_obj_r_copy;
41885 } else {
41886 fetch_obj_r_fast_copy:
41887 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
41888 ZEND_VM_NEXT_OPCODE();
41889 }
41890 }
41891 } else if (EXPECTED(zobj->properties != NULL)) {
41892 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
41893 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
41894 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
41895
41896 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
41897 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
41898
41899 if (EXPECTED(p->key == name) ||
41900 (EXPECTED(p->h == ZSTR_H(name)) &&
41901 EXPECTED(p->key != NULL) &&
41902 EXPECTED(zend_string_equal_content(p->key, name)))) {
41903 retval = &p->val;
41904 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
41905 goto fetch_obj_r_copy;
41906 } else {
41907 goto fetch_obj_r_fast_copy;
41908 }
41909 }
41910 }
41911 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
41912 }
41913 retval = zend_hash_find_known_hash(zobj->properties, name);
41914 if (EXPECTED(retval)) {
41915 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
41916 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
41917 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
41918 goto fetch_obj_r_copy;
41919 } else {
41920 goto fetch_obj_r_fast_copy;
41921 }
41922 }
41923 }
41924 }
41925 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
41926 } else {
41927 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
41928 if (UNEXPECTED(!name)) {
41929 ZVAL_UNDEF(EX_VAR(opline->result.var));
41930 break;
41931 }
41932 }
41933
41934 #if ZEND_DEBUG
41935 /* For non-standard object handlers, verify a declared property type in debug builds.
41936 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
41937 zend_property_info *prop_info = NULL;
41938 if (zobj->handlers->read_property != zend_std_read_property) {
41939 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
41940 }
41941 #endif
41942 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
41943 #if ZEND_DEBUG
41944 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
41945 && ZEND_TYPE_IS_SET(prop_info->type)) {
41946 ZVAL_OPT_DEREF(retval);
41947 zend_verify_property_type(prop_info, retval, /* strict */ true);
41948 }
41949 #endif
41950
41951 if (IS_CONST != IS_CONST) {
41952 zend_tmp_string_release(tmp_name);
41953 }
41954
41955 if (retval != EX_VAR(opline->result.var)) {
41956 fetch_obj_r_copy:
41957 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
41958 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
41959 zend_unwrap_reference(retval);
41960 }
41961 } while (0);
41962
41963 fetch_obj_r_finish:
41964
41965
41966 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41967 }
41968
ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41969 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41970 {
41971 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
41972 }
41973
ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41974 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41975 {
41976 USE_OPLINE
41977 zval *property, *container, *result;
41978
41979 SAVE_OPLINE();
41980
41981 container = EX_VAR(opline->op1.var);
41982 property = RT_CONSTANT(opline, opline->op2);
41983 result = EX_VAR(opline->result.var);
41984 zend_fetch_property_address(
41985 result, container, IS_CV, property, IS_CONST,
41986 ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
41987 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
41988
41989 if (IS_CV == IS_VAR) {
41990 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
41991 }
41992 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
41993 }
41994
ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)41995 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
41996 {
41997 USE_OPLINE
41998 zval *property, *container, *result;
41999
42000 SAVE_OPLINE();
42001 container = EX_VAR(opline->op1.var);
42002 property = RT_CONSTANT(opline, opline->op2);
42003 result = EX_VAR(opline->result.var);
42004 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 OPLINE_CC EXECUTE_DATA_CC);
42005
42006 if (IS_CV == IS_VAR) {
42007 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42008 }
42009 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42010 }
42011
ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42012 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42013 {
42014 USE_OPLINE
42015 zval *container;
42016 void **cache_slot = NULL;
42017
42018 SAVE_OPLINE();
42019 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
42020
42021 if (IS_CV == IS_CONST ||
42022 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
42023 do {
42024 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
42025 container = Z_REFVAL_P(container);
42026 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
42027 break;
42028 }
42029 }
42030 if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
42031 ZVAL_UNDEFINED_OP2();
42032 }
42033 ZVAL_NULL(EX_VAR(opline->result.var));
42034 goto fetch_obj_is_finish;
42035 } while (0);
42036 }
42037
42038 /* here we are sure we are dealing with an object */
42039 do {
42040 zend_object *zobj = Z_OBJ_P(container);
42041 zend_string *name, *tmp_name;
42042 zval *retval;
42043
42044 if (IS_CONST == IS_CONST) {
42045 cache_slot = CACHE_ADDR(opline->extended_value);
42046
42047 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
42048 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
42049
42050 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
42051 retval = OBJ_PROP(zobj, prop_offset);
42052 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
42053 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
42054 goto fetch_obj_is_copy;
42055 } else {
42056 fetch_obj_is_fast_copy:
42057 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
42058 ZEND_VM_NEXT_OPCODE();
42059 }
42060 }
42061 } else if (EXPECTED(zobj->properties != NULL)) {
42062 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42063 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
42064 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
42065
42066 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
42067 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
42068
42069 if (EXPECTED(p->key == name) ||
42070 (EXPECTED(p->h == ZSTR_H(name)) &&
42071 EXPECTED(p->key != NULL) &&
42072 EXPECTED(zend_string_equal_content(p->key, name)))) {
42073 retval = &p->val;
42074 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
42075 goto fetch_obj_is_copy;
42076 } else {
42077 goto fetch_obj_is_fast_copy;
42078 }
42079 }
42080 }
42081 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
42082 }
42083 retval = zend_hash_find_known_hash(zobj->properties, name);
42084 if (EXPECTED(retval)) {
42085 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
42086 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
42087 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
42088 goto fetch_obj_is_copy;
42089 } else {
42090 goto fetch_obj_is_fast_copy;
42091 }
42092 }
42093 }
42094 }
42095 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42096 } else {
42097 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
42098 if (UNEXPECTED(!name)) {
42099 ZVAL_UNDEF(EX_VAR(opline->result.var));
42100 break;
42101 }
42102 }
42103
42104 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
42105
42106 if (IS_CONST != IS_CONST) {
42107 zend_tmp_string_release(tmp_name);
42108 }
42109
42110 if (retval != EX_VAR(opline->result.var)) {
42111 fetch_obj_is_copy:
42112 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
42113 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
42114 zend_unwrap_reference(retval);
42115 }
42116 } while (0);
42117
42118 fetch_obj_is_finish:
42119
42120
42121 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42122 }
42123
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42124 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42125 {
42126 #if 0
42127 USE_OPLINE
42128 #endif
42129
42130 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
42131 /* Behave like FETCH_OBJ_W */
42132 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
42133 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42134 }
42135 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42136 } else {
42137 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
42138 }
42139 }
42140
ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42141 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42142 {
42143 USE_OPLINE
42144 zval *container, *property, *result;
42145
42146 SAVE_OPLINE();
42147 container = EX_VAR(opline->op1.var);
42148 property = RT_CONSTANT(opline, opline->op2);
42149 result = EX_VAR(opline->result.var);
42150 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 OPLINE_CC EXECUTE_DATA_CC);
42151
42152 if (IS_CV == IS_VAR) {
42153 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
42154 }
42155 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
42156 }
42157
ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42158 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42159 {
42160 USE_OPLINE
42161 zval *object, *value, tmp;
42162 zend_object *zobj;
42163 zend_string *name, *tmp_name;
42164 zend_refcounted *garbage = NULL;
42165
42166 SAVE_OPLINE();
42167 object = EX_VAR(opline->op1.var);
42168 value = RT_CONSTANT((opline+1), (opline+1)->op1);
42169
42170 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42171 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42172 object = Z_REFVAL_P(object);
42173 goto assign_object;
42174 }
42175 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
42176 value = &EG(uninitialized_zval);
42177 goto free_and_exit_assign_obj;
42178 }
42179
42180 assign_object:
42181 zobj = Z_OBJ_P(object);
42182 if (IS_CONST == IS_CONST) {
42183 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
42184 void **cache_slot = CACHE_ADDR(opline->extended_value);
42185 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
42186 zval *property_val;
42187
42188 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
42189 property_val = OBJ_PROP(zobj, prop_offset);
42190 if (Z_TYPE_P(property_val) != IS_UNDEF) {
42191 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
42192
42193 if (prop_info != NULL) {
42194 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
42195 goto free_and_exit_assign_obj;
42196 } else {
42197 fast_assign_obj:
42198 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
42199 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42200 ZVAL_COPY(EX_VAR(opline->result.var), value);
42201 }
42202 goto exit_assign_obj;
42203 }
42204 }
42205 } else {
42206 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42207 if (EXPECTED(zobj->properties != NULL)) {
42208 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
42209 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
42210 GC_DELREF(zobj->properties);
42211 }
42212 zobj->properties = zend_array_dup(zobj->properties);
42213 }
42214 property_val = zend_hash_find_known_hash(zobj->properties, name);
42215 if (property_val) {
42216 goto fast_assign_obj;
42217 }
42218 }
42219
42220 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
42221 if (EXPECTED(zobj->properties == NULL)) {
42222 rebuild_object_properties(zobj);
42223 }
42224 if (IS_CONST == IS_CONST) {
42225 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
42226 Z_ADDREF_P(value);
42227 }
42228 } else if (IS_CONST != IS_TMP_VAR) {
42229 if (Z_ISREF_P(value)) {
42230 if (IS_CONST == IS_VAR) {
42231 zend_reference *ref = Z_REF_P(value);
42232 if (GC_DELREF(ref) == 0) {
42233 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
42234 efree_size(ref, sizeof(zend_reference));
42235 value = &tmp;
42236 } else {
42237 value = Z_REFVAL_P(value);
42238 Z_TRY_ADDREF_P(value);
42239 }
42240 } else {
42241 value = Z_REFVAL_P(value);
42242 Z_TRY_ADDREF_P(value);
42243 }
42244 } else if (IS_CONST == IS_CV) {
42245 Z_TRY_ADDREF_P(value);
42246 }
42247 }
42248 zend_hash_add_new(zobj->properties, name, value);
42249 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42250 ZVAL_COPY(EX_VAR(opline->result.var), value);
42251 }
42252 goto exit_assign_obj;
42253 }
42254 }
42255 }
42256 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42257 } else {
42258 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
42259 if (UNEXPECTED(!name)) {
42260
42261 UNDEF_RESULT();
42262 goto exit_assign_obj;
42263 }
42264 }
42265
42266 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
42267 ZVAL_DEREF(value);
42268 }
42269
42270 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
42271
42272 if (IS_CONST != IS_CONST) {
42273 zend_tmp_string_release(tmp_name);
42274 }
42275
42276 free_and_exit_assign_obj:
42277 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
42278 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42279 }
42280
42281 exit_assign_obj:
42282 if (garbage) {
42283 GC_DTOR_NO_REF(garbage);
42284 }
42285
42286
42287 /* assign_obj has two opcodes! */
42288 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42289 }
42290
42291 /* 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)42292 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42293 {
42294 USE_OPLINE
42295 zval *object, *value, tmp;
42296 zend_object *zobj;
42297 zend_string *name, *tmp_name;
42298 zend_refcounted *garbage = NULL;
42299
42300 SAVE_OPLINE();
42301 object = EX_VAR(opline->op1.var);
42302 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
42303
42304 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42305 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42306 object = Z_REFVAL_P(object);
42307 goto assign_object;
42308 }
42309 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
42310 value = &EG(uninitialized_zval);
42311 goto free_and_exit_assign_obj;
42312 }
42313
42314 assign_object:
42315 zobj = Z_OBJ_P(object);
42316 if (IS_CONST == IS_CONST) {
42317 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
42318 void **cache_slot = CACHE_ADDR(opline->extended_value);
42319 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
42320 zval *property_val;
42321
42322 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
42323 property_val = OBJ_PROP(zobj, prop_offset);
42324 if (Z_TYPE_P(property_val) != IS_UNDEF) {
42325 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
42326
42327 if (prop_info != NULL) {
42328 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
42329 goto free_and_exit_assign_obj;
42330 } else {
42331 fast_assign_obj:
42332 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
42333 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42334 ZVAL_COPY(EX_VAR(opline->result.var), value);
42335 }
42336 goto exit_assign_obj;
42337 }
42338 }
42339 } else {
42340 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42341 if (EXPECTED(zobj->properties != NULL)) {
42342 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
42343 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
42344 GC_DELREF(zobj->properties);
42345 }
42346 zobj->properties = zend_array_dup(zobj->properties);
42347 }
42348 property_val = zend_hash_find_known_hash(zobj->properties, name);
42349 if (property_val) {
42350 goto fast_assign_obj;
42351 }
42352 }
42353
42354 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
42355 if (EXPECTED(zobj->properties == NULL)) {
42356 rebuild_object_properties(zobj);
42357 }
42358 if (IS_TMP_VAR == IS_CONST) {
42359 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
42360 Z_ADDREF_P(value);
42361 }
42362 } else if (IS_TMP_VAR != IS_TMP_VAR) {
42363 if (Z_ISREF_P(value)) {
42364 if (IS_TMP_VAR == IS_VAR) {
42365 zend_reference *ref = Z_REF_P(value);
42366 if (GC_DELREF(ref) == 0) {
42367 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
42368 efree_size(ref, sizeof(zend_reference));
42369 value = &tmp;
42370 } else {
42371 value = Z_REFVAL_P(value);
42372 Z_TRY_ADDREF_P(value);
42373 }
42374 } else {
42375 value = Z_REFVAL_P(value);
42376 Z_TRY_ADDREF_P(value);
42377 }
42378 } else if (IS_TMP_VAR == IS_CV) {
42379 Z_TRY_ADDREF_P(value);
42380 }
42381 }
42382 zend_hash_add_new(zobj->properties, name, value);
42383 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42384 ZVAL_COPY(EX_VAR(opline->result.var), value);
42385 }
42386 goto exit_assign_obj;
42387 }
42388 }
42389 }
42390 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42391 } else {
42392 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
42393 if (UNEXPECTED(!name)) {
42394 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42395 UNDEF_RESULT();
42396 goto exit_assign_obj;
42397 }
42398 }
42399
42400 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
42401 ZVAL_DEREF(value);
42402 }
42403
42404 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
42405
42406 if (IS_CONST != IS_CONST) {
42407 zend_tmp_string_release(tmp_name);
42408 }
42409
42410 free_and_exit_assign_obj:
42411 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
42412 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42413 }
42414 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42415 exit_assign_obj:
42416 if (garbage) {
42417 GC_DTOR_NO_REF(garbage);
42418 }
42419
42420
42421 /* assign_obj has two opcodes! */
42422 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42423 }
42424
42425 /* 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)42426 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42427 {
42428 USE_OPLINE
42429 zval *object, *value, tmp;
42430 zend_object *zobj;
42431 zend_string *name, *tmp_name;
42432 zend_refcounted *garbage = NULL;
42433
42434 SAVE_OPLINE();
42435 object = EX_VAR(opline->op1.var);
42436 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
42437
42438 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42439 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42440 object = Z_REFVAL_P(object);
42441 goto assign_object;
42442 }
42443 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
42444 value = &EG(uninitialized_zval);
42445 goto free_and_exit_assign_obj;
42446 }
42447
42448 assign_object:
42449 zobj = Z_OBJ_P(object);
42450 if (IS_CONST == IS_CONST) {
42451 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
42452 void **cache_slot = CACHE_ADDR(opline->extended_value);
42453 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
42454 zval *property_val;
42455
42456 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
42457 property_val = OBJ_PROP(zobj, prop_offset);
42458 if (Z_TYPE_P(property_val) != IS_UNDEF) {
42459 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
42460
42461 if (prop_info != NULL) {
42462 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
42463 goto free_and_exit_assign_obj;
42464 } else {
42465 fast_assign_obj:
42466 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
42467 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42468 ZVAL_COPY(EX_VAR(opline->result.var), value);
42469 }
42470 goto exit_assign_obj;
42471 }
42472 }
42473 } else {
42474 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42475 if (EXPECTED(zobj->properties != NULL)) {
42476 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
42477 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
42478 GC_DELREF(zobj->properties);
42479 }
42480 zobj->properties = zend_array_dup(zobj->properties);
42481 }
42482 property_val = zend_hash_find_known_hash(zobj->properties, name);
42483 if (property_val) {
42484 goto fast_assign_obj;
42485 }
42486 }
42487
42488 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
42489 if (EXPECTED(zobj->properties == NULL)) {
42490 rebuild_object_properties(zobj);
42491 }
42492 if (IS_VAR == IS_CONST) {
42493 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
42494 Z_ADDREF_P(value);
42495 }
42496 } else if (IS_VAR != IS_TMP_VAR) {
42497 if (Z_ISREF_P(value)) {
42498 if (IS_VAR == IS_VAR) {
42499 zend_reference *ref = Z_REF_P(value);
42500 if (GC_DELREF(ref) == 0) {
42501 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
42502 efree_size(ref, sizeof(zend_reference));
42503 value = &tmp;
42504 } else {
42505 value = Z_REFVAL_P(value);
42506 Z_TRY_ADDREF_P(value);
42507 }
42508 } else {
42509 value = Z_REFVAL_P(value);
42510 Z_TRY_ADDREF_P(value);
42511 }
42512 } else if (IS_VAR == IS_CV) {
42513 Z_TRY_ADDREF_P(value);
42514 }
42515 }
42516 zend_hash_add_new(zobj->properties, name, value);
42517 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42518 ZVAL_COPY(EX_VAR(opline->result.var), value);
42519 }
42520 goto exit_assign_obj;
42521 }
42522 }
42523 }
42524 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42525 } else {
42526 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
42527 if (UNEXPECTED(!name)) {
42528 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42529 UNDEF_RESULT();
42530 goto exit_assign_obj;
42531 }
42532 }
42533
42534 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
42535 ZVAL_DEREF(value);
42536 }
42537
42538 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
42539
42540 if (IS_CONST != IS_CONST) {
42541 zend_tmp_string_release(tmp_name);
42542 }
42543
42544 free_and_exit_assign_obj:
42545 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
42546 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42547 }
42548 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42549 exit_assign_obj:
42550 if (garbage) {
42551 GC_DTOR_NO_REF(garbage);
42552 }
42553
42554
42555 /* assign_obj has two opcodes! */
42556 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42557 }
42558
42559 /* 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)42560 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42561 {
42562 USE_OPLINE
42563 zval *object, *value, tmp;
42564 zend_object *zobj;
42565 zend_string *name, *tmp_name;
42566 zend_refcounted *garbage = NULL;
42567
42568 SAVE_OPLINE();
42569 object = EX_VAR(opline->op1.var);
42570 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
42571
42572 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
42573 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
42574 object = Z_REFVAL_P(object);
42575 goto assign_object;
42576 }
42577 zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC);
42578 value = &EG(uninitialized_zval);
42579 goto free_and_exit_assign_obj;
42580 }
42581
42582 assign_object:
42583 zobj = Z_OBJ_P(object);
42584 if (IS_CONST == IS_CONST) {
42585 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
42586 void **cache_slot = CACHE_ADDR(opline->extended_value);
42587 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
42588 zval *property_val;
42589
42590 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
42591 property_val = OBJ_PROP(zobj, prop_offset);
42592 if (Z_TYPE_P(property_val) != IS_UNDEF) {
42593 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
42594
42595 if (prop_info != NULL) {
42596 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
42597 goto free_and_exit_assign_obj;
42598 } else {
42599 fast_assign_obj:
42600 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
42601 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42602 ZVAL_COPY(EX_VAR(opline->result.var), value);
42603 }
42604 goto exit_assign_obj;
42605 }
42606 }
42607 } else {
42608 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42609 if (EXPECTED(zobj->properties != NULL)) {
42610 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
42611 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
42612 GC_DELREF(zobj->properties);
42613 }
42614 zobj->properties = zend_array_dup(zobj->properties);
42615 }
42616 property_val = zend_hash_find_known_hash(zobj->properties, name);
42617 if (property_val) {
42618 goto fast_assign_obj;
42619 }
42620 }
42621
42622 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
42623 if (EXPECTED(zobj->properties == NULL)) {
42624 rebuild_object_properties(zobj);
42625 }
42626 if (IS_CV == IS_CONST) {
42627 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
42628 Z_ADDREF_P(value);
42629 }
42630 } else if (IS_CV != IS_TMP_VAR) {
42631 if (Z_ISREF_P(value)) {
42632 if (IS_CV == IS_VAR) {
42633 zend_reference *ref = Z_REF_P(value);
42634 if (GC_DELREF(ref) == 0) {
42635 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
42636 efree_size(ref, sizeof(zend_reference));
42637 value = &tmp;
42638 } else {
42639 value = Z_REFVAL_P(value);
42640 Z_TRY_ADDREF_P(value);
42641 }
42642 } else {
42643 value = Z_REFVAL_P(value);
42644 Z_TRY_ADDREF_P(value);
42645 }
42646 } else if (IS_CV == IS_CV) {
42647 Z_TRY_ADDREF_P(value);
42648 }
42649 }
42650 zend_hash_add_new(zobj->properties, name, value);
42651 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42652 ZVAL_COPY(EX_VAR(opline->result.var), value);
42653 }
42654 goto exit_assign_obj;
42655 }
42656 }
42657 }
42658 name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
42659 } else {
42660 name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name);
42661 if (UNEXPECTED(!name)) {
42662
42663 UNDEF_RESULT();
42664 goto exit_assign_obj;
42665 }
42666 }
42667
42668 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
42669 ZVAL_DEREF(value);
42670 }
42671
42672 value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
42673
42674 if (IS_CONST != IS_CONST) {
42675 zend_tmp_string_release(tmp_name);
42676 }
42677
42678 free_and_exit_assign_obj:
42679 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
42680 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
42681 }
42682
42683 exit_assign_obj:
42684 if (garbage) {
42685 GC_DTOR_NO_REF(garbage);
42686 }
42687
42688
42689 /* assign_obj has two opcodes! */
42690 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42691 }
42692
42693 /* 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)42694 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42695 {
42696 USE_OPLINE
42697 zval *object_ptr, *orig_object_ptr;
42698 zval *value;
42699 zval *variable_ptr;
42700 zval *dim;
42701 zend_refcounted *garbage = NULL;
42702
42703 SAVE_OPLINE();
42704 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
42705
42706 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
42707 try_assign_dim_array:
42708 SEPARATE_ARRAY(object_ptr);
42709 if (IS_CONST == IS_UNUSED) {
42710 value = RT_CONSTANT((opline+1), (opline+1)->op1);
42711 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
42712 HashTable *ht = Z_ARRVAL_P(object_ptr);
42713 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
42714 GC_ADDREF(ht);
42715 }
42716 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
42717 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
42718 zend_array_destroy(ht);
42719 goto assign_dim_error;
42720 }
42721 }
42722 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
42723 ZVAL_DEREF(value);
42724 }
42725 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
42726 if (UNEXPECTED(value == NULL)) {
42727 zend_cannot_add_element();
42728 goto assign_dim_error;
42729 } else if (IS_CONST == IS_CV) {
42730 if (Z_REFCOUNTED_P(value)) {
42731 Z_ADDREF_P(value);
42732 }
42733 } else if (IS_CONST == IS_VAR) {
42734 zval *free_op_data = EX_VAR((opline+1)->op1.var);
42735 if (Z_ISREF_P(free_op_data)) {
42736 if (Z_REFCOUNTED_P(value)) {
42737 Z_ADDREF_P(value);
42738 }
42739 zval_ptr_dtor_nogc(free_op_data);
42740 }
42741 } else if (IS_CONST == IS_CONST) {
42742 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
42743 Z_ADDREF_P(value);
42744 }
42745 }
42746 } else {
42747 dim = RT_CONSTANT(opline, opline->op2);
42748 if (IS_CONST == IS_CONST) {
42749 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
42750 } else {
42751 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
42752 }
42753 if (UNEXPECTED(variable_ptr == NULL)) {
42754 goto assign_dim_error;
42755 }
42756 value = RT_CONSTANT((opline+1), (opline+1)->op1);
42757 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
42758 }
42759 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42760 ZVAL_COPY(EX_VAR(opline->result.var), value);
42761 }
42762 if (garbage) {
42763 GC_DTOR_NO_REF(garbage);
42764 }
42765 } else {
42766 if (EXPECTED(Z_ISREF_P(object_ptr))) {
42767 object_ptr = Z_REFVAL_P(object_ptr);
42768 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
42769 goto try_assign_dim_array;
42770 }
42771 }
42772 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
42773 zend_object *obj = Z_OBJ_P(object_ptr);
42774
42775 GC_ADDREF(obj);
42776 dim = RT_CONSTANT(opline, opline->op2);
42777 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
42778 dim = ZVAL_UNDEFINED_OP2();
42779 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42780 dim++;
42781 }
42782
42783 value = RT_CONSTANT((opline+1), (opline+1)->op1);
42784 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
42785 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
42786 } else if (IS_CONST & (IS_CV|IS_VAR)) {
42787 ZVAL_DEREF(value);
42788 }
42789
42790 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
42791
42792 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
42793 zend_objects_store_del(obj);
42794 }
42795 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
42796 if (IS_CONST == IS_UNUSED) {
42797 zend_use_new_element_for_string();
42798
42799 UNDEF_RESULT();
42800 } else {
42801 dim = RT_CONSTANT(opline, opline->op2);
42802 value = RT_CONSTANT((opline+1), (opline+1)->op1);
42803 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
42804
42805 }
42806 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
42807 if (Z_ISREF_P(orig_object_ptr)
42808 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
42809 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
42810 dim = RT_CONSTANT(opline, opline->op2);
42811
42812 UNDEF_RESULT();
42813 } else {
42814 HashTable *ht = zend_new_array(8);
42815 uint8_t old_type = Z_TYPE_P(object_ptr);
42816
42817 ZVAL_ARR(object_ptr, ht);
42818 if (UNEXPECTED(old_type == IS_FALSE)) {
42819 GC_ADDREF(ht);
42820 zend_false_to_array_deprecated();
42821 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
42822 zend_array_destroy(ht);
42823 goto assign_dim_error;
42824 }
42825 }
42826 goto try_assign_dim_array;
42827 }
42828 } else {
42829 zend_use_scalar_as_array();
42830 dim = RT_CONSTANT(opline, opline->op2);
42831 assign_dim_error:
42832
42833 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42834 ZVAL_NULL(EX_VAR(opline->result.var));
42835 }
42836 }
42837 }
42838 if (IS_CONST != IS_UNUSED) {
42839
42840 }
42841
42842 /* assign_dim has two opcodes! */
42843 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42844 }
42845
ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42846 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
42847 {
42848 USE_OPLINE
42849 zval *object_ptr, *orig_object_ptr;
42850 zval *value;
42851 zval *variable_ptr;
42852 zval *dim;
42853 zend_refcounted *garbage = NULL;
42854
42855 SAVE_OPLINE();
42856 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
42857
42858 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
42859 try_assign_dim_array:
42860 SEPARATE_ARRAY(object_ptr);
42861 if (IS_CONST == IS_UNUSED) {
42862 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
42863 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
42864 HashTable *ht = Z_ARRVAL_P(object_ptr);
42865 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
42866 GC_ADDREF(ht);
42867 }
42868 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
42869 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
42870 zend_array_destroy(ht);
42871 goto assign_dim_error;
42872 }
42873 }
42874 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
42875 ZVAL_DEREF(value);
42876 }
42877 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
42878 if (UNEXPECTED(value == NULL)) {
42879 zend_cannot_add_element();
42880 goto assign_dim_error;
42881 } else if (IS_TMP_VAR == IS_CV) {
42882 if (Z_REFCOUNTED_P(value)) {
42883 Z_ADDREF_P(value);
42884 }
42885 } else if (IS_TMP_VAR == IS_VAR) {
42886 zval *free_op_data = EX_VAR((opline+1)->op1.var);
42887 if (Z_ISREF_P(free_op_data)) {
42888 if (Z_REFCOUNTED_P(value)) {
42889 Z_ADDREF_P(value);
42890 }
42891 zval_ptr_dtor_nogc(free_op_data);
42892 }
42893 } else if (IS_TMP_VAR == IS_CONST) {
42894 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
42895 Z_ADDREF_P(value);
42896 }
42897 }
42898 } else {
42899 dim = RT_CONSTANT(opline, opline->op2);
42900 if (IS_CONST == IS_CONST) {
42901 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
42902 } else {
42903 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
42904 }
42905 if (UNEXPECTED(variable_ptr == NULL)) {
42906 goto assign_dim_error;
42907 }
42908 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
42909 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
42910 }
42911 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42912 ZVAL_COPY(EX_VAR(opline->result.var), value);
42913 }
42914 if (garbage) {
42915 GC_DTOR_NO_REF(garbage);
42916 }
42917 } else {
42918 if (EXPECTED(Z_ISREF_P(object_ptr))) {
42919 object_ptr = Z_REFVAL_P(object_ptr);
42920 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
42921 goto try_assign_dim_array;
42922 }
42923 }
42924 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
42925 zend_object *obj = Z_OBJ_P(object_ptr);
42926
42927 GC_ADDREF(obj);
42928 dim = RT_CONSTANT(opline, opline->op2);
42929 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
42930 dim = ZVAL_UNDEFINED_OP2();
42931 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
42932 dim++;
42933 }
42934
42935 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
42936 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
42937 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
42938 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
42939 ZVAL_DEREF(value);
42940 }
42941
42942 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
42943
42944 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42945 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
42946 zend_objects_store_del(obj);
42947 }
42948 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
42949 if (IS_CONST == IS_UNUSED) {
42950 zend_use_new_element_for_string();
42951 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42952 UNDEF_RESULT();
42953 } else {
42954 dim = RT_CONSTANT(opline, opline->op2);
42955 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
42956 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
42957 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42958 }
42959 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
42960 if (Z_ISREF_P(orig_object_ptr)
42961 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
42962 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
42963 dim = RT_CONSTANT(opline, opline->op2);
42964 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42965 UNDEF_RESULT();
42966 } else {
42967 HashTable *ht = zend_new_array(8);
42968 uint8_t old_type = Z_TYPE_P(object_ptr);
42969
42970 ZVAL_ARR(object_ptr, ht);
42971 if (UNEXPECTED(old_type == IS_FALSE)) {
42972 GC_ADDREF(ht);
42973 zend_false_to_array_deprecated();
42974 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
42975 zend_array_destroy(ht);
42976 goto assign_dim_error;
42977 }
42978 }
42979 goto try_assign_dim_array;
42980 }
42981 } else {
42982 zend_use_scalar_as_array();
42983 dim = RT_CONSTANT(opline, opline->op2);
42984 assign_dim_error:
42985 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
42986 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
42987 ZVAL_NULL(EX_VAR(opline->result.var));
42988 }
42989 }
42990 }
42991 if (IS_CONST != IS_UNUSED) {
42992
42993 }
42994
42995 /* assign_dim has two opcodes! */
42996 ZEND_VM_NEXT_OPCODE_EX(1, 2);
42997 }
42998
ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)42999 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43000 {
43001 USE_OPLINE
43002 zval *object_ptr, *orig_object_ptr;
43003 zval *value;
43004 zval *variable_ptr;
43005 zval *dim;
43006 zend_refcounted *garbage = NULL;
43007
43008 SAVE_OPLINE();
43009 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
43010
43011 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
43012 try_assign_dim_array:
43013 SEPARATE_ARRAY(object_ptr);
43014 if (IS_CONST == IS_UNUSED) {
43015 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43016 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
43017 HashTable *ht = Z_ARRVAL_P(object_ptr);
43018 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
43019 GC_ADDREF(ht);
43020 }
43021 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
43022 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
43023 zend_array_destroy(ht);
43024 goto assign_dim_error;
43025 }
43026 }
43027 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
43028 ZVAL_DEREF(value);
43029 }
43030 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
43031 if (UNEXPECTED(value == NULL)) {
43032 zend_cannot_add_element();
43033 goto assign_dim_error;
43034 } else if (IS_VAR == IS_CV) {
43035 if (Z_REFCOUNTED_P(value)) {
43036 Z_ADDREF_P(value);
43037 }
43038 } else if (IS_VAR == IS_VAR) {
43039 zval *free_op_data = EX_VAR((opline+1)->op1.var);
43040 if (Z_ISREF_P(free_op_data)) {
43041 if (Z_REFCOUNTED_P(value)) {
43042 Z_ADDREF_P(value);
43043 }
43044 zval_ptr_dtor_nogc(free_op_data);
43045 }
43046 } else if (IS_VAR == IS_CONST) {
43047 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
43048 Z_ADDREF_P(value);
43049 }
43050 }
43051 } else {
43052 dim = RT_CONSTANT(opline, opline->op2);
43053 if (IS_CONST == IS_CONST) {
43054 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
43055 } else {
43056 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
43057 }
43058 if (UNEXPECTED(variable_ptr == NULL)) {
43059 goto assign_dim_error;
43060 }
43061 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43062 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
43063 }
43064 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43065 ZVAL_COPY(EX_VAR(opline->result.var), value);
43066 }
43067 if (garbage) {
43068 GC_DTOR_NO_REF(garbage);
43069 }
43070 } else {
43071 if (EXPECTED(Z_ISREF_P(object_ptr))) {
43072 object_ptr = Z_REFVAL_P(object_ptr);
43073 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
43074 goto try_assign_dim_array;
43075 }
43076 }
43077 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
43078 zend_object *obj = Z_OBJ_P(object_ptr);
43079
43080 GC_ADDREF(obj);
43081 dim = RT_CONSTANT(opline, opline->op2);
43082 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
43083 dim = ZVAL_UNDEFINED_OP2();
43084 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
43085 dim++;
43086 }
43087
43088 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43089 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
43090 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
43091 } else if (IS_VAR & (IS_CV|IS_VAR)) {
43092 ZVAL_DEREF(value);
43093 }
43094
43095 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
43096
43097 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43098 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
43099 zend_objects_store_del(obj);
43100 }
43101 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
43102 if (IS_CONST == IS_UNUSED) {
43103 zend_use_new_element_for_string();
43104 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43105 UNDEF_RESULT();
43106 } else {
43107 dim = RT_CONSTANT(opline, opline->op2);
43108 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43109 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
43110 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43111 }
43112 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
43113 if (Z_ISREF_P(orig_object_ptr)
43114 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
43115 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
43116 dim = RT_CONSTANT(opline, opline->op2);
43117 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43118 UNDEF_RESULT();
43119 } else {
43120 HashTable *ht = zend_new_array(8);
43121 uint8_t old_type = Z_TYPE_P(object_ptr);
43122
43123 ZVAL_ARR(object_ptr, ht);
43124 if (UNEXPECTED(old_type == IS_FALSE)) {
43125 GC_ADDREF(ht);
43126 zend_false_to_array_deprecated();
43127 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
43128 zend_array_destroy(ht);
43129 goto assign_dim_error;
43130 }
43131 }
43132 goto try_assign_dim_array;
43133 }
43134 } else {
43135 zend_use_scalar_as_array();
43136 dim = RT_CONSTANT(opline, opline->op2);
43137 assign_dim_error:
43138 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43139 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43140 ZVAL_NULL(EX_VAR(opline->result.var));
43141 }
43142 }
43143 }
43144 if (IS_CONST != IS_UNUSED) {
43145
43146 }
43147
43148 /* assign_dim has two opcodes! */
43149 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43150 }
43151
ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43152 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43153 {
43154 USE_OPLINE
43155 zval *object_ptr, *orig_object_ptr;
43156 zval *value;
43157 zval *variable_ptr;
43158 zval *dim;
43159 zend_refcounted *garbage = NULL;
43160
43161 SAVE_OPLINE();
43162 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
43163
43164 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
43165 try_assign_dim_array:
43166 SEPARATE_ARRAY(object_ptr);
43167 if (IS_CONST == IS_UNUSED) {
43168 value = EX_VAR((opline+1)->op1.var);
43169 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
43170 HashTable *ht = Z_ARRVAL_P(object_ptr);
43171 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
43172 GC_ADDREF(ht);
43173 }
43174 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
43175 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
43176 zend_array_destroy(ht);
43177 goto assign_dim_error;
43178 }
43179 }
43180 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
43181 ZVAL_DEREF(value);
43182 }
43183 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
43184 if (UNEXPECTED(value == NULL)) {
43185 zend_cannot_add_element();
43186 goto assign_dim_error;
43187 } else if (IS_CV == IS_CV) {
43188 if (Z_REFCOUNTED_P(value)) {
43189 Z_ADDREF_P(value);
43190 }
43191 } else if (IS_CV == IS_VAR) {
43192 zval *free_op_data = EX_VAR((opline+1)->op1.var);
43193 if (Z_ISREF_P(free_op_data)) {
43194 if (Z_REFCOUNTED_P(value)) {
43195 Z_ADDREF_P(value);
43196 }
43197 zval_ptr_dtor_nogc(free_op_data);
43198 }
43199 } else if (IS_CV == IS_CONST) {
43200 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
43201 Z_ADDREF_P(value);
43202 }
43203 }
43204 } else {
43205 dim = RT_CONSTANT(opline, opline->op2);
43206 if (IS_CONST == IS_CONST) {
43207 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
43208 } else {
43209 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
43210 }
43211 if (UNEXPECTED(variable_ptr == NULL)) {
43212 goto assign_dim_error;
43213 }
43214 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
43215 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
43216 }
43217 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43218 ZVAL_COPY(EX_VAR(opline->result.var), value);
43219 }
43220 if (garbage) {
43221 GC_DTOR_NO_REF(garbage);
43222 }
43223 } else {
43224 if (EXPECTED(Z_ISREF_P(object_ptr))) {
43225 object_ptr = Z_REFVAL_P(object_ptr);
43226 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
43227 goto try_assign_dim_array;
43228 }
43229 }
43230 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
43231 zend_object *obj = Z_OBJ_P(object_ptr);
43232
43233 GC_ADDREF(obj);
43234 dim = RT_CONSTANT(opline, opline->op2);
43235 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
43236 dim = ZVAL_UNDEFINED_OP2();
43237 } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
43238 dim++;
43239 }
43240
43241 value = EX_VAR((opline+1)->op1.var);
43242 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
43243 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
43244 } else if (IS_CV & (IS_CV|IS_VAR)) {
43245 ZVAL_DEREF(value);
43246 }
43247
43248 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
43249
43250 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
43251 zend_objects_store_del(obj);
43252 }
43253 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
43254 if (IS_CONST == IS_UNUSED) {
43255 zend_use_new_element_for_string();
43256
43257 UNDEF_RESULT();
43258 } else {
43259 dim = RT_CONSTANT(opline, opline->op2);
43260 value = EX_VAR((opline+1)->op1.var);
43261 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
43262
43263 }
43264 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
43265 if (Z_ISREF_P(orig_object_ptr)
43266 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
43267 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
43268 dim = RT_CONSTANT(opline, opline->op2);
43269
43270 UNDEF_RESULT();
43271 } else {
43272 HashTable *ht = zend_new_array(8);
43273 uint8_t old_type = Z_TYPE_P(object_ptr);
43274
43275 ZVAL_ARR(object_ptr, ht);
43276 if (UNEXPECTED(old_type == IS_FALSE)) {
43277 GC_ADDREF(ht);
43278 zend_false_to_array_deprecated();
43279 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
43280 zend_array_destroy(ht);
43281 goto assign_dim_error;
43282 }
43283 }
43284 goto try_assign_dim_array;
43285 }
43286 } else {
43287 zend_use_scalar_as_array();
43288 dim = RT_CONSTANT(opline, opline->op2);
43289 assign_dim_error:
43290
43291 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
43292 ZVAL_NULL(EX_VAR(opline->result.var));
43293 }
43294 }
43295 }
43296 if (IS_CONST != IS_UNUSED) {
43297
43298 }
43299
43300 /* assign_dim has two opcodes! */
43301 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43302 }
43303
ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43304 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43305 {
43306 USE_OPLINE
43307 zval *value;
43308 zval *variable_ptr;
43309
43310 SAVE_OPLINE();
43311 value = RT_CONSTANT(opline, opline->op2);
43312 variable_ptr = EX_VAR(opline->op1.var);
43313
43314 if (0 || UNEXPECTED(0)) {
43315 zend_refcounted *garbage = NULL;
43316
43317 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
43318 if (UNEXPECTED(0)) {
43319 ZVAL_COPY(EX_VAR(opline->result.var), value);
43320 }
43321 if (garbage) {
43322 GC_DTOR_NO_REF(garbage);
43323 }
43324 } else {
43325 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
43326 }
43327
43328 /* zend_assign_to_variable() always takes care of op2, never free it! */
43329
43330 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43331 }
43332
ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43333 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43334 {
43335 USE_OPLINE
43336 zval *value;
43337 zval *variable_ptr;
43338
43339 SAVE_OPLINE();
43340 value = RT_CONSTANT(opline, opline->op2);
43341 variable_ptr = EX_VAR(opline->op1.var);
43342
43343 if (0 || UNEXPECTED(1)) {
43344 zend_refcounted *garbage = NULL;
43345
43346 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
43347 if (UNEXPECTED(1)) {
43348 ZVAL_COPY(EX_VAR(opline->result.var), value);
43349 }
43350 if (garbage) {
43351 GC_DTOR_NO_REF(garbage);
43352 }
43353 } else {
43354 value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
43355 }
43356
43357 /* zend_assign_to_variable() always takes care of op2, never free it! */
43358
43359 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43360 }
43361
ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43362 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43363 {
43364 USE_OPLINE
43365 zval *property, *container, *value_ptr;
43366
43367 SAVE_OPLINE();
43368
43369 container = EX_VAR(opline->op1.var);
43370 property = RT_CONSTANT(opline, opline->op2);
43371
43372 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
43373
43374 if (1) {
43375 if (IS_CV == IS_UNUSED) {
43376 if (IS_CONST == IS_CONST) {
43377 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43378 } else {
43379 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43380 }
43381 } else {
43382 if (IS_CONST == IS_CONST) {
43383 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43384 } else {
43385 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43386 }
43387 }
43388 } else {
43389 zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43390 }
43391
43392
43393 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
43394 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43395 }
43396
43397 /* 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)43398 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43399 {
43400 USE_OPLINE
43401 zval *property, *container, *value_ptr;
43402
43403 SAVE_OPLINE();
43404
43405 container = EX_VAR(opline->op1.var);
43406 property = RT_CONSTANT(opline, opline->op2);
43407
43408 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
43409
43410 if (1) {
43411 if (IS_CV == IS_UNUSED) {
43412 if (IS_CONST == IS_CONST) {
43413 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43414 } else {
43415 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43416 }
43417 } else {
43418 if (IS_CONST == IS_CONST) {
43419 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43420 } else {
43421 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43422 }
43423 }
43424 } else {
43425 zend_assign_to_property_reference(container, IS_CV, property, IS_CONST, value_ptr OPLINE_CC EXECUTE_DATA_CC);
43426 }
43427
43428
43429
43430 ZEND_VM_NEXT_OPCODE_EX(1, 2);
43431 }
43432
43433 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43434 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43435 {
43436 USE_OPLINE
43437 zval *op1, *op2;
43438 zend_string *op1_str, *op2_str, *str;
43439
43440
43441 op1 = EX_VAR(opline->op1.var);
43442 op2 = RT_CONSTANT(opline, opline->op2);
43443 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
43444 (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
43445 zend_string *op1_str = Z_STR_P(op1);
43446 zend_string *op2_str = Z_STR_P(op2);
43447 zend_string *str;
43448 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
43449
43450 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
43451 if (IS_CONST == IS_CONST || IS_CONST == IS_CV) {
43452 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
43453 } else {
43454 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
43455 }
43456 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
43457 zend_string_release_ex(op1_str, 0);
43458 }
43459 } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
43460 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
43461 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
43462 } else {
43463 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
43464 }
43465 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
43466 zend_string_release_ex(op2_str, 0);
43467 }
43468 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
43469 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
43470 size_t len = ZSTR_LEN(op1_str);
43471
43472 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
43473 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
43474 GC_ADD_FLAGS(str, flags);
43475 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
43476 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
43477 zend_string_release_ex(op2_str, 0);
43478 }
43479 } else {
43480 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
43481 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
43482 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
43483 GC_ADD_FLAGS(str, flags);
43484 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
43485 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
43486 zend_string_release_ex(op1_str, 0);
43487 }
43488 if (IS_CONST & (IS_TMP_VAR|IS_VAR)) {
43489 zend_string_release_ex(op2_str, 0);
43490 }
43491 }
43492 ZEND_VM_NEXT_OPCODE();
43493 }
43494
43495 SAVE_OPLINE();
43496 if (IS_CV == IS_CONST) {
43497 op1_str = Z_STR_P(op1);
43498 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
43499 op1_str = zend_string_copy(Z_STR_P(op1));
43500 } else {
43501 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
43502 ZVAL_UNDEFINED_OP1();
43503 }
43504 op1_str = zval_get_string_func(op1);
43505 }
43506 if (IS_CONST == IS_CONST) {
43507 op2_str = Z_STR_P(op2);
43508 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
43509 op2_str = zend_string_copy(Z_STR_P(op2));
43510 } else {
43511 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
43512 ZVAL_UNDEFINED_OP2();
43513 }
43514 op2_str = zval_get_string_func(op2);
43515 }
43516 do {
43517 if (IS_CV != IS_CONST) {
43518 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
43519 if (IS_CONST == IS_CONST) {
43520 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
43521 GC_ADDREF(op2_str);
43522 }
43523 }
43524 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
43525 zend_string_release_ex(op1_str, 0);
43526 break;
43527 }
43528 }
43529 if (IS_CONST != IS_CONST) {
43530 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
43531 if (IS_CV == IS_CONST) {
43532 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
43533 GC_ADDREF(op1_str);
43534 }
43535 }
43536 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
43537 zend_string_release_ex(op2_str, 0);
43538 break;
43539 }
43540 }
43541 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
43542 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
43543 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
43544
43545 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
43546 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
43547 if (IS_CV != IS_CONST) {
43548 zend_string_release_ex(op1_str, 0);
43549 }
43550 if (IS_CONST != IS_CONST) {
43551 zend_string_release_ex(op2_str, 0);
43552 }
43553 } while (0);
43554
43555
43556 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43557 }
43558
ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43559 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43560 {
43561 USE_OPLINE
43562 zval *function_name;
43563 zval *object;
43564 zend_function *fbc;
43565 zend_class_entry *called_scope;
43566 zend_object *obj;
43567 zend_execute_data *call;
43568 uint32_t call_info;
43569
43570 SAVE_OPLINE();
43571
43572 object = EX_VAR(opline->op1.var);
43573
43574 if (IS_CONST != IS_CONST) {
43575 function_name = RT_CONSTANT(opline, opline->op2);
43576 }
43577
43578 if (IS_CONST != IS_CONST &&
43579 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
43580 do {
43581 if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
43582 function_name = Z_REFVAL_P(function_name);
43583 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
43584 break;
43585 }
43586 } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
43587 ZVAL_UNDEFINED_OP2();
43588 if (UNEXPECTED(EG(exception) != NULL)) {
43589
43590 HANDLE_EXCEPTION();
43591 }
43592 }
43593 zend_throw_error(NULL, "Method name must be a string");
43594
43595
43596 HANDLE_EXCEPTION();
43597 } while (0);
43598 }
43599
43600 if (IS_CV == IS_UNUSED) {
43601 obj = Z_OBJ_P(object);
43602 } else {
43603 do {
43604 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
43605 obj = Z_OBJ_P(object);
43606 } else {
43607 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
43608 zend_reference *ref = Z_REF_P(object);
43609
43610 object = &ref->val;
43611 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
43612 obj = Z_OBJ_P(object);
43613 if (IS_CV & IS_VAR) {
43614 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
43615 efree_size(ref, sizeof(zend_reference));
43616 } else {
43617 Z_ADDREF_P(object);
43618 }
43619 }
43620 break;
43621 }
43622 }
43623 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
43624 object = ZVAL_UNDEFINED_OP1();
43625 if (UNEXPECTED(EG(exception) != NULL)) {
43626 if (IS_CONST != IS_CONST) {
43627
43628 }
43629 HANDLE_EXCEPTION();
43630 }
43631 }
43632 if (IS_CONST == IS_CONST) {
43633 function_name = RT_CONSTANT(opline, opline->op2);
43634 }
43635 zend_invalid_method_call(object, function_name);
43636
43637
43638 HANDLE_EXCEPTION();
43639 }
43640 } while (0);
43641 }
43642
43643 called_scope = obj->ce;
43644
43645 if (IS_CONST == IS_CONST &&
43646 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
43647 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
43648 } else {
43649 zend_object *orig_obj = obj;
43650
43651 if (IS_CONST == IS_CONST) {
43652 function_name = RT_CONSTANT(opline, opline->op2);
43653 }
43654
43655 /* First, locate the function. */
43656 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
43657 if (UNEXPECTED(fbc == NULL)) {
43658 if (EXPECTED(!EG(exception))) {
43659 zend_undefined_method(obj->ce, Z_STR_P(function_name));
43660 }
43661
43662 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
43663 zend_objects_store_del(orig_obj);
43664 }
43665 HANDLE_EXCEPTION();
43666 }
43667 if (IS_CONST == IS_CONST &&
43668 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
43669 EXPECTED(obj == orig_obj)) {
43670 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
43671 }
43672 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
43673 GC_ADDREF(obj); /* For $this pointer */
43674 if (GC_DELREF(orig_obj) == 0) {
43675 zend_objects_store_del(orig_obj);
43676 }
43677 }
43678 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
43679 init_func_run_time_cache(&fbc->op_array);
43680 }
43681 }
43682
43683 if (IS_CONST != IS_CONST) {
43684
43685 }
43686
43687 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
43688 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
43689 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
43690 zend_objects_store_del(obj);
43691 if (UNEXPECTED(EG(exception))) {
43692 HANDLE_EXCEPTION();
43693 }
43694 }
43695 /* call static method */
43696 obj = (zend_object*)called_scope;
43697 call_info = ZEND_CALL_NESTED_FUNCTION;
43698 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
43699 if (IS_CV == IS_CV) {
43700 GC_ADDREF(obj); /* For $this pointer */
43701 }
43702 /* CV may be changed indirectly (e.g. when it's a reference) */
43703 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
43704 }
43705
43706 call = zend_vm_stack_push_call_frame(call_info,
43707 fbc, opline->extended_value, obj);
43708 call->prev_execute_data = EX(call);
43709 EX(call) = call;
43710
43711 ZEND_VM_NEXT_OPCODE();
43712 }
43713
ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43714 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43715 {
43716 USE_OPLINE
43717 zval *varptr, *arg;
43718
43719 if (IS_CONST == IS_CONST) {
43720 SAVE_OPLINE();
43721 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43722 uint32_t arg_num;
43723 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
43724 if (UNEXPECTED(!arg)) {
43725
43726 HANDLE_EXCEPTION();
43727 }
43728 } else {
43729 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
43730 }
43731
43732 varptr = EX_VAR(opline->op1.var);
43733 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
43734 SAVE_OPLINE();
43735 ZVAL_UNDEFINED_OP1();
43736 ZVAL_NULL(arg);
43737 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43738 }
43739
43740 if (IS_CV == IS_CV) {
43741 ZVAL_COPY_DEREF(arg, varptr);
43742 } else /* if (IS_CV == IS_VAR) */ {
43743 if (UNEXPECTED(Z_ISREF_P(varptr))) {
43744 zend_refcounted *ref = Z_COUNTED_P(varptr);
43745
43746 varptr = Z_REFVAL_P(varptr);
43747 ZVAL_COPY_VALUE(arg, varptr);
43748 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
43749 efree_size(ref, sizeof(zend_reference));
43750 } else if (Z_OPT_REFCOUNTED_P(arg)) {
43751 Z_ADDREF_P(arg);
43752 }
43753 } else {
43754 ZVAL_COPY_VALUE(arg, varptr);
43755 }
43756 }
43757
43758 ZEND_VM_NEXT_OPCODE();
43759 }
43760
ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43761 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43762 {
43763 USE_OPLINE
43764 zval *varptr, *arg;
43765
43766 SAVE_OPLINE();
43767 if (IS_CONST == IS_CONST) {
43768 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43769 uint32_t arg_num;
43770 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
43771 if (UNEXPECTED(!arg)) {
43772
43773 HANDLE_EXCEPTION();
43774 }
43775 } else {
43776 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
43777 }
43778
43779 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
43780 if (Z_ISREF_P(varptr)) {
43781 Z_ADDREF_P(varptr);
43782 } else {
43783 ZVAL_MAKE_REF_EX(varptr, 2);
43784 }
43785 ZVAL_REF(arg, Z_REF_P(varptr));
43786
43787 ZEND_VM_NEXT_OPCODE();
43788 }
43789
ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43790 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43791 {
43792 USE_OPLINE
43793 zval *varptr, *arg;
43794 uint32_t arg_num;
43795
43796 if (IS_CONST == IS_CONST) {
43797 SAVE_OPLINE();
43798 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
43799 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
43800 if (UNEXPECTED(!arg)) {
43801
43802 HANDLE_EXCEPTION();
43803 }
43804 } else {
43805 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
43806 arg_num = opline->op2.num;
43807 }
43808
43809 if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
43810 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
43811 goto send_var_by_ref;
43812 }
43813 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
43814 send_var_by_ref:
43815 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
43816 if (Z_ISREF_P(varptr)) {
43817 Z_ADDREF_P(varptr);
43818 } else {
43819 ZVAL_MAKE_REF_EX(varptr, 2);
43820 }
43821 ZVAL_REF(arg, Z_REF_P(varptr));
43822
43823 ZEND_VM_NEXT_OPCODE();
43824 }
43825
43826 varptr = EX_VAR(opline->op1.var);
43827 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
43828 SAVE_OPLINE();
43829 ZVAL_UNDEFINED_OP1();
43830 ZVAL_NULL(arg);
43831 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43832 }
43833
43834 if (IS_CV == IS_CV) {
43835 ZVAL_COPY_DEREF(arg, varptr);
43836 } else /* if (IS_CV == IS_VAR) */ {
43837 if (UNEXPECTED(Z_ISREF_P(varptr))) {
43838 zend_refcounted *ref = Z_COUNTED_P(varptr);
43839
43840 varptr = Z_REFVAL_P(varptr);
43841 ZVAL_COPY_VALUE(arg, varptr);
43842 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
43843 efree_size(ref, sizeof(zend_reference));
43844 } else if (Z_OPT_REFCOUNTED_P(arg)) {
43845 Z_ADDREF_P(arg);
43846 }
43847 } else {
43848 ZVAL_COPY_VALUE(arg, varptr);
43849 }
43850 }
43851
43852 ZEND_VM_NEXT_OPCODE();
43853 }
43854
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43855 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43856 {
43857 USE_OPLINE
43858 zval *expr_ptr, new_expr;
43859
43860 SAVE_OPLINE();
43861 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
43862 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
43863 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
43864 if (Z_ISREF_P(expr_ptr)) {
43865 Z_ADDREF_P(expr_ptr);
43866 } else {
43867 ZVAL_MAKE_REF_EX(expr_ptr, 2);
43868 }
43869
43870 } else {
43871 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
43872 if (IS_CV == IS_TMP_VAR) {
43873 /* pass */
43874 } else if (IS_CV == IS_CONST) {
43875 Z_TRY_ADDREF_P(expr_ptr);
43876 } else if (IS_CV == IS_CV) {
43877 ZVAL_DEREF(expr_ptr);
43878 Z_TRY_ADDREF_P(expr_ptr);
43879 } else /* if (IS_CV == IS_VAR) */ {
43880 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
43881 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
43882
43883 expr_ptr = Z_REFVAL_P(expr_ptr);
43884 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
43885 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
43886 expr_ptr = &new_expr;
43887 efree_size(ref, sizeof(zend_reference));
43888 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
43889 Z_ADDREF_P(expr_ptr);
43890 }
43891 }
43892 }
43893 }
43894
43895 if (IS_CONST != IS_UNUSED) {
43896 zval *offset = RT_CONSTANT(opline, opline->op2);
43897 zend_string *str;
43898 zend_ulong hval;
43899
43900 add_again:
43901 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
43902 str = Z_STR_P(offset);
43903 if (IS_CONST != IS_CONST) {
43904 if (ZEND_HANDLE_NUMERIC(str, hval)) {
43905 goto num_index;
43906 }
43907 }
43908 str_index:
43909 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
43910 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
43911 hval = Z_LVAL_P(offset);
43912 num_index:
43913 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
43914 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
43915 offset = Z_REFVAL_P(offset);
43916 goto add_again;
43917 } else if (Z_TYPE_P(offset) == IS_NULL) {
43918 str = ZSTR_EMPTY_ALLOC();
43919 goto str_index;
43920 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
43921 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
43922 goto num_index;
43923 } else if (Z_TYPE_P(offset) == IS_FALSE) {
43924 hval = 0;
43925 goto num_index;
43926 } else if (Z_TYPE_P(offset) == IS_TRUE) {
43927 hval = 1;
43928 goto num_index;
43929 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
43930 zend_use_resource_as_offset(offset);
43931 hval = Z_RES_HANDLE_P(offset);
43932 goto num_index;
43933 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
43934 ZVAL_UNDEFINED_OP2();
43935 str = ZSTR_EMPTY_ALLOC();
43936 goto str_index;
43937 } else {
43938 zend_illegal_array_offset_access(offset);
43939 zval_ptr_dtor_nogc(expr_ptr);
43940 }
43941
43942 } else {
43943 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
43944 zend_cannot_add_element();
43945 zval_ptr_dtor_nogc(expr_ptr);
43946 }
43947 }
43948 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
43949 }
43950
ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43951 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43952 {
43953 zval *array;
43954 uint32_t size;
43955 USE_OPLINE
43956
43957 array = EX_VAR(opline->result.var);
43958 if (IS_CV != IS_UNUSED) {
43959 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
43960 ZVAL_ARR(array, zend_new_array(size));
43961 /* Explicitly initialize array as not-packed if flag is set */
43962 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
43963 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
43964 }
43965 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
43966 } else {
43967 ZVAL_ARR(array, zend_new_array(0));
43968 ZEND_VM_NEXT_OPCODE();
43969 }
43970 }
43971
ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)43972 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
43973 {
43974 USE_OPLINE
43975 zval *container;
43976 zval *offset;
43977 zend_ulong hval;
43978 zend_string *key;
43979
43980 SAVE_OPLINE();
43981 container = EX_VAR(opline->op1.var);
43982 offset = RT_CONSTANT(opline, opline->op2);
43983
43984 do {
43985 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
43986 HashTable *ht;
43987
43988 unset_dim_array:
43989 SEPARATE_ARRAY(container);
43990 ht = Z_ARRVAL_P(container);
43991 offset_again:
43992 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
43993 key = Z_STR_P(offset);
43994 if (IS_CONST != IS_CONST) {
43995 if (ZEND_HANDLE_NUMERIC(key, hval)) {
43996 goto num_index_dim;
43997 }
43998 }
43999 str_index_dim:
44000 ZEND_ASSERT(ht != &EG(symbol_table));
44001 zend_hash_del(ht, key);
44002 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
44003 hval = Z_LVAL_P(offset);
44004 num_index_dim:
44005 zend_hash_index_del(ht, hval);
44006 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
44007 offset = Z_REFVAL_P(offset);
44008 goto offset_again;
44009 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
44010 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
44011 goto num_index_dim;
44012 } else if (Z_TYPE_P(offset) == IS_NULL) {
44013 key = ZSTR_EMPTY_ALLOC();
44014 goto str_index_dim;
44015 } else if (Z_TYPE_P(offset) == IS_FALSE) {
44016 hval = 0;
44017 goto num_index_dim;
44018 } else if (Z_TYPE_P(offset) == IS_TRUE) {
44019 hval = 1;
44020 goto num_index_dim;
44021 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
44022 zend_use_resource_as_offset(offset);
44023 hval = Z_RES_HANDLE_P(offset);
44024 goto num_index_dim;
44025 } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
44026 ZVAL_UNDEFINED_OP2();
44027 key = ZSTR_EMPTY_ALLOC();
44028 goto str_index_dim;
44029 } else {
44030 zend_illegal_array_offset_unset(offset);
44031 }
44032 break;
44033 } else if (Z_ISREF_P(container)) {
44034 container = Z_REFVAL_P(container);
44035 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44036 goto unset_dim_array;
44037 }
44038 }
44039 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
44040 container = ZVAL_UNDEFINED_OP1();
44041 }
44042 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
44043 offset = ZVAL_UNDEFINED_OP2();
44044 }
44045 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
44046 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
44047 offset++;
44048 }
44049 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
44050 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
44051 zend_throw_error(NULL, "Cannot unset string offsets");
44052 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
44053 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
44054 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
44055 zend_false_to_array_deprecated();
44056 }
44057 } while (0);
44058
44059
44060 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44061 }
44062
ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44063 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44064 {
44065 USE_OPLINE
44066 zval *container;
44067 zval *offset;
44068 zend_string *name, *tmp_name;
44069
44070 SAVE_OPLINE();
44071 container = EX_VAR(opline->op1.var);
44072 offset = RT_CONSTANT(opline, opline->op2);
44073
44074 do {
44075 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
44076 if (Z_ISREF_P(container)) {
44077 container = Z_REFVAL_P(container);
44078 if (Z_TYPE_P(container) != IS_OBJECT) {
44079 if (IS_CV == IS_CV
44080 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
44081 ZVAL_UNDEFINED_OP1();
44082 }
44083 break;
44084 }
44085 } else {
44086 break;
44087 }
44088 }
44089 if (IS_CONST == IS_CONST) {
44090 name = Z_STR_P(offset);
44091 } else {
44092 name = zval_try_get_tmp_string(offset, &tmp_name);
44093 if (UNEXPECTED(!name)) {
44094 break;
44095 }
44096 }
44097 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
44098 if (IS_CONST != IS_CONST) {
44099 zend_tmp_string_release(tmp_name);
44100 }
44101 } while (0);
44102
44103
44104 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44105 }
44106
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44107 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44108 {
44109 USE_OPLINE
44110 zval *container;
44111 bool result;
44112 zend_ulong hval;
44113 zval *offset;
44114
44115 SAVE_OPLINE();
44116 container = EX_VAR(opline->op1.var);
44117 offset = RT_CONSTANT(opline, opline->op2);
44118
44119 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44120 HashTable *ht;
44121 zval *value;
44122 zend_string *str;
44123
44124 isset_dim_obj_array:
44125 ht = Z_ARRVAL_P(container);
44126 isset_again:
44127 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
44128 str = Z_STR_P(offset);
44129 if (IS_CONST != IS_CONST) {
44130 if (ZEND_HANDLE_NUMERIC(str, hval)) {
44131 goto num_index_prop;
44132 }
44133 }
44134 value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST);
44135 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
44136 hval = Z_LVAL_P(offset);
44137 num_index_prop:
44138 value = zend_hash_index_find(ht, hval);
44139 } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
44140 offset = Z_REFVAL_P(offset);
44141 goto isset_again;
44142 } else {
44143 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
44144 if (UNEXPECTED(EG(exception))) {
44145 result = 0;
44146 goto isset_dim_obj_exit;
44147 }
44148 }
44149
44150 if (!(opline->extended_value & ZEND_ISEMPTY)) {
44151 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
44152 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
44153 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
44154
44155 if (IS_CV & (IS_CONST|IS_CV)) {
44156 /* avoid exception check */
44157
44158 ZEND_VM_SMART_BRANCH(result, 0);
44159 }
44160 } else {
44161 result = (value == NULL || !i_zend_is_true(value));
44162 }
44163 goto isset_dim_obj_exit;
44164 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
44165 container = Z_REFVAL_P(container);
44166 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44167 goto isset_dim_obj_array;
44168 }
44169 }
44170
44171 if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
44172 offset++;
44173 }
44174 if (!(opline->extended_value & ZEND_ISEMPTY)) {
44175 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
44176 } else {
44177 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
44178 }
44179
44180 isset_dim_obj_exit:
44181
44182
44183 ZEND_VM_SMART_BRANCH(result, 1);
44184 }
44185
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44186 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44187 {
44188 USE_OPLINE
44189 zval *container;
44190 int result;
44191 zval *offset;
44192 zend_string *name, *tmp_name;
44193
44194 SAVE_OPLINE();
44195 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
44196 offset = RT_CONSTANT(opline, opline->op2);
44197
44198 if (IS_CV == IS_CONST ||
44199 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
44200 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
44201 container = Z_REFVAL_P(container);
44202 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
44203 result = (opline->extended_value & ZEND_ISEMPTY);
44204 goto isset_object_finish;
44205 }
44206 } else {
44207 result = (opline->extended_value & ZEND_ISEMPTY);
44208 goto isset_object_finish;
44209 }
44210 }
44211
44212 if (IS_CONST == IS_CONST) {
44213 name = Z_STR_P(offset);
44214 } else {
44215 name = zval_try_get_tmp_string(offset, &tmp_name);
44216 if (UNEXPECTED(!name)) {
44217 result = 0;
44218 goto isset_object_finish;
44219 }
44220 }
44221
44222 result =
44223 (opline->extended_value & ZEND_ISEMPTY) ^
44224 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));
44225
44226 if (IS_CONST != IS_CONST) {
44227 zend_tmp_string_release(tmp_name);
44228 }
44229
44230 isset_object_finish:
44231
44232
44233 ZEND_VM_SMART_BRANCH(result, 1);
44234 }
44235
ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44236 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44237 {
44238 USE_OPLINE
44239
44240 zval *key, *subject;
44241 HashTable *ht;
44242 bool result;
44243
44244 SAVE_OPLINE();
44245
44246 key = EX_VAR(opline->op1.var);
44247 subject = RT_CONSTANT(opline, opline->op2);
44248
44249 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
44250 array_key_exists_array:
44251 ht = Z_ARRVAL_P(subject);
44252 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
44253 } else {
44254 if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
44255 subject = Z_REFVAL_P(subject);
44256 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
44257 goto array_key_exists_array;
44258 }
44259 }
44260 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
44261 result = 0;
44262 }
44263
44264
44265 ZEND_VM_SMART_BRANCH(result, 1);
44266 }
44267
44268 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44269 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44270 {
44271 USE_OPLINE
44272 zval *expr;
44273 bool result;
44274
44275 SAVE_OPLINE();
44276 expr = EX_VAR(opline->op1.var);
44277
44278 try_instanceof:
44279 if (Z_TYPE_P(expr) == IS_OBJECT) {
44280 zend_class_entry *ce;
44281
44282 if (IS_CONST == IS_CONST) {
44283 ce = CACHED_PTR(opline->extended_value);
44284 if (UNEXPECTED(ce == NULL)) {
44285 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);
44286 if (EXPECTED(ce)) {
44287 CACHE_PTR(opline->extended_value, ce);
44288 }
44289 }
44290 } else if (IS_CONST == IS_UNUSED) {
44291 ce = zend_fetch_class(NULL, opline->op2.num);
44292 if (UNEXPECTED(ce == NULL)) {
44293
44294 ZVAL_UNDEF(EX_VAR(opline->result.var));
44295 HANDLE_EXCEPTION();
44296 }
44297 } else {
44298 ce = Z_CE_P(EX_VAR(opline->op2.var));
44299 }
44300 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
44301 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
44302 expr = Z_REFVAL_P(expr);
44303 goto try_instanceof;
44304 } else {
44305 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
44306 ZVAL_UNDEFINED_OP1();
44307 }
44308 result = 0;
44309 }
44310
44311 ZEND_VM_SMART_BRANCH(result, 1);
44312 }
44313
ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44314 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44315 {
44316 USE_OPLINE
44317
44318 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
44319
44320 SAVE_OPLINE();
44321 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
44322 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
44323 }
44324
44325 /* Destroy the previously yielded value */
44326 zval_ptr_dtor(&generator->value);
44327
44328 /* Destroy the previously yielded key */
44329 zval_ptr_dtor(&generator->key);
44330
44331 /* Set the new yielded value */
44332 if (IS_CV != IS_UNUSED) {
44333 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
44334 /* Constants and temporary variables aren't yieldable by reference,
44335 * but we still allow them with a notice. */
44336 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
44337 zval *value;
44338
44339 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
44340
44341 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
44342 ZVAL_COPY_VALUE(&generator->value, value);
44343 if (IS_CV == IS_CONST) {
44344 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
44345 Z_ADDREF(generator->value);
44346 }
44347 }
44348 } else {
44349 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
44350
44351 /* If a function call result is yielded and the function did
44352 * not return by reference we throw a notice. */
44353 do {
44354 if (IS_CV == IS_VAR) {
44355 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
44356 if (opline->extended_value == ZEND_RETURNS_FUNCTION
44357 && !Z_ISREF_P(value_ptr)) {
44358 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
44359 ZVAL_COPY(&generator->value, value_ptr);
44360 break;
44361 }
44362 }
44363 if (Z_ISREF_P(value_ptr)) {
44364 Z_ADDREF_P(value_ptr);
44365 } else {
44366 ZVAL_MAKE_REF_EX(value_ptr, 2);
44367 }
44368 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
44369 } while (0);
44370
44371 }
44372 } else {
44373 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
44374
44375 /* Consts, temporary variables and references need copying */
44376 if (IS_CV == IS_CONST) {
44377 ZVAL_COPY_VALUE(&generator->value, value);
44378 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
44379 Z_ADDREF(generator->value);
44380 }
44381 } else if (IS_CV == IS_TMP_VAR) {
44382 ZVAL_COPY_VALUE(&generator->value, value);
44383 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
44384 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
44385
44386 } else {
44387 ZVAL_COPY_VALUE(&generator->value, value);
44388 if (IS_CV == IS_CV) {
44389 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
44390 }
44391 }
44392 }
44393 } else {
44394 /* If no value was specified yield null */
44395 ZVAL_NULL(&generator->value);
44396 }
44397
44398 /* Set the new yielded key */
44399 if (IS_CONST != IS_UNUSED) {
44400 zval *key = RT_CONSTANT(opline, opline->op2);
44401 if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
44402 key = Z_REFVAL_P(key);
44403 }
44404 ZVAL_COPY(&generator->key, key);
44405
44406 if (Z_TYPE(generator->key) == IS_LONG
44407 && Z_LVAL(generator->key) > generator->largest_used_integer_key
44408 ) {
44409 generator->largest_used_integer_key = Z_LVAL(generator->key);
44410 }
44411 } else {
44412 /* If no key was specified we use auto-increment keys */
44413 generator->largest_used_integer_key++;
44414 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
44415 }
44416
44417 if (RETURN_VALUE_USED(opline)) {
44418 /* If the return value of yield is used set the send
44419 * target and initialize it to NULL */
44420 generator->send_target = EX_VAR(opline->result.var);
44421 ZVAL_NULL(generator->send_target);
44422 } else {
44423 generator->send_target = NULL;
44424 }
44425
44426 /* We increment to the next op, so we are at the correct position when the
44427 * generator is resumed. */
44428 ZEND_VM_INC_OPCODE();
44429
44430 /* The GOTO VM uses a local opline variable. We need to set the opline
44431 * variable in execute_data so we don't resume at an old position. */
44432 SAVE_OPLINE();
44433
44434 ZEND_VM_RETURN();
44435 }
44436
ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44437 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44438 {
44439 USE_OPLINE
44440 zend_string *varname;
44441 zval *value;
44442 zval *variable_ptr;
44443 uintptr_t idx;
44444 zend_reference *ref;
44445
44446 ZEND_VM_REPEATABLE_OPCODE
44447
44448 varname = Z_STR_P(RT_CONSTANT(opline, opline->op2));
44449
44450 /* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
44451 idx = (uintptr_t)CACHED_PTR(opline->extended_value) - 1;
44452 if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket))) {
44453 Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
44454
44455 if (EXPECTED(p->key == varname) ||
44456 (EXPECTED(p->h == ZSTR_H(varname)) &&
44457 EXPECTED(p->key != NULL) &&
44458 EXPECTED(zend_string_equal_content(p->key, varname)))) {
44459
44460 value = (zval*)p; /* value = &p->val; */
44461 goto check_indirect;
44462 }
44463 }
44464
44465 value = zend_hash_find_known_hash(&EG(symbol_table), varname);
44466 if (UNEXPECTED(value == NULL)) {
44467 value = zend_hash_add_new(&EG(symbol_table), varname, &EG(uninitialized_zval));
44468 idx = (char*)value - (char*)EG(symbol_table).arData;
44469 /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
44470 CACHE_PTR(opline->extended_value, (void*)(idx + 1));
44471 } else {
44472 idx = (char*)value - (char*)EG(symbol_table).arData;
44473 /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
44474 CACHE_PTR(opline->extended_value, (void*)(idx + 1));
44475 check_indirect:
44476 /* GLOBAL variable may be an INDIRECT pointer to CV */
44477 if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
44478 value = Z_INDIRECT_P(value);
44479 if (UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
44480 ZVAL_NULL(value);
44481 }
44482 }
44483 }
44484
44485 if (UNEXPECTED(!Z_ISREF_P(value))) {
44486 ZVAL_MAKE_REF_EX(value, 2);
44487 ref = Z_REF_P(value);
44488 } else {
44489 ref = Z_REF_P(value);
44490 GC_ADDREF(ref);
44491 }
44492
44493 variable_ptr = EX_VAR(opline->op1.var);
44494
44495 if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr))) {
44496 zend_refcounted *garbage = Z_COUNTED_P(variable_ptr);
44497
44498 ZVAL_REF(variable_ptr, ref);
44499 SAVE_OPLINE();
44500 if (GC_DELREF(garbage) == 0) {
44501 rc_dtor_func(garbage);
44502 if (UNEXPECTED(EG(exception))) {
44503 ZVAL_NULL(variable_ptr);
44504 HANDLE_EXCEPTION();
44505 }
44506 } else {
44507 gc_check_possible_root(garbage);
44508 }
44509 } else {
44510 ZVAL_REF(variable_ptr, ref);
44511 }
44512
44513 ZEND_VM_REPEAT_OPCODE(ZEND_BIND_GLOBAL);
44514 ZEND_VM_NEXT_OPCODE();
44515 }
44516
ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44517 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44518 {
44519 USE_OPLINE
44520 zval *op1;
44521 HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2));
44522 zval *result;
44523
44524 op1 = EX_VAR(opline->op1.var);
44525 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44526 result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_CV == IS_CONST);
44527 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44528 zval_ptr_dtor_str(op1);
44529 }
44530 ZEND_VM_SMART_BRANCH(result, 0);
44531 }
44532
44533 if (opline->extended_value) {
44534 if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
44535 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
44536 ZEND_VM_SMART_BRANCH(result, 0);
44537 }
44538 SAVE_OPLINE();
44539 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
44540 op1 = Z_REFVAL_P(op1);
44541 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44542 result = zend_hash_find(ht, Z_STR_P(op1));
44543
44544 ZEND_VM_SMART_BRANCH(result, 0);
44545 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
44546 result = zend_hash_index_find(ht, Z_LVAL_P(op1));
44547
44548 ZEND_VM_SMART_BRANCH(result, 0);
44549 }
44550 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
44551 ZVAL_UNDEFINED_OP1();
44552 }
44553 } else if (Z_TYPE_P(op1) <= IS_FALSE) {
44554 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
44555 SAVE_OPLINE();
44556 ZVAL_UNDEFINED_OP1();
44557 if (UNEXPECTED(EG(exception) != NULL)) {
44558 HANDLE_EXCEPTION();
44559 }
44560 }
44561 result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC());
44562 ZEND_VM_SMART_BRANCH(result, 0);
44563 } else {
44564 zend_string *key;
44565 zval key_tmp;
44566
44567 if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) {
44568 op1 = Z_REFVAL_P(op1);
44569 if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44570 result = zend_hash_find(ht, Z_STR_P(op1));
44571
44572 ZEND_VM_SMART_BRANCH(result, 0);
44573 }
44574 }
44575
44576 SAVE_OPLINE();
44577 ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) {
44578 ZVAL_STR(&key_tmp, key);
44579 if (zend_compare(op1, &key_tmp) == 0) {
44580
44581 ZEND_VM_SMART_BRANCH(1, 1);
44582 }
44583 } ZEND_HASH_FOREACH_END();
44584 }
44585
44586 ZEND_VM_SMART_BRANCH(0, 1);
44587 }
44588
ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44589 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44590 {
44591 /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
44592 /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
44593 /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
44594 USE_OPLINE
44595 zval *op1, *op2;
44596 bool result;
44597
44598 op1 = EX_VAR(opline->op1.var);
44599 op2 = RT_CONSTANT(opline, opline->op2);
44600 result = fast_is_identical_function(op1, op2);
44601 /* Free is a no-op for const/cv */
44602 ZEND_VM_SMART_BRANCH(result, 0);
44603 }
44604
ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44605 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44606 {
44607 USE_OPLINE
44608 zval *op1, *op2;
44609 bool result;
44610
44611 op1 = EX_VAR(opline->op1.var);
44612 op2 = RT_CONSTANT(opline, opline->op2);
44613 result = fast_is_identical_function(op1, op2);
44614 /* Free is a no-op for const/cv */
44615 ZEND_VM_SMART_BRANCH(!result, 0);
44616 }
44617
ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44618 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44619 {
44620 USE_OPLINE
44621 zval *container, *dim, *value;
44622 zend_long offset;
44623 HashTable *ht;
44624
44625 container = EX_VAR(opline->op1.var);
44626 dim = RT_CONSTANT(opline, opline->op2);
44627 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44628 fetch_dim_r_index_array:
44629 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
44630 offset = Z_LVAL_P(dim);
44631 } else {
44632 SAVE_OPLINE();
44633 zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC);
44634
44635 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44636 }
44637 ht = Z_ARRVAL_P(container);
44638 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
44639 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
44640 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44641 SAVE_OPLINE();
44642
44643 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44644 } else {
44645 ZEND_VM_NEXT_OPCODE();
44646 }
44647 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
44648 container = Z_REFVAL_P(container);
44649 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44650 goto fetch_dim_r_index_array;
44651 } else {
44652 goto fetch_dim_r_index_slow;
44653 }
44654 } else {
44655 fetch_dim_r_index_slow:
44656 SAVE_OPLINE();
44657 if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44658 dim++;
44659 }
44660 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
44661
44662 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44663 }
44664
44665 fetch_dim_r_index_undef:
44666 ZVAL_NULL(EX_VAR(opline->result.var));
44667 SAVE_OPLINE();
44668 zend_undefined_offset(offset);
44669
44670 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44671 }
44672
ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44673 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44674 {
44675 USE_OPLINE
44676 zval *container, *dim, *value;
44677 zend_long offset;
44678 HashTable *ht;
44679
44680 container = EX_VAR(opline->op1.var);
44681 dim = EX_VAR(opline->op2.var);
44682 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44683 fetch_dim_r_index_array:
44684 if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
44685 offset = Z_LVAL_P(dim);
44686 } else {
44687 SAVE_OPLINE();
44688 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC);
44689
44690 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44691 }
44692 ht = Z_ARRVAL_P(container);
44693 ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef);
44694 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
44695 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44696 SAVE_OPLINE();
44697
44698 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44699 } else {
44700 ZEND_VM_NEXT_OPCODE();
44701 }
44702 } else if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
44703 container = Z_REFVAL_P(container);
44704 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
44705 goto fetch_dim_r_index_array;
44706 } else {
44707 goto fetch_dim_r_index_slow;
44708 }
44709 } else {
44710 fetch_dim_r_index_slow:
44711 SAVE_OPLINE();
44712 if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
44713 dim++;
44714 }
44715 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
44716
44717 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44718 }
44719
44720 fetch_dim_r_index_undef:
44721 ZVAL_NULL(EX_VAR(opline->result.var));
44722 SAVE_OPLINE();
44723 zend_undefined_offset(offset);
44724
44725 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44726 }
44727
ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44728 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44729 {
44730 USE_OPLINE
44731 zval *op1, *op2;
44732
44733 SAVE_OPLINE();
44734 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
44735 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44736 div_function(EX_VAR(opline->result.var), op1, op2);
44737
44738 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
44739 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44740 }
44741
ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44742 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44743 {
44744 USE_OPLINE
44745 zval *op1, *op2;
44746
44747 SAVE_OPLINE();
44748 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
44749 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44750 pow_function(EX_VAR(opline->result.var), op1, op2);
44751
44752 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
44753 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44754 }
44755
ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44756 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44757 {
44758 USE_OPLINE
44759 zval *op1, *op2;
44760
44761 op1 = EX_VAR(opline->op1.var);
44762 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44763
44764 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
44765 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
44766 zend_string *op1_str = Z_STR_P(op1);
44767 zend_string *op2_str = Z_STR_P(op2);
44768 zend_string *str;
44769 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
44770
44771 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
44772 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
44773 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
44774 } else {
44775 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
44776 }
44777 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44778 zend_string_release_ex(op1_str, 0);
44779 }
44780 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
44781 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
44782 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
44783 } else {
44784 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
44785 }
44786 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
44787 zend_string_release_ex(op2_str, 0);
44788 }
44789 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
44790 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
44791 size_t len = ZSTR_LEN(op1_str);
44792
44793 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
44794 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
44795 }
44796 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
44797 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44798 GC_ADD_FLAGS(str, flags);
44799 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44800 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
44801 zend_string_release_ex(op2_str, 0);
44802 }
44803 } else {
44804 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
44805 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
44806 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
44807 GC_ADD_FLAGS(str, flags);
44808 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
44809 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44810 zend_string_release_ex(op1_str, 0);
44811 }
44812 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
44813 zend_string_release_ex(op2_str, 0);
44814 }
44815 }
44816 ZEND_VM_NEXT_OPCODE();
44817 } else {
44818 SAVE_OPLINE();
44819
44820 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
44821 op1 = ZVAL_UNDEFINED_OP1();
44822 }
44823 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
44824 op2 = ZVAL_UNDEFINED_OP2();
44825 }
44826 concat_function(EX_VAR(opline->result.var), op1, op2);
44827
44828 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
44829 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
44830 }
44831 }
44832
ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44833 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44834 {
44835 USE_OPLINE
44836 zval *op1, *op2;
44837 double d1, d2;
44838
44839 op1 = EX_VAR(opline->op1.var);
44840 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44841 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
44842 /* pass */
44843 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
44844 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
44845 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
44846 is_equal_true:
44847 ZEND_VM_SMART_BRANCH_TRUE_NONE();
44848 } else {
44849 is_equal_false:
44850 ZEND_VM_SMART_BRANCH_FALSE_NONE();
44851 }
44852 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44853 d1 = (double)Z_LVAL_P(op1);
44854 d2 = Z_DVAL_P(op2);
44855 goto is_equal_double;
44856 }
44857 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
44858 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44859 d1 = Z_DVAL_P(op1);
44860 d2 = Z_DVAL_P(op2);
44861 is_equal_double:
44862 if (d1 == d2) {
44863 goto is_equal_true;
44864 } else {
44865 goto is_equal_false;
44866 }
44867 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
44868 d1 = Z_DVAL_P(op1);
44869 d2 = (double)Z_LVAL_P(op2);
44870 goto is_equal_double;
44871 }
44872 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44873 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
44874 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
44875 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44876 zval_ptr_dtor_str(op1);
44877 }
44878 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
44879 zval_ptr_dtor_str(op2);
44880 }
44881 if (result) {
44882 goto is_equal_true;
44883 } else {
44884 goto is_equal_false;
44885 }
44886 }
44887 }
44888 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
44889 }
44890
ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44891 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44892 {
44893 USE_OPLINE
44894 zval *op1, *op2;
44895 double d1, d2;
44896
44897 op1 = EX_VAR(opline->op1.var);
44898 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44899 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
44900 /* pass */
44901 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
44902 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
44903 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
44904 is_equal_true:
44905 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
44906 } else {
44907 is_equal_false:
44908 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
44909 }
44910 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44911 d1 = (double)Z_LVAL_P(op1);
44912 d2 = Z_DVAL_P(op2);
44913 goto is_equal_double;
44914 }
44915 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
44916 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44917 d1 = Z_DVAL_P(op1);
44918 d2 = Z_DVAL_P(op2);
44919 is_equal_double:
44920 if (d1 == d2) {
44921 goto is_equal_true;
44922 } else {
44923 goto is_equal_false;
44924 }
44925 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
44926 d1 = Z_DVAL_P(op1);
44927 d2 = (double)Z_LVAL_P(op2);
44928 goto is_equal_double;
44929 }
44930 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44931 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
44932 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
44933 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44934 zval_ptr_dtor_str(op1);
44935 }
44936 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
44937 zval_ptr_dtor_str(op2);
44938 }
44939 if (result) {
44940 goto is_equal_true;
44941 } else {
44942 goto is_equal_false;
44943 }
44944 }
44945 }
44946 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
44947 }
44948
ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)44949 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
44950 {
44951 USE_OPLINE
44952 zval *op1, *op2;
44953 double d1, d2;
44954
44955 op1 = EX_VAR(opline->op1.var);
44956 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
44957 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
44958 /* pass */
44959 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
44960 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
44961 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
44962 is_equal_true:
44963 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
44964 } else {
44965 is_equal_false:
44966 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
44967 }
44968 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44969 d1 = (double)Z_LVAL_P(op1);
44970 d2 = Z_DVAL_P(op2);
44971 goto is_equal_double;
44972 }
44973 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
44974 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
44975 d1 = Z_DVAL_P(op1);
44976 d2 = Z_DVAL_P(op2);
44977 is_equal_double:
44978 if (d1 == d2) {
44979 goto is_equal_true;
44980 } else {
44981 goto is_equal_false;
44982 }
44983 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
44984 d1 = Z_DVAL_P(op1);
44985 d2 = (double)Z_LVAL_P(op2);
44986 goto is_equal_double;
44987 }
44988 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
44989 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
44990 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
44991 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
44992 zval_ptr_dtor_str(op1);
44993 }
44994 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
44995 zval_ptr_dtor_str(op2);
44996 }
44997 if (result) {
44998 goto is_equal_true;
44999 } else {
45000 goto is_equal_false;
45001 }
45002 }
45003 }
45004 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
45005 }
45006
ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45007 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45008 {
45009 USE_OPLINE
45010 zval *op1, *op2;
45011 double d1, d2;
45012
45013 op1 = EX_VAR(opline->op1.var);
45014 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45015 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
45016 /* pass */
45017 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45018 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45019 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
45020 is_not_equal_true:
45021 ZEND_VM_SMART_BRANCH_TRUE_NONE();
45022 } else {
45023 is_not_equal_false:
45024 ZEND_VM_SMART_BRANCH_FALSE_NONE();
45025 }
45026 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45027 d1 = (double)Z_LVAL_P(op1);
45028 d2 = Z_DVAL_P(op2);
45029 goto is_not_equal_double;
45030 }
45031 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
45032 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45033 d1 = Z_DVAL_P(op1);
45034 d2 = Z_DVAL_P(op2);
45035 is_not_equal_double:
45036 if (d1 != d2) {
45037 goto is_not_equal_true;
45038 } else {
45039 goto is_not_equal_false;
45040 }
45041 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45042 d1 = Z_DVAL_P(op1);
45043 d2 = (double)Z_LVAL_P(op2);
45044 goto is_not_equal_double;
45045 }
45046 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45047 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
45048 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
45049 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45050 zval_ptr_dtor_str(op1);
45051 }
45052 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
45053 zval_ptr_dtor_str(op2);
45054 }
45055 if (!result) {
45056 goto is_not_equal_true;
45057 } else {
45058 goto is_not_equal_false;
45059 }
45060 }
45061 }
45062 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
45063 }
45064
ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45065 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45066 {
45067 USE_OPLINE
45068 zval *op1, *op2;
45069 double d1, d2;
45070
45071 op1 = EX_VAR(opline->op1.var);
45072 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45073 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
45074 /* pass */
45075 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45076 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45077 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
45078 is_not_equal_true:
45079 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
45080 } else {
45081 is_not_equal_false:
45082 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
45083 }
45084 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45085 d1 = (double)Z_LVAL_P(op1);
45086 d2 = Z_DVAL_P(op2);
45087 goto is_not_equal_double;
45088 }
45089 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
45090 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45091 d1 = Z_DVAL_P(op1);
45092 d2 = Z_DVAL_P(op2);
45093 is_not_equal_double:
45094 if (d1 != d2) {
45095 goto is_not_equal_true;
45096 } else {
45097 goto is_not_equal_false;
45098 }
45099 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45100 d1 = Z_DVAL_P(op1);
45101 d2 = (double)Z_LVAL_P(op2);
45102 goto is_not_equal_double;
45103 }
45104 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45105 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
45106 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
45107 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45108 zval_ptr_dtor_str(op1);
45109 }
45110 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
45111 zval_ptr_dtor_str(op2);
45112 }
45113 if (!result) {
45114 goto is_not_equal_true;
45115 } else {
45116 goto is_not_equal_false;
45117 }
45118 }
45119 }
45120 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
45121 }
45122
ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45123 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45124 {
45125 USE_OPLINE
45126 zval *op1, *op2;
45127 double d1, d2;
45128
45129 op1 = EX_VAR(opline->op1.var);
45130 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45131 if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) {
45132 /* pass */
45133 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
45134 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45135 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
45136 is_not_equal_true:
45137 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
45138 } else {
45139 is_not_equal_false:
45140 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
45141 }
45142 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45143 d1 = (double)Z_LVAL_P(op1);
45144 d2 = Z_DVAL_P(op2);
45145 goto is_not_equal_double;
45146 }
45147 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
45148 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
45149 d1 = Z_DVAL_P(op1);
45150 d2 = Z_DVAL_P(op2);
45151 is_not_equal_double:
45152 if (d1 != d2) {
45153 goto is_not_equal_true;
45154 } else {
45155 goto is_not_equal_false;
45156 }
45157 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
45158 d1 = Z_DVAL_P(op1);
45159 d2 = (double)Z_LVAL_P(op2);
45160 goto is_not_equal_double;
45161 }
45162 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
45163 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
45164 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
45165 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
45166 zval_ptr_dtor_str(op1);
45167 }
45168 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
45169 zval_ptr_dtor_str(op2);
45170 }
45171 if (!result) {
45172 goto is_not_equal_true;
45173 } else {
45174 goto is_not_equal_false;
45175 }
45176 }
45177 }
45178 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
45179 }
45180
ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45181 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45182 {
45183 USE_OPLINE
45184 zval *op1, *op2;
45185
45186 SAVE_OPLINE();
45187 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45188 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45189 compare_function(EX_VAR(opline->result.var), op1, op2);
45190
45191 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45192 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45193 }
45194
ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45195 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45196 {
45197 USE_OPLINE
45198 zval *op1, *op2;
45199
45200 SAVE_OPLINE();
45201 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
45202 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45203 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
45204
45205 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45206 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45207 }
45208
ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45209 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45210 {
45211 USE_OPLINE
45212 zval *object;
45213 zval *property;
45214 zval *value;
45215 zval *zptr;
45216 void **cache_slot;
45217 zend_property_info *prop_info;
45218 zend_object *zobj;
45219 zend_string *name, *tmp_name;
45220
45221 SAVE_OPLINE();
45222 object = EX_VAR(opline->op1.var);
45223 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45224
45225 do {
45226 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
45227
45228 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
45229 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
45230 object = Z_REFVAL_P(object);
45231 goto assign_op_object;
45232 }
45233 if (IS_CV == IS_CV
45234 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
45235 ZVAL_UNDEFINED_OP1();
45236 }
45237 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
45238 break;
45239 }
45240
45241 assign_op_object:
45242 /* here we are sure we are dealing with an object */
45243 zobj = Z_OBJ_P(object);
45244 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45245 name = Z_STR_P(property);
45246 } else {
45247 name = zval_try_get_tmp_string(property, &tmp_name);
45248 if (UNEXPECTED(!name)) {
45249 UNDEF_RESULT();
45250 break;
45251 }
45252 }
45253 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
45254 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
45255 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
45256 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45257 ZVAL_NULL(EX_VAR(opline->result.var));
45258 }
45259 } else {
45260 zval *orig_zptr = zptr;
45261 zend_reference *ref;
45262
45263 do {
45264 if (UNEXPECTED(Z_ISREF_P(zptr))) {
45265 ref = Z_REF_P(zptr);
45266 zptr = Z_REFVAL_P(zptr);
45267 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
45268 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
45269 break;
45270 }
45271 }
45272
45273 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45274 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
45275 } else {
45276 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
45277 }
45278 if (prop_info) {
45279 /* special case for typed properties */
45280 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
45281 } else {
45282 zend_binary_op(zptr, zptr, value OPLINE_CC);
45283 }
45284 } while (0);
45285
45286 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45287 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
45288 }
45289 }
45290 } else {
45291 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
45292 }
45293 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
45294 zend_tmp_string_release(tmp_name);
45295 }
45296 } while (0);
45297
45298 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
45299 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45300
45301 /* assign_obj has two opcodes! */
45302 ZEND_VM_NEXT_OPCODE_EX(1, 2);
45303 }
45304
45305 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45306 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45307 {
45308 USE_OPLINE
45309 zval *var_ptr;
45310 zval *value, *container, *dim;
45311 HashTable *ht;
45312
45313 SAVE_OPLINE();
45314 container = EX_VAR(opline->op1.var);
45315
45316 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45317 assign_dim_op_array:
45318 SEPARATE_ARRAY(container);
45319 ht = Z_ARRVAL_P(container);
45320 assign_dim_op_new_array:
45321 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45322 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
45323 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
45324 if (UNEXPECTED(!var_ptr)) {
45325 zend_cannot_add_element();
45326 goto assign_dim_op_ret_null;
45327 }
45328 } else {
45329 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45330 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
45331 } else {
45332 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
45333 }
45334 if (UNEXPECTED(!var_ptr)) {
45335 goto assign_dim_op_ret_null;
45336 }
45337 }
45338
45339 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
45340
45341 do {
45342 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
45343 zend_reference *ref = Z_REF_P(var_ptr);
45344 var_ptr = Z_REFVAL_P(var_ptr);
45345 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
45346 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
45347 break;
45348 }
45349 }
45350 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
45351 } while (0);
45352
45353 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45354 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
45355 }
45356 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
45357 } else {
45358 if (EXPECTED(Z_ISREF_P(container))) {
45359 container = Z_REFVAL_P(container);
45360 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45361 goto assign_dim_op_array;
45362 }
45363 }
45364
45365 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
45366 zend_object *obj = Z_OBJ_P(container);
45367
45368 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45369 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
45370 dim++;
45371 }
45372 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
45373 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
45374 uint8_t old_type;
45375
45376 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
45377 ZVAL_UNDEFINED_OP1();
45378 }
45379 ht = zend_new_array(8);
45380 old_type = Z_TYPE_P(container);
45381 ZVAL_ARR(container, ht);
45382 if (UNEXPECTED(old_type == IS_FALSE)) {
45383 GC_ADDREF(ht);
45384 zend_false_to_array_deprecated();
45385 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
45386 zend_array_destroy(ht);
45387 goto assign_dim_op_ret_null;
45388 }
45389 }
45390 goto assign_dim_op_new_array;
45391 } else {
45392 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45393 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
45394 assign_dim_op_ret_null:
45395 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
45396 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45397 ZVAL_NULL(EX_VAR(opline->result.var));
45398 }
45399 }
45400 }
45401
45402 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45403
45404 ZEND_VM_NEXT_OPCODE_EX(1, 2);
45405 }
45406
ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45407 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45408 {
45409 USE_OPLINE
45410 zval *var_ptr;
45411 zval *value;
45412
45413 SAVE_OPLINE();
45414 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45415 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
45416
45417 do {
45418 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
45419 zend_reference *ref = Z_REF_P(var_ptr);
45420 var_ptr = Z_REFVAL_P(var_ptr);
45421 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
45422 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
45423 break;
45424 }
45425 }
45426 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
45427 } while (0);
45428
45429 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45430 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
45431 }
45432
45433 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45434
45435 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45436 }
45437
ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45438 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45439 {
45440 USE_OPLINE
45441 zval *object;
45442 zval *property;
45443 zval *zptr;
45444 void **cache_slot;
45445 zend_property_info *prop_info;
45446 zend_object *zobj;
45447 zend_string *name, *tmp_name;
45448
45449 SAVE_OPLINE();
45450 object = EX_VAR(opline->op1.var);
45451 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45452
45453 do {
45454 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
45455 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
45456 object = Z_REFVAL_P(object);
45457 goto pre_incdec_object;
45458 }
45459 if (IS_CV == IS_CV
45460 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
45461 ZVAL_UNDEFINED_OP1();
45462 }
45463 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
45464 break;
45465 }
45466
45467 pre_incdec_object:
45468 /* here we are sure we are dealing with an object */
45469 zobj = Z_OBJ_P(object);
45470 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45471 name = Z_STR_P(property);
45472 } else {
45473 name = zval_try_get_tmp_string(property, &tmp_name);
45474 if (UNEXPECTED(!name)) {
45475 UNDEF_RESULT();
45476 break;
45477 }
45478 }
45479 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
45480 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
45481 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
45482 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
45483 ZVAL_NULL(EX_VAR(opline->result.var));
45484 }
45485 } else {
45486 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45487 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
45488 } else {
45489 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
45490 }
45491 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
45492 }
45493 } else {
45494 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
45495 }
45496 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
45497 zend_tmp_string_release(tmp_name);
45498 }
45499 } while (0);
45500
45501 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45502
45503 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45504 }
45505
ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45506 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45507 {
45508 USE_OPLINE
45509 zval *object;
45510 zval *property;
45511 zval *zptr;
45512 void **cache_slot;
45513 zend_property_info *prop_info;
45514 zend_object *zobj;
45515 zend_string *name, *tmp_name;
45516
45517 SAVE_OPLINE();
45518 object = EX_VAR(opline->op1.var);
45519 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45520
45521 do {
45522 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
45523 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
45524 object = Z_REFVAL_P(object);
45525 goto post_incdec_object;
45526 }
45527 if (IS_CV == IS_CV
45528 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
45529 ZVAL_UNDEFINED_OP1();
45530 }
45531 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
45532 break;
45533 }
45534
45535 post_incdec_object:
45536 /* here we are sure we are dealing with an object */
45537 zobj = Z_OBJ_P(object);
45538 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45539 name = Z_STR_P(property);
45540 } else {
45541 name = zval_try_get_tmp_string(property, &tmp_name);
45542 if (UNEXPECTED(!name)) {
45543 ZVAL_UNDEF(EX_VAR(opline->result.var));
45544 break;
45545 }
45546 }
45547 cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
45548 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
45549 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
45550 ZVAL_NULL(EX_VAR(opline->result.var));
45551 } else {
45552 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45553 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
45554 } else {
45555 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
45556 }
45557
45558 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
45559 }
45560 } else {
45561 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
45562 }
45563 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
45564 zend_tmp_string_release(tmp_name);
45565 }
45566 } while (0);
45567
45568 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45569
45570 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45571 }
45572
ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45573 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45574 {
45575 USE_OPLINE
45576 zval *container, *dim, *value;
45577
45578 SAVE_OPLINE();
45579 container = EX_VAR(opline->op1.var);
45580 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45581 if (IS_CV != IS_CONST) {
45582 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45583 fetch_dim_r_array:
45584 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC);
45585 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
45586 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
45587 container = Z_REFVAL_P(container);
45588 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
45589 goto fetch_dim_r_array;
45590 } else {
45591 goto fetch_dim_r_slow;
45592 }
45593 } else {
45594 fetch_dim_r_slow:
45595 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
45596 dim++;
45597 }
45598 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
45599 }
45600 } else {
45601 zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC);
45602 }
45603 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45604
45605 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45606 }
45607
ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45608 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45609 {
45610 USE_OPLINE
45611 zval *container;
45612
45613 SAVE_OPLINE();
45614 container = EX_VAR(opline->op1.var);
45615 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);
45616 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45617 if (IS_CV == IS_VAR) {
45618 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
45619 }
45620 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45621 }
45622
ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45623 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45624 {
45625 USE_OPLINE
45626 zval *container;
45627
45628 SAVE_OPLINE();
45629 container = EX_VAR(opline->op1.var);
45630 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);
45631 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45632 if (IS_CV == IS_VAR) {
45633 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
45634 }
45635 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45636 }
45637
ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45638 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45639 {
45640 USE_OPLINE
45641 zval *container;
45642
45643 SAVE_OPLINE();
45644 container = EX_VAR(opline->op1.var);
45645 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);
45646 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45647
45648 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45649 }
45650
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45651 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45652 {
45653 #if 0
45654 USE_OPLINE
45655 #endif
45656
45657 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
45658 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
45659 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45660 }
45661 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45662 } else {
45663 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
45664 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45665 }
45666 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45667 }
45668 }
45669
ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45670 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45671 {
45672 USE_OPLINE
45673 zval *container;
45674
45675 SAVE_OPLINE();
45676 container = EX_VAR(opline->op1.var);
45677 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);
45678 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45679 if (IS_CV == IS_VAR) {
45680 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
45681 }
45682 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45683 }
45684
ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45685 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45686 {
45687 USE_OPLINE
45688 zval *container;
45689 void **cache_slot = NULL;
45690
45691 SAVE_OPLINE();
45692 container = EX_VAR(opline->op1.var);
45693
45694 if (IS_CV == IS_CONST ||
45695 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
45696 do {
45697 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
45698 container = Z_REFVAL_P(container);
45699 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
45700 break;
45701 }
45702 }
45703 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
45704 ZVAL_UNDEFINED_OP1();
45705 }
45706 zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
45707 ZVAL_NULL(EX_VAR(opline->result.var));
45708 goto fetch_obj_r_finish;
45709 } while (0);
45710 }
45711
45712 /* here we are sure we are dealing with an object */
45713 do {
45714 zend_object *zobj = Z_OBJ_P(container);
45715 zend_string *name, *tmp_name;
45716 zval *retval;
45717
45718 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45719 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
45720
45721 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
45722 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
45723
45724 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
45725 retval = OBJ_PROP(zobj, prop_offset);
45726 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
45727 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45728 goto fetch_obj_r_copy;
45729 } else {
45730 fetch_obj_r_fast_copy:
45731 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
45732 ZEND_VM_NEXT_OPCODE();
45733 }
45734 }
45735 } else if (EXPECTED(zobj->properties != NULL)) {
45736 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
45737 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
45738 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
45739
45740 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
45741 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
45742
45743 if (EXPECTED(p->key == name) ||
45744 (EXPECTED(p->h == ZSTR_H(name)) &&
45745 EXPECTED(p->key != NULL) &&
45746 EXPECTED(zend_string_equal_content(p->key, name)))) {
45747 retval = &p->val;
45748 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45749 goto fetch_obj_r_copy;
45750 } else {
45751 goto fetch_obj_r_fast_copy;
45752 }
45753 }
45754 }
45755 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
45756 }
45757 retval = zend_hash_find_known_hash(zobj->properties, name);
45758 if (EXPECTED(retval)) {
45759 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
45760 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
45761 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45762 goto fetch_obj_r_copy;
45763 } else {
45764 goto fetch_obj_r_fast_copy;
45765 }
45766 }
45767 }
45768 }
45769 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
45770 } else {
45771 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
45772 if (UNEXPECTED(!name)) {
45773 ZVAL_UNDEF(EX_VAR(opline->result.var));
45774 break;
45775 }
45776 }
45777
45778 #if ZEND_DEBUG
45779 /* For non-standard object handlers, verify a declared property type in debug builds.
45780 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
45781 zend_property_info *prop_info = NULL;
45782 if (zobj->handlers->read_property != zend_std_read_property) {
45783 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
45784 }
45785 #endif
45786 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
45787 #if ZEND_DEBUG
45788 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
45789 && ZEND_TYPE_IS_SET(prop_info->type)) {
45790 ZVAL_OPT_DEREF(retval);
45791 zend_verify_property_type(prop_info, retval, /* strict */ true);
45792 }
45793 #endif
45794
45795 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
45796 zend_tmp_string_release(tmp_name);
45797 }
45798
45799 if (retval != EX_VAR(opline->result.var)) {
45800 fetch_obj_r_copy:
45801 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
45802 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
45803 zend_unwrap_reference(retval);
45804 }
45805 } while (0);
45806
45807 fetch_obj_r_finish:
45808 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45809
45810 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45811 }
45812
ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45813 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45814 {
45815 USE_OPLINE
45816 zval *property, *container, *result;
45817
45818 SAVE_OPLINE();
45819
45820 container = EX_VAR(opline->op1.var);
45821 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45822 result = EX_VAR(opline->result.var);
45823 zend_fetch_property_address(
45824 result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR),
45825 (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
45826 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
45827 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45828 if (IS_CV == IS_VAR) {
45829 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
45830 }
45831 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45832 }
45833
ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45834 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45835 {
45836 USE_OPLINE
45837 zval *property, *container, *result;
45838
45839 SAVE_OPLINE();
45840 container = EX_VAR(opline->op1.var);
45841 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45842 result = EX_VAR(opline->result.var);
45843 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 OPLINE_CC EXECUTE_DATA_CC);
45844 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45845 if (IS_CV == IS_VAR) {
45846 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
45847 }
45848 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45849 }
45850
ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45851 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45852 {
45853 USE_OPLINE
45854 zval *container;
45855 void **cache_slot = NULL;
45856
45857 SAVE_OPLINE();
45858 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
45859
45860 if (IS_CV == IS_CONST ||
45861 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
45862 do {
45863 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
45864 container = Z_REFVAL_P(container);
45865 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
45866 break;
45867 }
45868 }
45869 if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
45870 ZVAL_UNDEFINED_OP2();
45871 }
45872 ZVAL_NULL(EX_VAR(opline->result.var));
45873 goto fetch_obj_is_finish;
45874 } while (0);
45875 }
45876
45877 /* here we are sure we are dealing with an object */
45878 do {
45879 zend_object *zobj = Z_OBJ_P(container);
45880 zend_string *name, *tmp_name;
45881 zval *retval;
45882
45883 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
45884 cache_slot = CACHE_ADDR(opline->extended_value);
45885
45886 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
45887 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
45888
45889 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
45890 retval = OBJ_PROP(zobj, prop_offset);
45891 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
45892 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45893 goto fetch_obj_is_copy;
45894 } else {
45895 fetch_obj_is_fast_copy:
45896 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
45897 ZEND_VM_NEXT_OPCODE();
45898 }
45899 }
45900 } else if (EXPECTED(zobj->properties != NULL)) {
45901 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
45902 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
45903 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
45904
45905 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
45906 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
45907
45908 if (EXPECTED(p->key == name) ||
45909 (EXPECTED(p->h == ZSTR_H(name)) &&
45910 EXPECTED(p->key != NULL) &&
45911 EXPECTED(zend_string_equal_content(p->key, name)))) {
45912 retval = &p->val;
45913 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45914 goto fetch_obj_is_copy;
45915 } else {
45916 goto fetch_obj_is_fast_copy;
45917 }
45918 }
45919 }
45920 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
45921 }
45922 retval = zend_hash_find_known_hash(zobj->properties, name);
45923 if (EXPECTED(retval)) {
45924 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
45925 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
45926 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
45927 goto fetch_obj_is_copy;
45928 } else {
45929 goto fetch_obj_is_fast_copy;
45930 }
45931 }
45932 }
45933 }
45934 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
45935 } else {
45936 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
45937 if (UNEXPECTED(!name)) {
45938 ZVAL_UNDEF(EX_VAR(opline->result.var));
45939 break;
45940 }
45941 }
45942
45943 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
45944
45945 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
45946 zend_tmp_string_release(tmp_name);
45947 }
45948
45949 if (retval != EX_VAR(opline->result.var)) {
45950 fetch_obj_is_copy:
45951 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
45952 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
45953 zend_unwrap_reference(retval);
45954 }
45955 } while (0);
45956
45957 fetch_obj_is_finish:
45958 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45959
45960 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45961 }
45962
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45963 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45964 {
45965 #if 0
45966 USE_OPLINE
45967 #endif
45968
45969 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
45970 /* Behave like FETCH_OBJ_W */
45971 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
45972 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45973 }
45974 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45975 } else {
45976 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
45977 }
45978 }
45979
ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45980 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45981 {
45982 USE_OPLINE
45983 zval *container, *property, *result;
45984
45985 SAVE_OPLINE();
45986 container = EX_VAR(opline->op1.var);
45987 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
45988 result = EX_VAR(opline->result.var);
45989 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 OPLINE_CC EXECUTE_DATA_CC);
45990 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
45991 if (IS_CV == IS_VAR) {
45992 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
45993 }
45994 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
45995 }
45996
ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)45997 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
45998 {
45999 USE_OPLINE
46000 zval *object, *value, tmp;
46001 zend_object *zobj;
46002 zend_string *name, *tmp_name;
46003 zend_refcounted *garbage = NULL;
46004
46005 SAVE_OPLINE();
46006 object = EX_VAR(opline->op1.var);
46007 value = RT_CONSTANT((opline+1), (opline+1)->op1);
46008
46009 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46010 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46011 object = Z_REFVAL_P(object);
46012 goto assign_object;
46013 }
46014 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
46015 value = &EG(uninitialized_zval);
46016 goto free_and_exit_assign_obj;
46017 }
46018
46019 assign_object:
46020 zobj = Z_OBJ_P(object);
46021 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46022 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
46023 void **cache_slot = CACHE_ADDR(opline->extended_value);
46024 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
46025 zval *property_val;
46026
46027 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
46028 property_val = OBJ_PROP(zobj, prop_offset);
46029 if (Z_TYPE_P(property_val) != IS_UNDEF) {
46030 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
46031
46032 if (prop_info != NULL) {
46033 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
46034 goto free_and_exit_assign_obj;
46035 } else {
46036 fast_assign_obj:
46037 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
46038 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46039 ZVAL_COPY(EX_VAR(opline->result.var), value);
46040 }
46041 goto exit_assign_obj;
46042 }
46043 }
46044 } else {
46045 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46046 if (EXPECTED(zobj->properties != NULL)) {
46047 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
46048 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
46049 GC_DELREF(zobj->properties);
46050 }
46051 zobj->properties = zend_array_dup(zobj->properties);
46052 }
46053 property_val = zend_hash_find_known_hash(zobj->properties, name);
46054 if (property_val) {
46055 goto fast_assign_obj;
46056 }
46057 }
46058
46059 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
46060 if (EXPECTED(zobj->properties == NULL)) {
46061 rebuild_object_properties(zobj);
46062 }
46063 if (IS_CONST == IS_CONST) {
46064 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
46065 Z_ADDREF_P(value);
46066 }
46067 } else if (IS_CONST != IS_TMP_VAR) {
46068 if (Z_ISREF_P(value)) {
46069 if (IS_CONST == IS_VAR) {
46070 zend_reference *ref = Z_REF_P(value);
46071 if (GC_DELREF(ref) == 0) {
46072 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
46073 efree_size(ref, sizeof(zend_reference));
46074 value = &tmp;
46075 } else {
46076 value = Z_REFVAL_P(value);
46077 Z_TRY_ADDREF_P(value);
46078 }
46079 } else {
46080 value = Z_REFVAL_P(value);
46081 Z_TRY_ADDREF_P(value);
46082 }
46083 } else if (IS_CONST == IS_CV) {
46084 Z_TRY_ADDREF_P(value);
46085 }
46086 }
46087 zend_hash_add_new(zobj->properties, name, value);
46088 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46089 ZVAL_COPY(EX_VAR(opline->result.var), value);
46090 }
46091 goto exit_assign_obj;
46092 }
46093 }
46094 }
46095 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46096 } else {
46097 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
46098 if (UNEXPECTED(!name)) {
46099
46100 UNDEF_RESULT();
46101 goto exit_assign_obj;
46102 }
46103 }
46104
46105 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
46106 ZVAL_DEREF(value);
46107 }
46108
46109 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
46110
46111 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46112 zend_tmp_string_release(tmp_name);
46113 }
46114
46115 free_and_exit_assign_obj:
46116 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
46117 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46118 }
46119
46120 exit_assign_obj:
46121 if (garbage) {
46122 GC_DTOR_NO_REF(garbage);
46123 }
46124 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46125
46126 /* assign_obj has two opcodes! */
46127 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46128 }
46129
46130 /* 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)46131 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46132 {
46133 USE_OPLINE
46134 zval *object, *value, tmp;
46135 zend_object *zobj;
46136 zend_string *name, *tmp_name;
46137 zend_refcounted *garbage = NULL;
46138
46139 SAVE_OPLINE();
46140 object = EX_VAR(opline->op1.var);
46141 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
46142
46143 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46144 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46145 object = Z_REFVAL_P(object);
46146 goto assign_object;
46147 }
46148 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
46149 value = &EG(uninitialized_zval);
46150 goto free_and_exit_assign_obj;
46151 }
46152
46153 assign_object:
46154 zobj = Z_OBJ_P(object);
46155 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46156 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
46157 void **cache_slot = CACHE_ADDR(opline->extended_value);
46158 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
46159 zval *property_val;
46160
46161 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
46162 property_val = OBJ_PROP(zobj, prop_offset);
46163 if (Z_TYPE_P(property_val) != IS_UNDEF) {
46164 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
46165
46166 if (prop_info != NULL) {
46167 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
46168 goto free_and_exit_assign_obj;
46169 } else {
46170 fast_assign_obj:
46171 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
46172 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46173 ZVAL_COPY(EX_VAR(opline->result.var), value);
46174 }
46175 goto exit_assign_obj;
46176 }
46177 }
46178 } else {
46179 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46180 if (EXPECTED(zobj->properties != NULL)) {
46181 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
46182 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
46183 GC_DELREF(zobj->properties);
46184 }
46185 zobj->properties = zend_array_dup(zobj->properties);
46186 }
46187 property_val = zend_hash_find_known_hash(zobj->properties, name);
46188 if (property_val) {
46189 goto fast_assign_obj;
46190 }
46191 }
46192
46193 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
46194 if (EXPECTED(zobj->properties == NULL)) {
46195 rebuild_object_properties(zobj);
46196 }
46197 if (IS_TMP_VAR == IS_CONST) {
46198 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
46199 Z_ADDREF_P(value);
46200 }
46201 } else if (IS_TMP_VAR != IS_TMP_VAR) {
46202 if (Z_ISREF_P(value)) {
46203 if (IS_TMP_VAR == IS_VAR) {
46204 zend_reference *ref = Z_REF_P(value);
46205 if (GC_DELREF(ref) == 0) {
46206 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
46207 efree_size(ref, sizeof(zend_reference));
46208 value = &tmp;
46209 } else {
46210 value = Z_REFVAL_P(value);
46211 Z_TRY_ADDREF_P(value);
46212 }
46213 } else {
46214 value = Z_REFVAL_P(value);
46215 Z_TRY_ADDREF_P(value);
46216 }
46217 } else if (IS_TMP_VAR == IS_CV) {
46218 Z_TRY_ADDREF_P(value);
46219 }
46220 }
46221 zend_hash_add_new(zobj->properties, name, value);
46222 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46223 ZVAL_COPY(EX_VAR(opline->result.var), value);
46224 }
46225 goto exit_assign_obj;
46226 }
46227 }
46228 }
46229 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46230 } else {
46231 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
46232 if (UNEXPECTED(!name)) {
46233 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46234 UNDEF_RESULT();
46235 goto exit_assign_obj;
46236 }
46237 }
46238
46239 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
46240 ZVAL_DEREF(value);
46241 }
46242
46243 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
46244
46245 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46246 zend_tmp_string_release(tmp_name);
46247 }
46248
46249 free_and_exit_assign_obj:
46250 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
46251 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46252 }
46253 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46254 exit_assign_obj:
46255 if (garbage) {
46256 GC_DTOR_NO_REF(garbage);
46257 }
46258 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46259
46260 /* assign_obj has two opcodes! */
46261 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46262 }
46263
46264 /* 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)46265 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46266 {
46267 USE_OPLINE
46268 zval *object, *value, tmp;
46269 zend_object *zobj;
46270 zend_string *name, *tmp_name;
46271 zend_refcounted *garbage = NULL;
46272
46273 SAVE_OPLINE();
46274 object = EX_VAR(opline->op1.var);
46275 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
46276
46277 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46278 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46279 object = Z_REFVAL_P(object);
46280 goto assign_object;
46281 }
46282 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
46283 value = &EG(uninitialized_zval);
46284 goto free_and_exit_assign_obj;
46285 }
46286
46287 assign_object:
46288 zobj = Z_OBJ_P(object);
46289 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46290 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
46291 void **cache_slot = CACHE_ADDR(opline->extended_value);
46292 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
46293 zval *property_val;
46294
46295 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
46296 property_val = OBJ_PROP(zobj, prop_offset);
46297 if (Z_TYPE_P(property_val) != IS_UNDEF) {
46298 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
46299
46300 if (prop_info != NULL) {
46301 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
46302 goto free_and_exit_assign_obj;
46303 } else {
46304 fast_assign_obj:
46305 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
46306 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46307 ZVAL_COPY(EX_VAR(opline->result.var), value);
46308 }
46309 goto exit_assign_obj;
46310 }
46311 }
46312 } else {
46313 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46314 if (EXPECTED(zobj->properties != NULL)) {
46315 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
46316 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
46317 GC_DELREF(zobj->properties);
46318 }
46319 zobj->properties = zend_array_dup(zobj->properties);
46320 }
46321 property_val = zend_hash_find_known_hash(zobj->properties, name);
46322 if (property_val) {
46323 goto fast_assign_obj;
46324 }
46325 }
46326
46327 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
46328 if (EXPECTED(zobj->properties == NULL)) {
46329 rebuild_object_properties(zobj);
46330 }
46331 if (IS_VAR == IS_CONST) {
46332 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
46333 Z_ADDREF_P(value);
46334 }
46335 } else if (IS_VAR != IS_TMP_VAR) {
46336 if (Z_ISREF_P(value)) {
46337 if (IS_VAR == IS_VAR) {
46338 zend_reference *ref = Z_REF_P(value);
46339 if (GC_DELREF(ref) == 0) {
46340 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
46341 efree_size(ref, sizeof(zend_reference));
46342 value = &tmp;
46343 } else {
46344 value = Z_REFVAL_P(value);
46345 Z_TRY_ADDREF_P(value);
46346 }
46347 } else {
46348 value = Z_REFVAL_P(value);
46349 Z_TRY_ADDREF_P(value);
46350 }
46351 } else if (IS_VAR == IS_CV) {
46352 Z_TRY_ADDREF_P(value);
46353 }
46354 }
46355 zend_hash_add_new(zobj->properties, name, value);
46356 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46357 ZVAL_COPY(EX_VAR(opline->result.var), value);
46358 }
46359 goto exit_assign_obj;
46360 }
46361 }
46362 }
46363 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46364 } else {
46365 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
46366 if (UNEXPECTED(!name)) {
46367 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46368 UNDEF_RESULT();
46369 goto exit_assign_obj;
46370 }
46371 }
46372
46373 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
46374 ZVAL_DEREF(value);
46375 }
46376
46377 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
46378
46379 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46380 zend_tmp_string_release(tmp_name);
46381 }
46382
46383 free_and_exit_assign_obj:
46384 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
46385 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46386 }
46387 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46388 exit_assign_obj:
46389 if (garbage) {
46390 GC_DTOR_NO_REF(garbage);
46391 }
46392 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46393
46394 /* assign_obj has two opcodes! */
46395 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46396 }
46397
46398 /* 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)46399 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46400 {
46401 USE_OPLINE
46402 zval *object, *value, tmp;
46403 zend_object *zobj;
46404 zend_string *name, *tmp_name;
46405 zend_refcounted *garbage = NULL;
46406
46407 SAVE_OPLINE();
46408 object = EX_VAR(opline->op1.var);
46409 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
46410
46411 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
46412 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
46413 object = Z_REFVAL_P(object);
46414 goto assign_object;
46415 }
46416 zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
46417 value = &EG(uninitialized_zval);
46418 goto free_and_exit_assign_obj;
46419 }
46420
46421 assign_object:
46422 zobj = Z_OBJ_P(object);
46423 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46424 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
46425 void **cache_slot = CACHE_ADDR(opline->extended_value);
46426 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
46427 zval *property_val;
46428
46429 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
46430 property_val = OBJ_PROP(zobj, prop_offset);
46431 if (Z_TYPE_P(property_val) != IS_UNDEF) {
46432 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
46433
46434 if (prop_info != NULL) {
46435 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
46436 goto free_and_exit_assign_obj;
46437 } else {
46438 fast_assign_obj:
46439 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
46440 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46441 ZVAL_COPY(EX_VAR(opline->result.var), value);
46442 }
46443 goto exit_assign_obj;
46444 }
46445 }
46446 } else {
46447 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46448 if (EXPECTED(zobj->properties != NULL)) {
46449 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
46450 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
46451 GC_DELREF(zobj->properties);
46452 }
46453 zobj->properties = zend_array_dup(zobj->properties);
46454 }
46455 property_val = zend_hash_find_known_hash(zobj->properties, name);
46456 if (property_val) {
46457 goto fast_assign_obj;
46458 }
46459 }
46460
46461 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
46462 if (EXPECTED(zobj->properties == NULL)) {
46463 rebuild_object_properties(zobj);
46464 }
46465 if (IS_CV == IS_CONST) {
46466 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
46467 Z_ADDREF_P(value);
46468 }
46469 } else if (IS_CV != IS_TMP_VAR) {
46470 if (Z_ISREF_P(value)) {
46471 if (IS_CV == IS_VAR) {
46472 zend_reference *ref = Z_REF_P(value);
46473 if (GC_DELREF(ref) == 0) {
46474 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
46475 efree_size(ref, sizeof(zend_reference));
46476 value = &tmp;
46477 } else {
46478 value = Z_REFVAL_P(value);
46479 Z_TRY_ADDREF_P(value);
46480 }
46481 } else {
46482 value = Z_REFVAL_P(value);
46483 Z_TRY_ADDREF_P(value);
46484 }
46485 } else if (IS_CV == IS_CV) {
46486 Z_TRY_ADDREF_P(value);
46487 }
46488 }
46489 zend_hash_add_new(zobj->properties, name, value);
46490 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46491 ZVAL_COPY(EX_VAR(opline->result.var), value);
46492 }
46493 goto exit_assign_obj;
46494 }
46495 }
46496 }
46497 name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC));
46498 } else {
46499 name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
46500 if (UNEXPECTED(!name)) {
46501
46502 UNDEF_RESULT();
46503 goto exit_assign_obj;
46504 }
46505 }
46506
46507 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
46508 ZVAL_DEREF(value);
46509 }
46510
46511 value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
46512
46513 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
46514 zend_tmp_string_release(tmp_name);
46515 }
46516
46517 free_and_exit_assign_obj:
46518 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
46519 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
46520 }
46521
46522 exit_assign_obj:
46523 if (garbage) {
46524 GC_DTOR_NO_REF(garbage);
46525 }
46526 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46527
46528 /* assign_obj has two opcodes! */
46529 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46530 }
46531
46532 /* 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)46533 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46534 {
46535 USE_OPLINE
46536 zval *object_ptr, *orig_object_ptr;
46537 zval *value;
46538 zval *variable_ptr;
46539 zval *dim;
46540 zend_refcounted *garbage = NULL;
46541
46542 SAVE_OPLINE();
46543 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
46544
46545 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46546 try_assign_dim_array:
46547 SEPARATE_ARRAY(object_ptr);
46548 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46549 value = RT_CONSTANT((opline+1), (opline+1)->op1);
46550 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
46551 HashTable *ht = Z_ARRVAL_P(object_ptr);
46552 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
46553 GC_ADDREF(ht);
46554 }
46555 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46556 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
46557 zend_array_destroy(ht);
46558 goto assign_dim_error;
46559 }
46560 }
46561 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
46562 ZVAL_DEREF(value);
46563 }
46564 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
46565 if (UNEXPECTED(value == NULL)) {
46566 zend_cannot_add_element();
46567 goto assign_dim_error;
46568 } else if (IS_CONST == IS_CV) {
46569 if (Z_REFCOUNTED_P(value)) {
46570 Z_ADDREF_P(value);
46571 }
46572 } else if (IS_CONST == IS_VAR) {
46573 zval *free_op_data = EX_VAR((opline+1)->op1.var);
46574 if (Z_ISREF_P(free_op_data)) {
46575 if (Z_REFCOUNTED_P(value)) {
46576 Z_ADDREF_P(value);
46577 }
46578 zval_ptr_dtor_nogc(free_op_data);
46579 }
46580 } else if (IS_CONST == IS_CONST) {
46581 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
46582 Z_ADDREF_P(value);
46583 }
46584 }
46585 } else {
46586 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46587 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46588 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46589 } else {
46590 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46591 }
46592 if (UNEXPECTED(variable_ptr == NULL)) {
46593 goto assign_dim_error;
46594 }
46595 value = RT_CONSTANT((opline+1), (opline+1)->op1);
46596 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
46597 }
46598 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46599 ZVAL_COPY(EX_VAR(opline->result.var), value);
46600 }
46601 if (garbage) {
46602 GC_DTOR_NO_REF(garbage);
46603 }
46604 } else {
46605 if (EXPECTED(Z_ISREF_P(object_ptr))) {
46606 object_ptr = Z_REFVAL_P(object_ptr);
46607 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46608 goto try_assign_dim_array;
46609 }
46610 }
46611 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
46612 zend_object *obj = Z_OBJ_P(object_ptr);
46613
46614 GC_ADDREF(obj);
46615 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46616 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
46617 dim = ZVAL_UNDEFINED_OP2();
46618 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46619 dim++;
46620 }
46621
46622 value = RT_CONSTANT((opline+1), (opline+1)->op1);
46623 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
46624 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46625 } else if (IS_CONST & (IS_CV|IS_VAR)) {
46626 ZVAL_DEREF(value);
46627 }
46628
46629 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
46630
46631 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
46632 zend_objects_store_del(obj);
46633 }
46634 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
46635 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46636 zend_use_new_element_for_string();
46637
46638 UNDEF_RESULT();
46639 } else {
46640 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46641 value = RT_CONSTANT((opline+1), (opline+1)->op1);
46642 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
46643
46644 }
46645 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
46646 if (Z_ISREF_P(orig_object_ptr)
46647 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
46648 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
46649 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46650
46651 UNDEF_RESULT();
46652 } else {
46653 HashTable *ht = zend_new_array(8);
46654 uint8_t old_type = Z_TYPE_P(object_ptr);
46655
46656 ZVAL_ARR(object_ptr, ht);
46657 if (UNEXPECTED(old_type == IS_FALSE)) {
46658 GC_ADDREF(ht);
46659 zend_false_to_array_deprecated();
46660 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
46661 zend_array_destroy(ht);
46662 goto assign_dim_error;
46663 }
46664 }
46665 goto try_assign_dim_array;
46666 }
46667 } else {
46668 zend_use_scalar_as_array();
46669 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46670 assign_dim_error:
46671
46672 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46673 ZVAL_NULL(EX_VAR(opline->result.var));
46674 }
46675 }
46676 }
46677 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
46678 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46679 }
46680
46681 /* assign_dim has two opcodes! */
46682 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46683 }
46684
ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46685 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46686 {
46687 USE_OPLINE
46688 zval *object_ptr, *orig_object_ptr;
46689 zval *value;
46690 zval *variable_ptr;
46691 zval *dim;
46692 zend_refcounted *garbage = NULL;
46693
46694 SAVE_OPLINE();
46695 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
46696
46697 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46698 try_assign_dim_array:
46699 SEPARATE_ARRAY(object_ptr);
46700 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46701 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
46702 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
46703 HashTable *ht = Z_ARRVAL_P(object_ptr);
46704 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
46705 GC_ADDREF(ht);
46706 }
46707 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46708 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
46709 zend_array_destroy(ht);
46710 goto assign_dim_error;
46711 }
46712 }
46713 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
46714 ZVAL_DEREF(value);
46715 }
46716 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
46717 if (UNEXPECTED(value == NULL)) {
46718 zend_cannot_add_element();
46719 goto assign_dim_error;
46720 } else if (IS_TMP_VAR == IS_CV) {
46721 if (Z_REFCOUNTED_P(value)) {
46722 Z_ADDREF_P(value);
46723 }
46724 } else if (IS_TMP_VAR == IS_VAR) {
46725 zval *free_op_data = EX_VAR((opline+1)->op1.var);
46726 if (Z_ISREF_P(free_op_data)) {
46727 if (Z_REFCOUNTED_P(value)) {
46728 Z_ADDREF_P(value);
46729 }
46730 zval_ptr_dtor_nogc(free_op_data);
46731 }
46732 } else if (IS_TMP_VAR == IS_CONST) {
46733 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
46734 Z_ADDREF_P(value);
46735 }
46736 }
46737 } else {
46738 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46739 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46740 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46741 } else {
46742 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46743 }
46744 if (UNEXPECTED(variable_ptr == NULL)) {
46745 goto assign_dim_error;
46746 }
46747 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
46748 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
46749 }
46750 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46751 ZVAL_COPY(EX_VAR(opline->result.var), value);
46752 }
46753 if (garbage) {
46754 GC_DTOR_NO_REF(garbage);
46755 }
46756 } else {
46757 if (EXPECTED(Z_ISREF_P(object_ptr))) {
46758 object_ptr = Z_REFVAL_P(object_ptr);
46759 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46760 goto try_assign_dim_array;
46761 }
46762 }
46763 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
46764 zend_object *obj = Z_OBJ_P(object_ptr);
46765
46766 GC_ADDREF(obj);
46767 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46768 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
46769 dim = ZVAL_UNDEFINED_OP2();
46770 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46771 dim++;
46772 }
46773
46774 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
46775 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
46776 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46777 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
46778 ZVAL_DEREF(value);
46779 }
46780
46781 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
46782
46783 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46784 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
46785 zend_objects_store_del(obj);
46786 }
46787 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
46788 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46789 zend_use_new_element_for_string();
46790 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46791 UNDEF_RESULT();
46792 } else {
46793 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46794 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
46795 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
46796 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46797 }
46798 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
46799 if (Z_ISREF_P(orig_object_ptr)
46800 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
46801 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
46802 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46803 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46804 UNDEF_RESULT();
46805 } else {
46806 HashTable *ht = zend_new_array(8);
46807 uint8_t old_type = Z_TYPE_P(object_ptr);
46808
46809 ZVAL_ARR(object_ptr, ht);
46810 if (UNEXPECTED(old_type == IS_FALSE)) {
46811 GC_ADDREF(ht);
46812 zend_false_to_array_deprecated();
46813 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
46814 zend_array_destroy(ht);
46815 goto assign_dim_error;
46816 }
46817 }
46818 goto try_assign_dim_array;
46819 }
46820 } else {
46821 zend_use_scalar_as_array();
46822 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46823 assign_dim_error:
46824 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46825 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46826 ZVAL_NULL(EX_VAR(opline->result.var));
46827 }
46828 }
46829 }
46830 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
46831 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46832 }
46833
46834 /* assign_dim has two opcodes! */
46835 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46836 }
46837
ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46838 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46839 {
46840 USE_OPLINE
46841 zval *object_ptr, *orig_object_ptr;
46842 zval *value;
46843 zval *variable_ptr;
46844 zval *dim;
46845 zend_refcounted *garbage = NULL;
46846
46847 SAVE_OPLINE();
46848 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
46849
46850 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46851 try_assign_dim_array:
46852 SEPARATE_ARRAY(object_ptr);
46853 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46854 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
46855 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
46856 HashTable *ht = Z_ARRVAL_P(object_ptr);
46857 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
46858 GC_ADDREF(ht);
46859 }
46860 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46861 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
46862 zend_array_destroy(ht);
46863 goto assign_dim_error;
46864 }
46865 }
46866 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
46867 ZVAL_DEREF(value);
46868 }
46869 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
46870 if (UNEXPECTED(value == NULL)) {
46871 zend_cannot_add_element();
46872 goto assign_dim_error;
46873 } else if (IS_VAR == IS_CV) {
46874 if (Z_REFCOUNTED_P(value)) {
46875 Z_ADDREF_P(value);
46876 }
46877 } else if (IS_VAR == IS_VAR) {
46878 zval *free_op_data = EX_VAR((opline+1)->op1.var);
46879 if (Z_ISREF_P(free_op_data)) {
46880 if (Z_REFCOUNTED_P(value)) {
46881 Z_ADDREF_P(value);
46882 }
46883 zval_ptr_dtor_nogc(free_op_data);
46884 }
46885 } else if (IS_VAR == IS_CONST) {
46886 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
46887 Z_ADDREF_P(value);
46888 }
46889 }
46890 } else {
46891 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46892 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
46893 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46894 } else {
46895 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
46896 }
46897 if (UNEXPECTED(variable_ptr == NULL)) {
46898 goto assign_dim_error;
46899 }
46900 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
46901 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
46902 }
46903 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46904 ZVAL_COPY(EX_VAR(opline->result.var), value);
46905 }
46906 if (garbage) {
46907 GC_DTOR_NO_REF(garbage);
46908 }
46909 } else {
46910 if (EXPECTED(Z_ISREF_P(object_ptr))) {
46911 object_ptr = Z_REFVAL_P(object_ptr);
46912 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
46913 goto try_assign_dim_array;
46914 }
46915 }
46916 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
46917 zend_object *obj = Z_OBJ_P(object_ptr);
46918
46919 GC_ADDREF(obj);
46920 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46921 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
46922 dim = ZVAL_UNDEFINED_OP2();
46923 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
46924 dim++;
46925 }
46926
46927 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
46928 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
46929 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
46930 } else if (IS_VAR & (IS_CV|IS_VAR)) {
46931 ZVAL_DEREF(value);
46932 }
46933
46934 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
46935
46936 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46937 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
46938 zend_objects_store_del(obj);
46939 }
46940 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
46941 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
46942 zend_use_new_element_for_string();
46943 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46944 UNDEF_RESULT();
46945 } else {
46946 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46947 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
46948 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
46949 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46950 }
46951 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
46952 if (Z_ISREF_P(orig_object_ptr)
46953 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
46954 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
46955 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46956 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46957 UNDEF_RESULT();
46958 } else {
46959 HashTable *ht = zend_new_array(8);
46960 uint8_t old_type = Z_TYPE_P(object_ptr);
46961
46962 ZVAL_ARR(object_ptr, ht);
46963 if (UNEXPECTED(old_type == IS_FALSE)) {
46964 GC_ADDREF(ht);
46965 zend_false_to_array_deprecated();
46966 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
46967 zend_array_destroy(ht);
46968 goto assign_dim_error;
46969 }
46970 }
46971 goto try_assign_dim_array;
46972 }
46973 } else {
46974 zend_use_scalar_as_array();
46975 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
46976 assign_dim_error:
46977 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
46978 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
46979 ZVAL_NULL(EX_VAR(opline->result.var));
46980 }
46981 }
46982 }
46983 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
46984 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
46985 }
46986
46987 /* assign_dim has two opcodes! */
46988 ZEND_VM_NEXT_OPCODE_EX(1, 2);
46989 }
46990
ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)46991 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
46992 {
46993 USE_OPLINE
46994 zval *object_ptr, *orig_object_ptr;
46995 zval *value;
46996 zval *variable_ptr;
46997 zval *dim;
46998 zend_refcounted *garbage = NULL;
46999
47000 SAVE_OPLINE();
47001 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
47002
47003 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
47004 try_assign_dim_array:
47005 SEPARATE_ARRAY(object_ptr);
47006 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
47007 value = EX_VAR((opline+1)->op1.var);
47008 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
47009 HashTable *ht = Z_ARRVAL_P(object_ptr);
47010 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
47011 GC_ADDREF(ht);
47012 }
47013 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
47014 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
47015 zend_array_destroy(ht);
47016 goto assign_dim_error;
47017 }
47018 }
47019 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
47020 ZVAL_DEREF(value);
47021 }
47022 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
47023 if (UNEXPECTED(value == NULL)) {
47024 zend_cannot_add_element();
47025 goto assign_dim_error;
47026 } else if (IS_CV == IS_CV) {
47027 if (Z_REFCOUNTED_P(value)) {
47028 Z_ADDREF_P(value);
47029 }
47030 } else if (IS_CV == IS_VAR) {
47031 zval *free_op_data = EX_VAR((opline+1)->op1.var);
47032 if (Z_ISREF_P(free_op_data)) {
47033 if (Z_REFCOUNTED_P(value)) {
47034 Z_ADDREF_P(value);
47035 }
47036 zval_ptr_dtor_nogc(free_op_data);
47037 }
47038 } else if (IS_CV == IS_CONST) {
47039 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
47040 Z_ADDREF_P(value);
47041 }
47042 }
47043 } else {
47044 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47045 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47046 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
47047 } else {
47048 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
47049 }
47050 if (UNEXPECTED(variable_ptr == NULL)) {
47051 goto assign_dim_error;
47052 }
47053 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
47054 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
47055 }
47056 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47057 ZVAL_COPY(EX_VAR(opline->result.var), value);
47058 }
47059 if (garbage) {
47060 GC_DTOR_NO_REF(garbage);
47061 }
47062 } else {
47063 if (EXPECTED(Z_ISREF_P(object_ptr))) {
47064 object_ptr = Z_REFVAL_P(object_ptr);
47065 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
47066 goto try_assign_dim_array;
47067 }
47068 }
47069 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
47070 zend_object *obj = Z_OBJ_P(object_ptr);
47071
47072 GC_ADDREF(obj);
47073 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47074 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
47075 dim = ZVAL_UNDEFINED_OP2();
47076 } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
47077 dim++;
47078 }
47079
47080 value = EX_VAR((opline+1)->op1.var);
47081 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
47082 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
47083 } else if (IS_CV & (IS_CV|IS_VAR)) {
47084 ZVAL_DEREF(value);
47085 }
47086
47087 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
47088
47089 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
47090 zend_objects_store_del(obj);
47091 }
47092 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
47093 if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
47094 zend_use_new_element_for_string();
47095
47096 UNDEF_RESULT();
47097 } else {
47098 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47099 value = EX_VAR((opline+1)->op1.var);
47100 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
47101
47102 }
47103 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
47104 if (Z_ISREF_P(orig_object_ptr)
47105 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
47106 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
47107 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47108
47109 UNDEF_RESULT();
47110 } else {
47111 HashTable *ht = zend_new_array(8);
47112 uint8_t old_type = Z_TYPE_P(object_ptr);
47113
47114 ZVAL_ARR(object_ptr, ht);
47115 if (UNEXPECTED(old_type == IS_FALSE)) {
47116 GC_ADDREF(ht);
47117 zend_false_to_array_deprecated();
47118 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
47119 zend_array_destroy(ht);
47120 goto assign_dim_error;
47121 }
47122 }
47123 goto try_assign_dim_array;
47124 }
47125 } else {
47126 zend_use_scalar_as_array();
47127 dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47128 assign_dim_error:
47129
47130 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
47131 ZVAL_NULL(EX_VAR(opline->result.var));
47132 }
47133 }
47134 }
47135 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
47136 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47137 }
47138
47139 /* assign_dim has two opcodes! */
47140 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47141 }
47142
ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47143 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47144 {
47145 USE_OPLINE
47146 zval *property, *container, *value_ptr;
47147
47148 SAVE_OPLINE();
47149
47150 container = EX_VAR(opline->op1.var);
47151 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47152
47153 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
47154
47155 if (1) {
47156 if (IS_CV == IS_UNUSED) {
47157 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47158 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47159 } else {
47160 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47161 }
47162 } else {
47163 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47164 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47165 } else {
47166 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47167 }
47168 }
47169 } else {
47170 zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
47171 }
47172
47173 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47174 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
47175 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47176 }
47177
47178 /* 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)47179 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47180 {
47181 USE_OPLINE
47182 zval *property, *container, *value_ptr;
47183
47184 SAVE_OPLINE();
47185
47186 container = EX_VAR(opline->op1.var);
47187 property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47188
47189 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
47190
47191 if (1) {
47192 if (IS_CV == IS_UNUSED) {
47193 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47194 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47195 } else {
47196 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47197 }
47198 } else {
47199 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47200 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47201 } else {
47202 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
47203 }
47204 }
47205 } else {
47206 zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC);
47207 }
47208
47209 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47210
47211 ZEND_VM_NEXT_OPCODE_EX(1, 2);
47212 }
47213
47214 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47215 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47216 {
47217 USE_OPLINE
47218 zval *op1, *op2;
47219 zend_string *op1_str, *op2_str, *str;
47220
47221
47222 op1 = EX_VAR(opline->op1.var);
47223 op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47224 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
47225 ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
47226 zend_string *op1_str = Z_STR_P(op1);
47227 zend_string *op2_str = Z_STR_P(op2);
47228 zend_string *str;
47229 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
47230
47231 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
47232 if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) {
47233 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
47234 } else {
47235 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
47236 }
47237 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
47238 zend_string_release_ex(op1_str, 0);
47239 }
47240 } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
47241 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
47242 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
47243 } else {
47244 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
47245 }
47246 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
47247 zend_string_release_ex(op2_str, 0);
47248 }
47249 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
47250 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
47251 size_t len = ZSTR_LEN(op1_str);
47252
47253 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
47254 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
47255 GC_ADD_FLAGS(str, flags);
47256 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
47257 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
47258 zend_string_release_ex(op2_str, 0);
47259 }
47260 } else {
47261 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
47262 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
47263 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
47264 GC_ADD_FLAGS(str, flags);
47265 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
47266 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
47267 zend_string_release_ex(op1_str, 0);
47268 }
47269 if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) {
47270 zend_string_release_ex(op2_str, 0);
47271 }
47272 }
47273 ZEND_VM_NEXT_OPCODE();
47274 }
47275
47276 SAVE_OPLINE();
47277 if (IS_CV == IS_CONST) {
47278 op1_str = Z_STR_P(op1);
47279 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
47280 op1_str = zend_string_copy(Z_STR_P(op1));
47281 } else {
47282 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
47283 ZVAL_UNDEFINED_OP1();
47284 }
47285 op1_str = zval_get_string_func(op1);
47286 }
47287 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47288 op2_str = Z_STR_P(op2);
47289 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
47290 op2_str = zend_string_copy(Z_STR_P(op2));
47291 } else {
47292 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
47293 ZVAL_UNDEFINED_OP2();
47294 }
47295 op2_str = zval_get_string_func(op2);
47296 }
47297 do {
47298 if (IS_CV != IS_CONST) {
47299 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
47300 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47301 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
47302 GC_ADDREF(op2_str);
47303 }
47304 }
47305 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
47306 zend_string_release_ex(op1_str, 0);
47307 break;
47308 }
47309 }
47310 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47311 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
47312 if (IS_CV == IS_CONST) {
47313 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
47314 GC_ADDREF(op1_str);
47315 }
47316 }
47317 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
47318 zend_string_release_ex(op2_str, 0);
47319 break;
47320 }
47321 }
47322 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
47323 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
47324 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
47325
47326 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
47327 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
47328 if (IS_CV != IS_CONST) {
47329 zend_string_release_ex(op1_str, 0);
47330 }
47331 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47332 zend_string_release_ex(op2_str, 0);
47333 }
47334 } while (0);
47335
47336 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47337 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47338 }
47339
ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47340 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47341 {
47342 USE_OPLINE
47343 zval *function_name;
47344 zval *object;
47345 zend_function *fbc;
47346 zend_class_entry *called_scope;
47347 zend_object *obj;
47348 zend_execute_data *call;
47349 uint32_t call_info;
47350
47351 SAVE_OPLINE();
47352
47353 object = EX_VAR(opline->op1.var);
47354
47355 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47356 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47357 }
47358
47359 if ((IS_TMP_VAR|IS_VAR) != IS_CONST &&
47360 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
47361 do {
47362 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
47363 function_name = Z_REFVAL_P(function_name);
47364 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
47365 break;
47366 }
47367 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
47368 ZVAL_UNDEFINED_OP2();
47369 if (UNEXPECTED(EG(exception) != NULL)) {
47370
47371 HANDLE_EXCEPTION();
47372 }
47373 }
47374 zend_throw_error(NULL, "Method name must be a string");
47375 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47376
47377 HANDLE_EXCEPTION();
47378 } while (0);
47379 }
47380
47381 if (IS_CV == IS_UNUSED) {
47382 obj = Z_OBJ_P(object);
47383 } else {
47384 do {
47385 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
47386 obj = Z_OBJ_P(object);
47387 } else {
47388 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
47389 zend_reference *ref = Z_REF_P(object);
47390
47391 object = &ref->val;
47392 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
47393 obj = Z_OBJ_P(object);
47394 if (IS_CV & IS_VAR) {
47395 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
47396 efree_size(ref, sizeof(zend_reference));
47397 } else {
47398 Z_ADDREF_P(object);
47399 }
47400 }
47401 break;
47402 }
47403 }
47404 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
47405 object = ZVAL_UNDEFINED_OP1();
47406 if (UNEXPECTED(EG(exception) != NULL)) {
47407 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47408 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47409 }
47410 HANDLE_EXCEPTION();
47411 }
47412 }
47413 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47414 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47415 }
47416 zend_invalid_method_call(object, function_name);
47417 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47418
47419 HANDLE_EXCEPTION();
47420 }
47421 } while (0);
47422 }
47423
47424 called_scope = obj->ce;
47425
47426 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
47427 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
47428 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
47429 } else {
47430 zend_object *orig_obj = obj;
47431
47432 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47433 function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47434 }
47435
47436 /* First, locate the function. */
47437 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));
47438 if (UNEXPECTED(fbc == NULL)) {
47439 if (EXPECTED(!EG(exception))) {
47440 zend_undefined_method(obj->ce, Z_STR_P(function_name));
47441 }
47442 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47443 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
47444 zend_objects_store_del(orig_obj);
47445 }
47446 HANDLE_EXCEPTION();
47447 }
47448 if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
47449 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
47450 EXPECTED(obj == orig_obj)) {
47451 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
47452 }
47453 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
47454 GC_ADDREF(obj); /* For $this pointer */
47455 if (GC_DELREF(orig_obj) == 0) {
47456 zend_objects_store_del(orig_obj);
47457 }
47458 }
47459 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
47460 init_func_run_time_cache(&fbc->op_array);
47461 }
47462 }
47463
47464 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47465 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47466 }
47467
47468 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
47469 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
47470 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
47471 zend_objects_store_del(obj);
47472 if (UNEXPECTED(EG(exception))) {
47473 HANDLE_EXCEPTION();
47474 }
47475 }
47476 /* call static method */
47477 obj = (zend_object*)called_scope;
47478 call_info = ZEND_CALL_NESTED_FUNCTION;
47479 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
47480 if (IS_CV == IS_CV) {
47481 GC_ADDREF(obj); /* For $this pointer */
47482 }
47483 /* CV may be changed indirectly (e.g. when it's a reference) */
47484 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
47485 }
47486
47487 call = zend_vm_stack_push_call_frame(call_info,
47488 fbc, opline->extended_value, obj);
47489 call->prev_execute_data = EX(call);
47490 EX(call) = call;
47491
47492 ZEND_VM_NEXT_OPCODE();
47493 }
47494
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47495 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47496 {
47497 USE_OPLINE
47498 zval *expr_ptr, new_expr;
47499
47500 SAVE_OPLINE();
47501 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
47502 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
47503 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
47504 if (Z_ISREF_P(expr_ptr)) {
47505 Z_ADDREF_P(expr_ptr);
47506 } else {
47507 ZVAL_MAKE_REF_EX(expr_ptr, 2);
47508 }
47509
47510 } else {
47511 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
47512 if (IS_CV == IS_TMP_VAR) {
47513 /* pass */
47514 } else if (IS_CV == IS_CONST) {
47515 Z_TRY_ADDREF_P(expr_ptr);
47516 } else if (IS_CV == IS_CV) {
47517 ZVAL_DEREF(expr_ptr);
47518 Z_TRY_ADDREF_P(expr_ptr);
47519 } else /* if (IS_CV == IS_VAR) */ {
47520 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
47521 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
47522
47523 expr_ptr = Z_REFVAL_P(expr_ptr);
47524 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
47525 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
47526 expr_ptr = &new_expr;
47527 efree_size(ref, sizeof(zend_reference));
47528 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
47529 Z_ADDREF_P(expr_ptr);
47530 }
47531 }
47532 }
47533 }
47534
47535 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
47536 zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47537 zend_string *str;
47538 zend_ulong hval;
47539
47540 add_again:
47541 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
47542 str = Z_STR_P(offset);
47543 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47544 if (ZEND_HANDLE_NUMERIC(str, hval)) {
47545 goto num_index;
47546 }
47547 }
47548 str_index:
47549 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
47550 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
47551 hval = Z_LVAL_P(offset);
47552 num_index:
47553 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
47554 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
47555 offset = Z_REFVAL_P(offset);
47556 goto add_again;
47557 } else if (Z_TYPE_P(offset) == IS_NULL) {
47558 str = ZSTR_EMPTY_ALLOC();
47559 goto str_index;
47560 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
47561 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
47562 goto num_index;
47563 } else if (Z_TYPE_P(offset) == IS_FALSE) {
47564 hval = 0;
47565 goto num_index;
47566 } else if (Z_TYPE_P(offset) == IS_TRUE) {
47567 hval = 1;
47568 goto num_index;
47569 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
47570 zend_use_resource_as_offset(offset);
47571 hval = Z_RES_HANDLE_P(offset);
47572 goto num_index;
47573 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
47574 ZVAL_UNDEFINED_OP2();
47575 str = ZSTR_EMPTY_ALLOC();
47576 goto str_index;
47577 } else {
47578 zend_illegal_array_offset_access(offset);
47579 zval_ptr_dtor_nogc(expr_ptr);
47580 }
47581 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47582 } else {
47583 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
47584 zend_cannot_add_element();
47585 zval_ptr_dtor_nogc(expr_ptr);
47586 }
47587 }
47588 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47589 }
47590
ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47591 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47592 {
47593 zval *array;
47594 uint32_t size;
47595 USE_OPLINE
47596
47597 array = EX_VAR(opline->result.var);
47598 if (IS_CV != IS_UNUSED) {
47599 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
47600 ZVAL_ARR(array, zend_new_array(size));
47601 /* Explicitly initialize array as not-packed if flag is set */
47602 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
47603 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
47604 }
47605 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47606 } else {
47607 ZVAL_ARR(array, zend_new_array(0));
47608 ZEND_VM_NEXT_OPCODE();
47609 }
47610 }
47611
ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47612 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47613 {
47614 USE_OPLINE
47615 zval *container;
47616 zval *offset;
47617 zend_ulong hval;
47618 zend_string *key;
47619
47620 SAVE_OPLINE();
47621 container = EX_VAR(opline->op1.var);
47622 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47623
47624 do {
47625 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
47626 HashTable *ht;
47627
47628 unset_dim_array:
47629 SEPARATE_ARRAY(container);
47630 ht = Z_ARRVAL_P(container);
47631 offset_again:
47632 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
47633 key = Z_STR_P(offset);
47634 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47635 if (ZEND_HANDLE_NUMERIC(key, hval)) {
47636 goto num_index_dim;
47637 }
47638 }
47639 str_index_dim:
47640 ZEND_ASSERT(ht != &EG(symbol_table));
47641 zend_hash_del(ht, key);
47642 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
47643 hval = Z_LVAL_P(offset);
47644 num_index_dim:
47645 zend_hash_index_del(ht, hval);
47646 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
47647 offset = Z_REFVAL_P(offset);
47648 goto offset_again;
47649 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
47650 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
47651 goto num_index_dim;
47652 } else if (Z_TYPE_P(offset) == IS_NULL) {
47653 key = ZSTR_EMPTY_ALLOC();
47654 goto str_index_dim;
47655 } else if (Z_TYPE_P(offset) == IS_FALSE) {
47656 hval = 0;
47657 goto num_index_dim;
47658 } else if (Z_TYPE_P(offset) == IS_TRUE) {
47659 hval = 1;
47660 goto num_index_dim;
47661 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
47662 zend_use_resource_as_offset(offset);
47663 hval = Z_RES_HANDLE_P(offset);
47664 goto num_index_dim;
47665 } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
47666 ZVAL_UNDEFINED_OP2();
47667 key = ZSTR_EMPTY_ALLOC();
47668 goto str_index_dim;
47669 } else {
47670 zend_illegal_array_offset_unset(offset);
47671 }
47672 break;
47673 } else if (Z_ISREF_P(container)) {
47674 container = Z_REFVAL_P(container);
47675 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
47676 goto unset_dim_array;
47677 }
47678 }
47679 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
47680 container = ZVAL_UNDEFINED_OP1();
47681 }
47682 if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
47683 offset = ZVAL_UNDEFINED_OP2();
47684 }
47685 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
47686 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
47687 offset++;
47688 }
47689 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
47690 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
47691 zend_throw_error(NULL, "Cannot unset string offsets");
47692 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
47693 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
47694 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
47695 zend_false_to_array_deprecated();
47696 }
47697 } while (0);
47698
47699 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47700
47701 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47702 }
47703
ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47704 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47705 {
47706 USE_OPLINE
47707 zval *container;
47708 zval *offset;
47709 zend_string *name, *tmp_name;
47710
47711 SAVE_OPLINE();
47712 container = EX_VAR(opline->op1.var);
47713 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47714
47715 do {
47716 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
47717 if (Z_ISREF_P(container)) {
47718 container = Z_REFVAL_P(container);
47719 if (Z_TYPE_P(container) != IS_OBJECT) {
47720 if (IS_CV == IS_CV
47721 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
47722 ZVAL_UNDEFINED_OP1();
47723 }
47724 break;
47725 }
47726 } else {
47727 break;
47728 }
47729 }
47730 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47731 name = Z_STR_P(offset);
47732 } else {
47733 name = zval_try_get_tmp_string(offset, &tmp_name);
47734 if (UNEXPECTED(!name)) {
47735 break;
47736 }
47737 }
47738 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));
47739 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47740 zend_tmp_string_release(tmp_name);
47741 }
47742 } while (0);
47743
47744 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47745
47746 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
47747 }
47748
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47749 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47750 {
47751 USE_OPLINE
47752 zval *container;
47753 bool result;
47754 zend_ulong hval;
47755 zval *offset;
47756
47757 SAVE_OPLINE();
47758 container = EX_VAR(opline->op1.var);
47759 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47760
47761 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
47762 HashTable *ht;
47763 zval *value;
47764 zend_string *str;
47765
47766 isset_dim_obj_array:
47767 ht = Z_ARRVAL_P(container);
47768 isset_again:
47769 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
47770 str = Z_STR_P(offset);
47771 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47772 if (ZEND_HANDLE_NUMERIC(str, hval)) {
47773 goto num_index_prop;
47774 }
47775 }
47776 value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST);
47777 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
47778 hval = Z_LVAL_P(offset);
47779 num_index_prop:
47780 value = zend_hash_index_find(ht, hval);
47781 } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
47782 offset = Z_REFVAL_P(offset);
47783 goto isset_again;
47784 } else {
47785 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
47786 if (UNEXPECTED(EG(exception))) {
47787 result = 0;
47788 goto isset_dim_obj_exit;
47789 }
47790 }
47791
47792 if (!(opline->extended_value & ZEND_ISEMPTY)) {
47793 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
47794 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
47795 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
47796
47797 if (IS_CV & (IS_CONST|IS_CV)) {
47798 /* avoid exception check */
47799 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47800 ZEND_VM_SMART_BRANCH(result, 0);
47801 }
47802 } else {
47803 result = (value == NULL || !i_zend_is_true(value));
47804 }
47805 goto isset_dim_obj_exit;
47806 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
47807 container = Z_REFVAL_P(container);
47808 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
47809 goto isset_dim_obj_array;
47810 }
47811 }
47812
47813 if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
47814 offset++;
47815 }
47816 if (!(opline->extended_value & ZEND_ISEMPTY)) {
47817 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
47818 } else {
47819 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
47820 }
47821
47822 isset_dim_obj_exit:
47823 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47824
47825 ZEND_VM_SMART_BRANCH(result, 1);
47826 }
47827
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47828 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47829 {
47830 USE_OPLINE
47831 zval *container;
47832 int result;
47833 zval *offset;
47834 zend_string *name, *tmp_name;
47835
47836 SAVE_OPLINE();
47837 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
47838 offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47839
47840 if (IS_CV == IS_CONST ||
47841 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
47842 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
47843 container = Z_REFVAL_P(container);
47844 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
47845 result = (opline->extended_value & ZEND_ISEMPTY);
47846 goto isset_object_finish;
47847 }
47848 } else {
47849 result = (opline->extended_value & ZEND_ISEMPTY);
47850 goto isset_object_finish;
47851 }
47852 }
47853
47854 if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
47855 name = Z_STR_P(offset);
47856 } else {
47857 name = zval_try_get_tmp_string(offset, &tmp_name);
47858 if (UNEXPECTED(!name)) {
47859 result = 0;
47860 goto isset_object_finish;
47861 }
47862 }
47863
47864 result =
47865 (opline->extended_value & ZEND_ISEMPTY) ^
47866 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));
47867
47868 if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
47869 zend_tmp_string_release(tmp_name);
47870 }
47871
47872 isset_object_finish:
47873 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47874
47875 ZEND_VM_SMART_BRANCH(result, 1);
47876 }
47877
ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47878 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47879 {
47880 USE_OPLINE
47881
47882 zval *key, *subject;
47883 HashTable *ht;
47884 bool result;
47885
47886 SAVE_OPLINE();
47887
47888 key = EX_VAR(opline->op1.var);
47889 subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47890
47891 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
47892 array_key_exists_array:
47893 ht = Z_ARRVAL_P(subject);
47894 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
47895 } else {
47896 if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
47897 subject = Z_REFVAL_P(subject);
47898 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
47899 goto array_key_exists_array;
47900 }
47901 }
47902 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
47903 result = 0;
47904 }
47905
47906 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
47907
47908 ZEND_VM_SMART_BRANCH(result, 1);
47909 }
47910
47911 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)47912 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
47913 {
47914 USE_OPLINE
47915
47916 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
47917
47918 SAVE_OPLINE();
47919 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
47920 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
47921 }
47922
47923 /* Destroy the previously yielded value */
47924 zval_ptr_dtor(&generator->value);
47925
47926 /* Destroy the previously yielded key */
47927 zval_ptr_dtor(&generator->key);
47928
47929 /* Set the new yielded value */
47930 if (IS_CV != IS_UNUSED) {
47931 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
47932 /* Constants and temporary variables aren't yieldable by reference,
47933 * but we still allow them with a notice. */
47934 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
47935 zval *value;
47936
47937 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
47938
47939 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
47940 ZVAL_COPY_VALUE(&generator->value, value);
47941 if (IS_CV == IS_CONST) {
47942 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
47943 Z_ADDREF(generator->value);
47944 }
47945 }
47946 } else {
47947 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
47948
47949 /* If a function call result is yielded and the function did
47950 * not return by reference we throw a notice. */
47951 do {
47952 if (IS_CV == IS_VAR) {
47953 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
47954 if (opline->extended_value == ZEND_RETURNS_FUNCTION
47955 && !Z_ISREF_P(value_ptr)) {
47956 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
47957 ZVAL_COPY(&generator->value, value_ptr);
47958 break;
47959 }
47960 }
47961 if (Z_ISREF_P(value_ptr)) {
47962 Z_ADDREF_P(value_ptr);
47963 } else {
47964 ZVAL_MAKE_REF_EX(value_ptr, 2);
47965 }
47966 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
47967 } while (0);
47968
47969 }
47970 } else {
47971 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
47972
47973 /* Consts, temporary variables and references need copying */
47974 if (IS_CV == IS_CONST) {
47975 ZVAL_COPY_VALUE(&generator->value, value);
47976 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
47977 Z_ADDREF(generator->value);
47978 }
47979 } else if (IS_CV == IS_TMP_VAR) {
47980 ZVAL_COPY_VALUE(&generator->value, value);
47981 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
47982 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
47983
47984 } else {
47985 ZVAL_COPY_VALUE(&generator->value, value);
47986 if (IS_CV == IS_CV) {
47987 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
47988 }
47989 }
47990 }
47991 } else {
47992 /* If no value was specified yield null */
47993 ZVAL_NULL(&generator->value);
47994 }
47995
47996 /* Set the new yielded key */
47997 if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) {
47998 zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
47999 if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
48000 key = Z_REFVAL_P(key);
48001 }
48002 ZVAL_COPY(&generator->key, key);
48003 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48004
48005 if (Z_TYPE(generator->key) == IS_LONG
48006 && Z_LVAL(generator->key) > generator->largest_used_integer_key
48007 ) {
48008 generator->largest_used_integer_key = Z_LVAL(generator->key);
48009 }
48010 } else {
48011 /* If no key was specified we use auto-increment keys */
48012 generator->largest_used_integer_key++;
48013 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
48014 }
48015
48016 if (RETURN_VALUE_USED(opline)) {
48017 /* If the return value of yield is used set the send
48018 * target and initialize it to NULL */
48019 generator->send_target = EX_VAR(opline->result.var);
48020 ZVAL_NULL(generator->send_target);
48021 } else {
48022 generator->send_target = NULL;
48023 }
48024
48025 /* We increment to the next op, so we are at the correct position when the
48026 * generator is resumed. */
48027 ZEND_VM_INC_OPCODE();
48028
48029 /* The GOTO VM uses a local opline variable. We need to set the opline
48030 * variable in execute_data so we don't resume at an old position. */
48031 SAVE_OPLINE();
48032
48033 ZEND_VM_RETURN();
48034 }
48035
ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48036 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48037 {
48038 USE_OPLINE
48039 zval *op1, *op2;
48040 bool result;
48041
48042 SAVE_OPLINE();
48043 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48044 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
48045 result = fast_is_identical_function(op1, op2);
48046
48047 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48048 ZEND_VM_SMART_BRANCH(result, 1);
48049 }
48050
ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48051 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48052 {
48053 USE_OPLINE
48054 zval *op1, *op2;
48055 bool result;
48056
48057 SAVE_OPLINE();
48058 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48059 op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
48060 result = fast_is_not_identical_function(op1, op2);
48061
48062 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48063 ZEND_VM_SMART_BRANCH(result, 1);
48064 }
48065
ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48066 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48067 {
48068 USE_OPLINE
48069 zval *value;
48070 zval *variable_ptr;
48071
48072 SAVE_OPLINE();
48073 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
48074 variable_ptr = EX_VAR(opline->op1.var);
48075
48076 if (0 || UNEXPECTED(0)) {
48077 zend_refcounted *garbage = NULL;
48078
48079 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
48080 if (UNEXPECTED(0)) {
48081 ZVAL_COPY(EX_VAR(opline->result.var), value);
48082 }
48083 if (garbage) {
48084 GC_DTOR_NO_REF(garbage);
48085 }
48086 } else {
48087 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
48088 }
48089
48090 /* zend_assign_to_variable() always takes care of op2, never free it! */
48091
48092 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48093 }
48094
ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48095 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48096 {
48097 USE_OPLINE
48098 zval *value;
48099 zval *variable_ptr;
48100
48101 SAVE_OPLINE();
48102 value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC);
48103 variable_ptr = EX_VAR(opline->op1.var);
48104
48105 if (0 || UNEXPECTED(1)) {
48106 zend_refcounted *garbage = NULL;
48107
48108 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
48109 if (UNEXPECTED(1)) {
48110 ZVAL_COPY(EX_VAR(opline->result.var), value);
48111 }
48112 if (garbage) {
48113 GC_DTOR_NO_REF(garbage);
48114 }
48115 } else {
48116 value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
48117 }
48118
48119 /* zend_assign_to_variable() always takes care of op2, never free it! */
48120
48121 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48122 }
48123
ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48124 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48125 {
48126 USE_OPLINE
48127 zval *op1, *op2;
48128 bool result;
48129
48130 SAVE_OPLINE();
48131 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48132 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
48133 result = fast_is_identical_function(op1, op2);
48134
48135 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48136 ZEND_VM_SMART_BRANCH(result, 1);
48137 }
48138
ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48139 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48140 {
48141 USE_OPLINE
48142 zval *op1, *op2;
48143 bool result;
48144
48145 SAVE_OPLINE();
48146 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
48147 op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC);
48148 result = fast_is_not_identical_function(op1, op2);
48149
48150 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48151 ZEND_VM_SMART_BRANCH(result, 1);
48152 }
48153
ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48154 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48155 {
48156 USE_OPLINE
48157 zval *value;
48158 zval *variable_ptr;
48159
48160 SAVE_OPLINE();
48161 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48162 variable_ptr = EX_VAR(opline->op1.var);
48163
48164 if (0 || UNEXPECTED(0)) {
48165 zend_refcounted *garbage = NULL;
48166
48167 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
48168 if (UNEXPECTED(0)) {
48169 ZVAL_COPY(EX_VAR(opline->result.var), value);
48170 }
48171 if (garbage) {
48172 GC_DTOR_NO_REF(garbage);
48173 }
48174 } else {
48175 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
48176 }
48177
48178 /* zend_assign_to_variable() always takes care of op2, never free it! */
48179
48180 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48181 }
48182
ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48183 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48184 {
48185 USE_OPLINE
48186 zval *value;
48187 zval *variable_ptr;
48188
48189 SAVE_OPLINE();
48190 value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48191 variable_ptr = EX_VAR(opline->op1.var);
48192
48193 if (0 || UNEXPECTED(1)) {
48194 zend_refcounted *garbage = NULL;
48195
48196 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
48197 if (UNEXPECTED(1)) {
48198 ZVAL_COPY(EX_VAR(opline->result.var), value);
48199 }
48200 if (garbage) {
48201 GC_DTOR_NO_REF(garbage);
48202 }
48203 } else {
48204 value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
48205 }
48206
48207 /* zend_assign_to_variable() always takes care of op2, never free it! */
48208
48209 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48210 }
48211
ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48212 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48213 {
48214 USE_OPLINE
48215 zval *variable_ptr;
48216 zval *value_ptr;
48217 zend_refcounted *garbage = NULL;
48218
48219 SAVE_OPLINE();
48220 value_ptr = _get_zval_ptr_ptr_var(opline->op2.var EXECUTE_DATA_CC);
48221 variable_ptr = EX_VAR(opline->op1.var);
48222
48223 if (IS_CV == IS_VAR &&
48224 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
48225
48226 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
48227 variable_ptr = &EG(uninitialized_zval);
48228 } else if (IS_VAR == IS_VAR &&
48229 opline->extended_value == ZEND_RETURNS_FUNCTION &&
48230 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
48231
48232 variable_ptr = zend_wrong_assign_to_variable_reference(
48233 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
48234 } else {
48235 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
48236 }
48237
48238 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48239 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
48240 }
48241
48242 if (garbage) {
48243 GC_DTOR(garbage);
48244 }
48245
48246 zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
48247
48248 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48249 }
48250
ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48251 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48252 {
48253 USE_OPLINE
48254 zval *expr;
48255 bool result;
48256
48257 SAVE_OPLINE();
48258 expr = EX_VAR(opline->op1.var);
48259
48260 try_instanceof:
48261 if (Z_TYPE_P(expr) == IS_OBJECT) {
48262 zend_class_entry *ce;
48263
48264 if (IS_VAR == IS_CONST) {
48265 ce = CACHED_PTR(opline->extended_value);
48266 if (UNEXPECTED(ce == NULL)) {
48267 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);
48268 if (EXPECTED(ce)) {
48269 CACHE_PTR(opline->extended_value, ce);
48270 }
48271 }
48272 } else if (IS_VAR == IS_UNUSED) {
48273 ce = zend_fetch_class(NULL, opline->op2.num);
48274 if (UNEXPECTED(ce == NULL)) {
48275
48276 ZVAL_UNDEF(EX_VAR(opline->result.var));
48277 HANDLE_EXCEPTION();
48278 }
48279 } else {
48280 ce = Z_CE_P(EX_VAR(opline->op2.var));
48281 }
48282 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
48283 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
48284 expr = Z_REFVAL_P(expr);
48285 goto try_instanceof;
48286 } else {
48287 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
48288 ZVAL_UNDEFINED_OP1();
48289 }
48290 result = 0;
48291 }
48292
48293 ZEND_VM_SMART_BRANCH(result, 1);
48294 }
48295
ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48296 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48297 {
48298 USE_OPLINE
48299 zval *var_ptr;
48300 zval *value, *container, *dim;
48301 HashTable *ht;
48302
48303 SAVE_OPLINE();
48304 container = EX_VAR(opline->op1.var);
48305
48306 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
48307 assign_dim_op_array:
48308 SEPARATE_ARRAY(container);
48309 ht = Z_ARRVAL_P(container);
48310 assign_dim_op_new_array:
48311 dim = NULL;
48312 if (IS_UNUSED == IS_UNUSED) {
48313 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
48314 if (UNEXPECTED(!var_ptr)) {
48315 zend_cannot_add_element();
48316 goto assign_dim_op_ret_null;
48317 }
48318 } else {
48319 if (IS_UNUSED == IS_CONST) {
48320 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
48321 } else {
48322 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
48323 }
48324 if (UNEXPECTED(!var_ptr)) {
48325 goto assign_dim_op_ret_null;
48326 }
48327 }
48328
48329 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
48330
48331 do {
48332 if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
48333 zend_reference *ref = Z_REF_P(var_ptr);
48334 var_ptr = Z_REFVAL_P(var_ptr);
48335 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
48336 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
48337 break;
48338 }
48339 }
48340 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
48341 } while (0);
48342
48343 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48344 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
48345 }
48346 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
48347 } else {
48348 if (EXPECTED(Z_ISREF_P(container))) {
48349 container = Z_REFVAL_P(container);
48350 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
48351 goto assign_dim_op_array;
48352 }
48353 }
48354
48355 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
48356 zend_object *obj = Z_OBJ_P(container);
48357
48358 dim = NULL;
48359 if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48360 dim++;
48361 }
48362 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
48363 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
48364 uint8_t old_type;
48365
48366 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
48367 ZVAL_UNDEFINED_OP1();
48368 }
48369 ht = zend_new_array(8);
48370 old_type = Z_TYPE_P(container);
48371 ZVAL_ARR(container, ht);
48372 if (UNEXPECTED(old_type == IS_FALSE)) {
48373 GC_ADDREF(ht);
48374 zend_false_to_array_deprecated();
48375 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48376 zend_array_destroy(ht);
48377 goto assign_dim_op_ret_null;
48378 }
48379 }
48380 goto assign_dim_op_new_array;
48381 } else {
48382 dim = NULL;
48383 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
48384 assign_dim_op_ret_null:
48385 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
48386 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48387 ZVAL_NULL(EX_VAR(opline->result.var));
48388 }
48389 }
48390 }
48391
48392
48393 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48394 }
48395
zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)48396 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)
48397 {
48398 USE_OPLINE
48399 zval *varname;
48400 zval *retval;
48401 zend_string *name, *tmp_name;
48402 HashTable *target_symbol_table;
48403
48404 SAVE_OPLINE();
48405 varname = EX_VAR(opline->op1.var);
48406
48407 if (IS_CV == IS_CONST) {
48408 name = Z_STR_P(varname);
48409 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
48410 name = Z_STR_P(varname);
48411 tmp_name = NULL;
48412 } else {
48413 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
48414 ZVAL_UNDEFINED_OP1();
48415 }
48416 name = zval_try_get_tmp_string(varname, &tmp_name);
48417 if (UNEXPECTED(!name)) {
48418 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
48419
48420 }
48421 ZVAL_UNDEF(EX_VAR(opline->result.var));
48422 HANDLE_EXCEPTION();
48423 }
48424 }
48425
48426 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
48427 retval = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
48428 if (retval == NULL) {
48429 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
48430 fetch_this:
48431 zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
48432 if (IS_CV != IS_CONST) {
48433 zend_tmp_string_release(tmp_name);
48434 }
48435 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48436 }
48437 if (type == BP_VAR_W) {
48438 retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
48439 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
48440 retval = &EG(uninitialized_zval);
48441 } else {
48442 if (IS_CV == IS_CV) {
48443 /* Keep name alive in case an error handler tries to free it. */
48444 zend_string_addref(name);
48445 }
48446 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
48447 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
48448 if (type == BP_VAR_RW && !EG(exception)) {
48449 retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
48450 } else {
48451 retval = &EG(uninitialized_zval);
48452 }
48453 if (IS_CV == IS_CV) {
48454 zend_string_release(name);
48455 }
48456 }
48457 /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
48458 } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
48459 retval = Z_INDIRECT_P(retval);
48460 if (Z_TYPE_P(retval) == IS_UNDEF) {
48461 if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
48462 goto fetch_this;
48463 }
48464 if (type == BP_VAR_W) {
48465 ZVAL_NULL(retval);
48466 } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) {
48467 retval = &EG(uninitialized_zval);
48468 } else {
48469 zend_error_unchecked(E_WARNING, "Undefined %svariable $%S",
48470 (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name);
48471 if (type == BP_VAR_RW && !EG(exception)) {
48472 ZVAL_NULL(retval);
48473 } else {
48474 retval = &EG(uninitialized_zval);
48475 }
48476 }
48477 }
48478 }
48479
48480 if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
48481
48482 }
48483
48484 if (IS_CV != IS_CONST) {
48485 zend_tmp_string_release(tmp_name);
48486 }
48487
48488 ZEND_ASSERT(retval != NULL);
48489 if (type == BP_VAR_R || type == BP_VAR_IS) {
48490 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
48491 } else {
48492 ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
48493 }
48494 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48495 }
48496
ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48497 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48498 {
48499 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_R ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48500 }
48501
ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48502 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48503 {
48504 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_W ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48505 }
48506
ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48507 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48508 {
48509 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_RW ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48510 }
48511
ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48512 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48513 {
48514 int fetch_type =
48515 (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
48516 BP_VAR_W : BP_VAR_R;
48517 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(fetch_type ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48518 }
48519
ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48520 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48521 {
48522 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_UNSET ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48523 }
48524
ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48525 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48526 {
48527 ZEND_VM_TAIL_CALL(zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
48528 }
48529
48530 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48531 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48532 {
48533 USE_OPLINE
48534 zval *container;
48535
48536 SAVE_OPLINE();
48537 container = EX_VAR(opline->op1.var);
48538 zend_fetch_dimension_address_W(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
48539
48540 if (IS_CV == IS_VAR) {
48541 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
48542 }
48543 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48544 }
48545
ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48546 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48547 {
48548 USE_OPLINE
48549 zval *container;
48550
48551 SAVE_OPLINE();
48552 container = EX_VAR(opline->op1.var);
48553 zend_fetch_dimension_address_RW(container, NULL, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC);
48554
48555 if (IS_CV == IS_VAR) {
48556 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
48557 }
48558 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
48559 }
48560
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48561 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48562 {
48563 #if 0
48564 USE_OPLINE
48565 #endif
48566
48567 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
48568 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
48569 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
48570 }
48571 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
48572 } else {
48573 if (IS_UNUSED == IS_UNUSED) {
48574 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
48575 }
48576 ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
48577 }
48578 }
48579
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48580 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48581 {
48582 USE_OPLINE
48583 zval *object_ptr, *orig_object_ptr;
48584 zval *value;
48585 zval *variable_ptr;
48586 zval *dim;
48587 zend_refcounted *garbage = NULL;
48588
48589 SAVE_OPLINE();
48590 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48591
48592 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48593 try_assign_dim_array:
48594 SEPARATE_ARRAY(object_ptr);
48595 if (IS_UNUSED == IS_UNUSED) {
48596 value = RT_CONSTANT((opline+1), (opline+1)->op1);
48597 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48598 HashTable *ht = Z_ARRVAL_P(object_ptr);
48599 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48600 GC_ADDREF(ht);
48601 }
48602 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48603 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48604 zend_array_destroy(ht);
48605 goto assign_dim_error;
48606 }
48607 }
48608 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
48609 ZVAL_DEREF(value);
48610 }
48611 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48612 if (UNEXPECTED(value == NULL)) {
48613 zend_cannot_add_element();
48614 goto assign_dim_error;
48615 } else if (IS_CONST == IS_CV) {
48616 if (Z_REFCOUNTED_P(value)) {
48617 Z_ADDREF_P(value);
48618 }
48619 } else if (IS_CONST == IS_VAR) {
48620 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48621 if (Z_ISREF_P(free_op_data)) {
48622 if (Z_REFCOUNTED_P(value)) {
48623 Z_ADDREF_P(value);
48624 }
48625 zval_ptr_dtor_nogc(free_op_data);
48626 }
48627 } else if (IS_CONST == IS_CONST) {
48628 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48629 Z_ADDREF_P(value);
48630 }
48631 }
48632 } else {
48633 dim = NULL;
48634 if (IS_UNUSED == IS_CONST) {
48635 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48636 } else {
48637 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48638 }
48639 if (UNEXPECTED(variable_ptr == NULL)) {
48640 goto assign_dim_error;
48641 }
48642 value = RT_CONSTANT((opline+1), (opline+1)->op1);
48643 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
48644 }
48645 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48646 ZVAL_COPY(EX_VAR(opline->result.var), value);
48647 }
48648 if (garbage) {
48649 GC_DTOR_NO_REF(garbage);
48650 }
48651 } else {
48652 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48653 object_ptr = Z_REFVAL_P(object_ptr);
48654 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48655 goto try_assign_dim_array;
48656 }
48657 }
48658 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48659 zend_object *obj = Z_OBJ_P(object_ptr);
48660
48661 GC_ADDREF(obj);
48662 dim = NULL;
48663 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48664 dim = ZVAL_UNDEFINED_OP2();
48665 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48666 dim++;
48667 }
48668
48669 value = RT_CONSTANT((opline+1), (opline+1)->op1);
48670 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48671 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48672 } else if (IS_CONST & (IS_CV|IS_VAR)) {
48673 ZVAL_DEREF(value);
48674 }
48675
48676 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48677
48678 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48679 zend_objects_store_del(obj);
48680 }
48681 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48682 if (IS_UNUSED == IS_UNUSED) {
48683 zend_use_new_element_for_string();
48684
48685 UNDEF_RESULT();
48686 } else {
48687 dim = NULL;
48688 value = RT_CONSTANT((opline+1), (opline+1)->op1);
48689 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48690
48691 }
48692 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48693 if (Z_ISREF_P(orig_object_ptr)
48694 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48695 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48696 dim = NULL;
48697
48698 UNDEF_RESULT();
48699 } else {
48700 HashTable *ht = zend_new_array(8);
48701 uint8_t old_type = Z_TYPE_P(object_ptr);
48702
48703 ZVAL_ARR(object_ptr, ht);
48704 if (UNEXPECTED(old_type == IS_FALSE)) {
48705 GC_ADDREF(ht);
48706 zend_false_to_array_deprecated();
48707 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48708 zend_array_destroy(ht);
48709 goto assign_dim_error;
48710 }
48711 }
48712 goto try_assign_dim_array;
48713 }
48714 } else {
48715 zend_use_scalar_as_array();
48716 dim = NULL;
48717 assign_dim_error:
48718
48719 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48720 ZVAL_NULL(EX_VAR(opline->result.var));
48721 }
48722 }
48723 }
48724 if (IS_UNUSED != IS_UNUSED) {
48725
48726 }
48727
48728 /* assign_dim has two opcodes! */
48729 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48730 }
48731
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48732 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48733 {
48734 USE_OPLINE
48735 zval *object_ptr, *orig_object_ptr;
48736 zval *value;
48737 zval *variable_ptr;
48738 zval *dim;
48739 zend_refcounted *garbage = NULL;
48740
48741 SAVE_OPLINE();
48742 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48743
48744 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48745 try_assign_dim_array:
48746 SEPARATE_ARRAY(object_ptr);
48747 if (IS_UNUSED == IS_UNUSED) {
48748 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48749 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48750 HashTable *ht = Z_ARRVAL_P(object_ptr);
48751 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48752 GC_ADDREF(ht);
48753 }
48754 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48755 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48756 zend_array_destroy(ht);
48757 goto assign_dim_error;
48758 }
48759 }
48760 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
48761 ZVAL_DEREF(value);
48762 }
48763 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48764 if (UNEXPECTED(value == NULL)) {
48765 zend_cannot_add_element();
48766 goto assign_dim_error;
48767 } else if (IS_TMP_VAR == IS_CV) {
48768 if (Z_REFCOUNTED_P(value)) {
48769 Z_ADDREF_P(value);
48770 }
48771 } else if (IS_TMP_VAR == IS_VAR) {
48772 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48773 if (Z_ISREF_P(free_op_data)) {
48774 if (Z_REFCOUNTED_P(value)) {
48775 Z_ADDREF_P(value);
48776 }
48777 zval_ptr_dtor_nogc(free_op_data);
48778 }
48779 } else if (IS_TMP_VAR == IS_CONST) {
48780 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48781 Z_ADDREF_P(value);
48782 }
48783 }
48784 } else {
48785 dim = NULL;
48786 if (IS_UNUSED == IS_CONST) {
48787 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48788 } else {
48789 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48790 }
48791 if (UNEXPECTED(variable_ptr == NULL)) {
48792 goto assign_dim_error;
48793 }
48794 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48795 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
48796 }
48797 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48798 ZVAL_COPY(EX_VAR(opline->result.var), value);
48799 }
48800 if (garbage) {
48801 GC_DTOR_NO_REF(garbage);
48802 }
48803 } else {
48804 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48805 object_ptr = Z_REFVAL_P(object_ptr);
48806 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48807 goto try_assign_dim_array;
48808 }
48809 }
48810 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48811 zend_object *obj = Z_OBJ_P(object_ptr);
48812
48813 GC_ADDREF(obj);
48814 dim = NULL;
48815 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48816 dim = ZVAL_UNDEFINED_OP2();
48817 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48818 dim++;
48819 }
48820
48821 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48822 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48823 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48824 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
48825 ZVAL_DEREF(value);
48826 }
48827
48828 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48829
48830 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48831 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48832 zend_objects_store_del(obj);
48833 }
48834 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48835 if (IS_UNUSED == IS_UNUSED) {
48836 zend_use_new_element_for_string();
48837 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48838 UNDEF_RESULT();
48839 } else {
48840 dim = NULL;
48841 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
48842 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48843 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48844 }
48845 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48846 if (Z_ISREF_P(orig_object_ptr)
48847 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
48848 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
48849 dim = NULL;
48850 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48851 UNDEF_RESULT();
48852 } else {
48853 HashTable *ht = zend_new_array(8);
48854 uint8_t old_type = Z_TYPE_P(object_ptr);
48855
48856 ZVAL_ARR(object_ptr, ht);
48857 if (UNEXPECTED(old_type == IS_FALSE)) {
48858 GC_ADDREF(ht);
48859 zend_false_to_array_deprecated();
48860 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
48861 zend_array_destroy(ht);
48862 goto assign_dim_error;
48863 }
48864 }
48865 goto try_assign_dim_array;
48866 }
48867 } else {
48868 zend_use_scalar_as_array();
48869 dim = NULL;
48870 assign_dim_error:
48871 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48872 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48873 ZVAL_NULL(EX_VAR(opline->result.var));
48874 }
48875 }
48876 }
48877 if (IS_UNUSED != IS_UNUSED) {
48878
48879 }
48880
48881 /* assign_dim has two opcodes! */
48882 ZEND_VM_NEXT_OPCODE_EX(1, 2);
48883 }
48884
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)48885 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
48886 {
48887 USE_OPLINE
48888 zval *object_ptr, *orig_object_ptr;
48889 zval *value;
48890 zval *variable_ptr;
48891 zval *dim;
48892 zend_refcounted *garbage = NULL;
48893
48894 SAVE_OPLINE();
48895 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
48896
48897 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48898 try_assign_dim_array:
48899 SEPARATE_ARRAY(object_ptr);
48900 if (IS_UNUSED == IS_UNUSED) {
48901 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48902 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
48903 HashTable *ht = Z_ARRVAL_P(object_ptr);
48904 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
48905 GC_ADDREF(ht);
48906 }
48907 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48908 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
48909 zend_array_destroy(ht);
48910 goto assign_dim_error;
48911 }
48912 }
48913 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
48914 ZVAL_DEREF(value);
48915 }
48916 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
48917 if (UNEXPECTED(value == NULL)) {
48918 zend_cannot_add_element();
48919 goto assign_dim_error;
48920 } else if (IS_VAR == IS_CV) {
48921 if (Z_REFCOUNTED_P(value)) {
48922 Z_ADDREF_P(value);
48923 }
48924 } else if (IS_VAR == IS_VAR) {
48925 zval *free_op_data = EX_VAR((opline+1)->op1.var);
48926 if (Z_ISREF_P(free_op_data)) {
48927 if (Z_REFCOUNTED_P(value)) {
48928 Z_ADDREF_P(value);
48929 }
48930 zval_ptr_dtor_nogc(free_op_data);
48931 }
48932 } else if (IS_VAR == IS_CONST) {
48933 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
48934 Z_ADDREF_P(value);
48935 }
48936 }
48937 } else {
48938 dim = NULL;
48939 if (IS_UNUSED == IS_CONST) {
48940 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48941 } else {
48942 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
48943 }
48944 if (UNEXPECTED(variable_ptr == NULL)) {
48945 goto assign_dim_error;
48946 }
48947 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48948 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
48949 }
48950 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
48951 ZVAL_COPY(EX_VAR(opline->result.var), value);
48952 }
48953 if (garbage) {
48954 GC_DTOR_NO_REF(garbage);
48955 }
48956 } else {
48957 if (EXPECTED(Z_ISREF_P(object_ptr))) {
48958 object_ptr = Z_REFVAL_P(object_ptr);
48959 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
48960 goto try_assign_dim_array;
48961 }
48962 }
48963 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
48964 zend_object *obj = Z_OBJ_P(object_ptr);
48965
48966 GC_ADDREF(obj);
48967 dim = NULL;
48968 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
48969 dim = ZVAL_UNDEFINED_OP2();
48970 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
48971 dim++;
48972 }
48973
48974 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48975 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
48976 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
48977 } else if (IS_VAR & (IS_CV|IS_VAR)) {
48978 ZVAL_DEREF(value);
48979 }
48980
48981 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
48982
48983 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48984 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
48985 zend_objects_store_del(obj);
48986 }
48987 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
48988 if (IS_UNUSED == IS_UNUSED) {
48989 zend_use_new_element_for_string();
48990 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48991 UNDEF_RESULT();
48992 } else {
48993 dim = NULL;
48994 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
48995 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
48996 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
48997 }
48998 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
48999 if (Z_ISREF_P(orig_object_ptr)
49000 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
49001 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
49002 dim = NULL;
49003 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
49004 UNDEF_RESULT();
49005 } else {
49006 HashTable *ht = zend_new_array(8);
49007 uint8_t old_type = Z_TYPE_P(object_ptr);
49008
49009 ZVAL_ARR(object_ptr, ht);
49010 if (UNEXPECTED(old_type == IS_FALSE)) {
49011 GC_ADDREF(ht);
49012 zend_false_to_array_deprecated();
49013 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
49014 zend_array_destroy(ht);
49015 goto assign_dim_error;
49016 }
49017 }
49018 goto try_assign_dim_array;
49019 }
49020 } else {
49021 zend_use_scalar_as_array();
49022 dim = NULL;
49023 assign_dim_error:
49024 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
49025 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49026 ZVAL_NULL(EX_VAR(opline->result.var));
49027 }
49028 }
49029 }
49030 if (IS_UNUSED != IS_UNUSED) {
49031
49032 }
49033
49034 /* assign_dim has two opcodes! */
49035 ZEND_VM_NEXT_OPCODE_EX(1, 2);
49036 }
49037
ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49038 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49039 {
49040 USE_OPLINE
49041 zval *object_ptr, *orig_object_ptr;
49042 zval *value;
49043 zval *variable_ptr;
49044 zval *dim;
49045 zend_refcounted *garbage = NULL;
49046
49047 SAVE_OPLINE();
49048 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
49049
49050 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
49051 try_assign_dim_array:
49052 SEPARATE_ARRAY(object_ptr);
49053 if (IS_UNUSED == IS_UNUSED) {
49054 value = EX_VAR((opline+1)->op1.var);
49055 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
49056 HashTable *ht = Z_ARRVAL_P(object_ptr);
49057 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
49058 GC_ADDREF(ht);
49059 }
49060 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
49061 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
49062 zend_array_destroy(ht);
49063 goto assign_dim_error;
49064 }
49065 }
49066 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
49067 ZVAL_DEREF(value);
49068 }
49069 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
49070 if (UNEXPECTED(value == NULL)) {
49071 zend_cannot_add_element();
49072 goto assign_dim_error;
49073 } else if (IS_CV == IS_CV) {
49074 if (Z_REFCOUNTED_P(value)) {
49075 Z_ADDREF_P(value);
49076 }
49077 } else if (IS_CV == IS_VAR) {
49078 zval *free_op_data = EX_VAR((opline+1)->op1.var);
49079 if (Z_ISREF_P(free_op_data)) {
49080 if (Z_REFCOUNTED_P(value)) {
49081 Z_ADDREF_P(value);
49082 }
49083 zval_ptr_dtor_nogc(free_op_data);
49084 }
49085 } else if (IS_CV == IS_CONST) {
49086 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
49087 Z_ADDREF_P(value);
49088 }
49089 }
49090 } else {
49091 dim = NULL;
49092 if (IS_UNUSED == IS_CONST) {
49093 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
49094 } else {
49095 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
49096 }
49097 if (UNEXPECTED(variable_ptr == NULL)) {
49098 goto assign_dim_error;
49099 }
49100 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
49101 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
49102 }
49103 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49104 ZVAL_COPY(EX_VAR(opline->result.var), value);
49105 }
49106 if (garbage) {
49107 GC_DTOR_NO_REF(garbage);
49108 }
49109 } else {
49110 if (EXPECTED(Z_ISREF_P(object_ptr))) {
49111 object_ptr = Z_REFVAL_P(object_ptr);
49112 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
49113 goto try_assign_dim_array;
49114 }
49115 }
49116 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
49117 zend_object *obj = Z_OBJ_P(object_ptr);
49118
49119 GC_ADDREF(obj);
49120 dim = NULL;
49121 if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
49122 dim = ZVAL_UNDEFINED_OP2();
49123 } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
49124 dim++;
49125 }
49126
49127 value = EX_VAR((opline+1)->op1.var);
49128 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
49129 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
49130 } else if (IS_CV & (IS_CV|IS_VAR)) {
49131 ZVAL_DEREF(value);
49132 }
49133
49134 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
49135
49136 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
49137 zend_objects_store_del(obj);
49138 }
49139 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
49140 if (IS_UNUSED == IS_UNUSED) {
49141 zend_use_new_element_for_string();
49142
49143 UNDEF_RESULT();
49144 } else {
49145 dim = NULL;
49146 value = EX_VAR((opline+1)->op1.var);
49147 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
49148
49149 }
49150 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
49151 if (Z_ISREF_P(orig_object_ptr)
49152 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
49153 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
49154 dim = NULL;
49155
49156 UNDEF_RESULT();
49157 } else {
49158 HashTable *ht = zend_new_array(8);
49159 uint8_t old_type = Z_TYPE_P(object_ptr);
49160
49161 ZVAL_ARR(object_ptr, ht);
49162 if (UNEXPECTED(old_type == IS_FALSE)) {
49163 GC_ADDREF(ht);
49164 zend_false_to_array_deprecated();
49165 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
49166 zend_array_destroy(ht);
49167 goto assign_dim_error;
49168 }
49169 }
49170 goto try_assign_dim_array;
49171 }
49172 } else {
49173 zend_use_scalar_as_array();
49174 dim = NULL;
49175 assign_dim_error:
49176
49177 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
49178 ZVAL_NULL(EX_VAR(opline->result.var));
49179 }
49180 }
49181 }
49182 if (IS_UNUSED != IS_UNUSED) {
49183
49184 }
49185
49186 /* assign_dim has two opcodes! */
49187 ZEND_VM_NEXT_OPCODE_EX(1, 2);
49188 }
49189
ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49190 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49191 {
49192 if (IS_CV == IS_UNUSED) {
49193 SAVE_OPLINE();
49194 zend_verify_missing_return_type(EX(func));
49195 HANDLE_EXCEPTION();
49196 } else {
49197 /* prevents "undefined variable opline" errors */
49198 #if 0 || (IS_CV != IS_UNUSED)
49199 USE_OPLINE
49200 zval *retval_ref, *retval_ptr;
49201 zend_arg_info *ret_info = EX(func)->common.arg_info - 1;
49202 retval_ref = retval_ptr = EX_VAR(opline->op1.var);
49203
49204 if (IS_CV == IS_CONST) {
49205 ZVAL_COPY(EX_VAR(opline->result.var), retval_ptr);
49206 retval_ref = retval_ptr = EX_VAR(opline->result.var);
49207 } else if (IS_CV == IS_VAR) {
49208 if (UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_INDIRECT)) {
49209 retval_ref = retval_ptr = Z_INDIRECT_P(retval_ptr);
49210 }
49211 ZVAL_DEREF(retval_ptr);
49212 } else if (IS_CV == IS_CV) {
49213 ZVAL_DEREF(retval_ptr);
49214 }
49215
49216 if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(ret_info->type, Z_TYPE_P(retval_ptr)))) {
49217 ZEND_VM_NEXT_OPCODE();
49218 }
49219
49220 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(retval_ptr))) {
49221 SAVE_OPLINE();
49222 retval_ref = retval_ptr = ZVAL_UNDEFINED_OP1();
49223 if (UNEXPECTED(EG(exception))) {
49224 HANDLE_EXCEPTION();
49225 }
49226 if (ZEND_TYPE_FULL_MASK(ret_info->type) & MAY_BE_NULL) {
49227 ZEND_VM_NEXT_OPCODE();
49228 }
49229 }
49230
49231 zend_reference *ref = NULL;
49232 void *cache_slot = CACHE_ADDR(opline->op2.num);
49233 if (UNEXPECTED(retval_ref != retval_ptr)) {
49234 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
49235 ref = Z_REF_P(retval_ref);
49236 } else {
49237 /* A cast might happen - unwrap the reference if this is a by-value return */
49238 if (Z_REFCOUNT_P(retval_ref) == 1) {
49239 ZVAL_UNREF(retval_ref);
49240 } else {
49241 Z_DELREF_P(retval_ref);
49242 ZVAL_COPY(retval_ref, retval_ptr);
49243 }
49244 retval_ptr = retval_ref;
49245 }
49246 }
49247
49248 SAVE_OPLINE();
49249 if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
49250 zend_verify_return_error(EX(func), retval_ptr);
49251 HANDLE_EXCEPTION();
49252 }
49253 ZEND_VM_NEXT_OPCODE();
49254 #endif
49255 }
49256 }
49257
ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49258 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49259 {
49260 USE_OPLINE
49261 zval *varptr, *arg;
49262
49263 if (IS_UNUSED == IS_CONST) {
49264 SAVE_OPLINE();
49265 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
49266 uint32_t arg_num;
49267 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
49268 if (UNEXPECTED(!arg)) {
49269
49270 HANDLE_EXCEPTION();
49271 }
49272 } else {
49273 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
49274 }
49275
49276 varptr = EX_VAR(opline->op1.var);
49277 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
49278 SAVE_OPLINE();
49279 ZVAL_UNDEFINED_OP1();
49280 ZVAL_NULL(arg);
49281 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49282 }
49283
49284 if (IS_CV == IS_CV) {
49285 ZVAL_COPY_DEREF(arg, varptr);
49286 } else /* if (IS_CV == IS_VAR) */ {
49287 if (UNEXPECTED(Z_ISREF_P(varptr))) {
49288 zend_refcounted *ref = Z_COUNTED_P(varptr);
49289
49290 varptr = Z_REFVAL_P(varptr);
49291 ZVAL_COPY_VALUE(arg, varptr);
49292 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
49293 efree_size(ref, sizeof(zend_reference));
49294 } else if (Z_OPT_REFCOUNTED_P(arg)) {
49295 Z_ADDREF_P(arg);
49296 }
49297 } else {
49298 ZVAL_COPY_VALUE(arg, varptr);
49299 }
49300 }
49301
49302 ZEND_VM_NEXT_OPCODE();
49303 }
49304
ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49305 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49306 {
49307 USE_OPLINE
49308 zval *varptr, *arg;
49309
49310 SAVE_OPLINE();
49311 if (IS_UNUSED == IS_CONST) {
49312 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
49313 uint32_t arg_num;
49314 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
49315 if (UNEXPECTED(!arg)) {
49316
49317 HANDLE_EXCEPTION();
49318 }
49319 } else {
49320 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
49321 }
49322
49323 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49324 if (Z_ISREF_P(varptr)) {
49325 Z_ADDREF_P(varptr);
49326 } else {
49327 ZVAL_MAKE_REF_EX(varptr, 2);
49328 }
49329 ZVAL_REF(arg, Z_REF_P(varptr));
49330
49331 ZEND_VM_NEXT_OPCODE();
49332 }
49333
ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49334 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49335 {
49336 USE_OPLINE
49337 zval *varptr, *arg;
49338 uint32_t arg_num;
49339
49340 if (IS_UNUSED == IS_CONST) {
49341 SAVE_OPLINE();
49342 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
49343 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
49344 if (UNEXPECTED(!arg)) {
49345
49346 HANDLE_EXCEPTION();
49347 }
49348 } else {
49349 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
49350 arg_num = opline->op2.num;
49351 }
49352
49353 if (EXPECTED(0)) {
49354 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
49355 goto send_var_by_ref;
49356 }
49357 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
49358 send_var_by_ref:
49359 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49360 if (Z_ISREF_P(varptr)) {
49361 Z_ADDREF_P(varptr);
49362 } else {
49363 ZVAL_MAKE_REF_EX(varptr, 2);
49364 }
49365 ZVAL_REF(arg, Z_REF_P(varptr));
49366
49367 ZEND_VM_NEXT_OPCODE();
49368 }
49369
49370 varptr = EX_VAR(opline->op1.var);
49371 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
49372 SAVE_OPLINE();
49373 ZVAL_UNDEFINED_OP1();
49374 ZVAL_NULL(arg);
49375 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49376 }
49377
49378 if (IS_CV == IS_CV) {
49379 ZVAL_COPY_DEREF(arg, varptr);
49380 } else /* if (IS_CV == IS_VAR) */ {
49381 if (UNEXPECTED(Z_ISREF_P(varptr))) {
49382 zend_refcounted *ref = Z_COUNTED_P(varptr);
49383
49384 varptr = Z_REFVAL_P(varptr);
49385 ZVAL_COPY_VALUE(arg, varptr);
49386 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
49387 efree_size(ref, sizeof(zend_reference));
49388 } else if (Z_OPT_REFCOUNTED_P(arg)) {
49389 Z_ADDREF_P(arg);
49390 }
49391 } else {
49392 ZVAL_COPY_VALUE(arg, varptr);
49393 }
49394 }
49395
49396 ZEND_VM_NEXT_OPCODE();
49397 }
49398
ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49399 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49400 {
49401 USE_OPLINE
49402 zval *varptr, *arg;
49403 uint32_t arg_num;
49404
49405 if (IS_UNUSED == IS_CONST) {
49406 SAVE_OPLINE();
49407 zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
49408 arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
49409 if (UNEXPECTED(!arg)) {
49410
49411 HANDLE_EXCEPTION();
49412 }
49413 } else {
49414 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
49415 arg_num = opline->op2.num;
49416 }
49417
49418 if (EXPECTED(1)) {
49419 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
49420 goto send_var_by_ref;
49421 }
49422 } else if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
49423 send_var_by_ref:
49424 varptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49425 if (Z_ISREF_P(varptr)) {
49426 Z_ADDREF_P(varptr);
49427 } else {
49428 ZVAL_MAKE_REF_EX(varptr, 2);
49429 }
49430 ZVAL_REF(arg, Z_REF_P(varptr));
49431
49432 ZEND_VM_NEXT_OPCODE();
49433 }
49434
49435 varptr = EX_VAR(opline->op1.var);
49436 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(varptr) == IS_UNDEF)) {
49437 SAVE_OPLINE();
49438 ZVAL_UNDEFINED_OP1();
49439 ZVAL_NULL(arg);
49440 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49441 }
49442
49443 if (IS_CV == IS_CV) {
49444 ZVAL_COPY_DEREF(arg, varptr);
49445 } else /* if (IS_CV == IS_VAR) */ {
49446 if (UNEXPECTED(Z_ISREF_P(varptr))) {
49447 zend_refcounted *ref = Z_COUNTED_P(varptr);
49448
49449 varptr = Z_REFVAL_P(varptr);
49450 ZVAL_COPY_VALUE(arg, varptr);
49451 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
49452 efree_size(ref, sizeof(zend_reference));
49453 } else if (Z_OPT_REFCOUNTED_P(arg)) {
49454 Z_ADDREF_P(arg);
49455 }
49456 } else {
49457 ZVAL_COPY_VALUE(arg, varptr);
49458 }
49459 }
49460
49461 ZEND_VM_NEXT_OPCODE();
49462 }
49463
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49464 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49465 {
49466 USE_OPLINE
49467 zval *expr_ptr, new_expr;
49468
49469 SAVE_OPLINE();
49470 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
49471 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
49472 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49473 if (Z_ISREF_P(expr_ptr)) {
49474 Z_ADDREF_P(expr_ptr);
49475 } else {
49476 ZVAL_MAKE_REF_EX(expr_ptr, 2);
49477 }
49478
49479 } else {
49480 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49481 if (IS_CV == IS_TMP_VAR) {
49482 /* pass */
49483 } else if (IS_CV == IS_CONST) {
49484 Z_TRY_ADDREF_P(expr_ptr);
49485 } else if (IS_CV == IS_CV) {
49486 ZVAL_DEREF(expr_ptr);
49487 Z_TRY_ADDREF_P(expr_ptr);
49488 } else /* if (IS_CV == IS_VAR) */ {
49489 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
49490 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
49491
49492 expr_ptr = Z_REFVAL_P(expr_ptr);
49493 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
49494 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
49495 expr_ptr = &new_expr;
49496 efree_size(ref, sizeof(zend_reference));
49497 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
49498 Z_ADDREF_P(expr_ptr);
49499 }
49500 }
49501 }
49502 }
49503
49504 if (IS_UNUSED != IS_UNUSED) {
49505 zval *offset = NULL;
49506 zend_string *str;
49507 zend_ulong hval;
49508
49509 add_again:
49510 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
49511 str = Z_STR_P(offset);
49512 if (IS_UNUSED != IS_CONST) {
49513 if (ZEND_HANDLE_NUMERIC(str, hval)) {
49514 goto num_index;
49515 }
49516 }
49517 str_index:
49518 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
49519 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
49520 hval = Z_LVAL_P(offset);
49521 num_index:
49522 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
49523 } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
49524 offset = Z_REFVAL_P(offset);
49525 goto add_again;
49526 } else if (Z_TYPE_P(offset) == IS_NULL) {
49527 str = ZSTR_EMPTY_ALLOC();
49528 goto str_index;
49529 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
49530 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
49531 goto num_index;
49532 } else if (Z_TYPE_P(offset) == IS_FALSE) {
49533 hval = 0;
49534 goto num_index;
49535 } else if (Z_TYPE_P(offset) == IS_TRUE) {
49536 hval = 1;
49537 goto num_index;
49538 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
49539 zend_use_resource_as_offset(offset);
49540 hval = Z_RES_HANDLE_P(offset);
49541 goto num_index;
49542 } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
49543 ZVAL_UNDEFINED_OP2();
49544 str = ZSTR_EMPTY_ALLOC();
49545 goto str_index;
49546 } else {
49547 zend_illegal_array_offset_access(offset);
49548 zval_ptr_dtor_nogc(expr_ptr);
49549 }
49550
49551 } else {
49552 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
49553 zend_cannot_add_element();
49554 zval_ptr_dtor_nogc(expr_ptr);
49555 }
49556 }
49557 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49558 }
49559
ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49560 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49561 {
49562 zval *array;
49563 uint32_t size;
49564 USE_OPLINE
49565
49566 array = EX_VAR(opline->result.var);
49567 if (IS_CV != IS_UNUSED) {
49568 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
49569 ZVAL_ARR(array, zend_new_array(size));
49570 /* Explicitly initialize array as not-packed if flag is set */
49571 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
49572 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
49573 }
49574 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49575 } else {
49576 ZVAL_ARR(array, zend_new_array(0));
49577 ZEND_VM_NEXT_OPCODE();
49578 }
49579 }
49580
ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49581 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49582 {
49583 USE_OPLINE
49584 zval *var = EX_VAR(opline->op1.var);
49585
49586 if (Z_REFCOUNTED_P(var)) {
49587 zend_refcounted *garbage = Z_COUNTED_P(var);
49588
49589 ZVAL_UNDEF(var);
49590 SAVE_OPLINE();
49591 GC_DTOR(garbage);
49592 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49593 } else {
49594 ZVAL_UNDEF(var);
49595 }
49596 ZEND_VM_NEXT_OPCODE();
49597 }
49598
ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49599 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49600 {
49601 USE_OPLINE
49602 zval *varname;
49603 zend_string *name, *tmp_name;
49604 HashTable *target_symbol_table;
49605
49606 SAVE_OPLINE();
49607
49608 varname = EX_VAR(opline->op1.var);
49609
49610 if (IS_CV == IS_CONST) {
49611 name = Z_STR_P(varname);
49612 } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
49613 name = Z_STR_P(varname);
49614 tmp_name = NULL;
49615 } else {
49616 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
49617 varname = ZVAL_UNDEFINED_OP1();
49618 }
49619 name = zval_try_get_tmp_string(varname, &tmp_name);
49620 if (UNEXPECTED(!name)) {
49621
49622 HANDLE_EXCEPTION();
49623 }
49624 }
49625
49626 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
49627 zend_hash_del_ind(target_symbol_table, name);
49628
49629 if (IS_CV != IS_CONST) {
49630 zend_tmp_string_release(tmp_name);
49631 }
49632
49633 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49634 }
49635
49636 /* 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)49637 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49638 {
49639 USE_OPLINE
49640 zval *value;
49641
49642 value = EX_VAR(opline->op1.var);
49643 if (!(0)) {
49644 if (Z_TYPE_P(value) > IS_NULL &&
49645 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
49646 ZEND_VM_SMART_BRANCH_TRUE();
49647 } else {
49648 ZEND_VM_SMART_BRANCH_FALSE();
49649 }
49650 } else {
49651 bool result;
49652
49653 SAVE_OPLINE();
49654 result = !i_zend_is_true(value);
49655 ZEND_VM_SMART_BRANCH(result, 1);
49656 }
49657 }
49658
ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49659 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49660 {
49661 USE_OPLINE
49662 zval *value;
49663
49664 value = EX_VAR(opline->op1.var);
49665 if (!(1)) {
49666 if (Z_TYPE_P(value) > IS_NULL &&
49667 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL)) {
49668 ZEND_VM_SMART_BRANCH_TRUE();
49669 } else {
49670 ZEND_VM_SMART_BRANCH_FALSE();
49671 }
49672 } else {
49673 bool result;
49674
49675 SAVE_OPLINE();
49676 result = !i_zend_is_true(value);
49677 ZEND_VM_SMART_BRANCH(result, 1);
49678 }
49679 }
49680
ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49681 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49682 {
49683 USE_OPLINE
49684 zval *value;
49685 /* Should be bool result? as below got: result = (opline->extended_value & ZEND_ISEMPTY) */
49686 int result;
49687 zval *varname;
49688 zend_string *name, *tmp_name;
49689 HashTable *target_symbol_table;
49690
49691 SAVE_OPLINE();
49692 varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
49693 if (IS_CV == IS_CONST) {
49694 name = Z_STR_P(varname);
49695 } else {
49696 name = zval_get_tmp_string(varname, &tmp_name);
49697 }
49698
49699 target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
49700 value = zend_hash_find_ex(target_symbol_table, name, IS_CV == IS_CONST);
49701
49702 if (IS_CV != IS_CONST) {
49703 zend_tmp_string_release(tmp_name);
49704 }
49705
49706 if (!value) {
49707 result = (opline->extended_value & ZEND_ISEMPTY);
49708 } else {
49709 if (Z_TYPE_P(value) == IS_INDIRECT) {
49710 value = Z_INDIRECT_P(value);
49711 }
49712 if (!(opline->extended_value & ZEND_ISEMPTY)) {
49713 if (Z_ISREF_P(value)) {
49714 value = Z_REFVAL_P(value);
49715 }
49716 result = Z_TYPE_P(value) > IS_NULL;
49717 } else {
49718 result = !i_zend_is_true(value);
49719 }
49720 }
49721
49722 ZEND_VM_SMART_BRANCH(result, 1);
49723 }
49724
49725 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */
ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49726 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49727 {
49728 USE_OPLINE
49729 zval *expr;
49730 bool result;
49731
49732 SAVE_OPLINE();
49733 expr = EX_VAR(opline->op1.var);
49734
49735 try_instanceof:
49736 if (Z_TYPE_P(expr) == IS_OBJECT) {
49737 zend_class_entry *ce;
49738
49739 if (IS_UNUSED == IS_CONST) {
49740 ce = CACHED_PTR(opline->extended_value);
49741 if (UNEXPECTED(ce == NULL)) {
49742 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);
49743 if (EXPECTED(ce)) {
49744 CACHE_PTR(opline->extended_value, ce);
49745 }
49746 }
49747 } else if (IS_UNUSED == IS_UNUSED) {
49748 ce = zend_fetch_class(NULL, opline->op2.num);
49749 if (UNEXPECTED(ce == NULL)) {
49750
49751 ZVAL_UNDEF(EX_VAR(opline->result.var));
49752 HANDLE_EXCEPTION();
49753 }
49754 } else {
49755 ce = Z_CE_P(EX_VAR(opline->op2.var));
49756 }
49757 result = ce && instanceof_function(Z_OBJCE_P(expr), ce);
49758 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) {
49759 expr = Z_REFVAL_P(expr);
49760 goto try_instanceof;
49761 } else {
49762 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) {
49763 ZVAL_UNDEFINED_OP1();
49764 }
49765 result = 0;
49766 }
49767
49768 ZEND_VM_SMART_BRANCH(result, 1);
49769 }
49770
ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49771 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49772 {
49773 USE_OPLINE
49774
49775 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
49776
49777 SAVE_OPLINE();
49778 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
49779 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
49780 }
49781
49782 /* Destroy the previously yielded value */
49783 zval_ptr_dtor(&generator->value);
49784
49785 /* Destroy the previously yielded key */
49786 zval_ptr_dtor(&generator->key);
49787
49788 /* Set the new yielded value */
49789 if (IS_CV != IS_UNUSED) {
49790 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
49791 /* Constants and temporary variables aren't yieldable by reference,
49792 * but we still allow them with a notice. */
49793 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
49794 zval *value;
49795
49796 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49797
49798 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49799 ZVAL_COPY_VALUE(&generator->value, value);
49800 if (IS_CV == IS_CONST) {
49801 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49802 Z_ADDREF(generator->value);
49803 }
49804 }
49805 } else {
49806 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
49807
49808 /* If a function call result is yielded and the function did
49809 * not return by reference we throw a notice. */
49810 do {
49811 if (IS_CV == IS_VAR) {
49812 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
49813 if (opline->extended_value == ZEND_RETURNS_FUNCTION
49814 && !Z_ISREF_P(value_ptr)) {
49815 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
49816 ZVAL_COPY(&generator->value, value_ptr);
49817 break;
49818 }
49819 }
49820 if (Z_ISREF_P(value_ptr)) {
49821 Z_ADDREF_P(value_ptr);
49822 } else {
49823 ZVAL_MAKE_REF_EX(value_ptr, 2);
49824 }
49825 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
49826 } while (0);
49827
49828 }
49829 } else {
49830 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
49831
49832 /* Consts, temporary variables and references need copying */
49833 if (IS_CV == IS_CONST) {
49834 ZVAL_COPY_VALUE(&generator->value, value);
49835 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
49836 Z_ADDREF(generator->value);
49837 }
49838 } else if (IS_CV == IS_TMP_VAR) {
49839 ZVAL_COPY_VALUE(&generator->value, value);
49840 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
49841 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
49842
49843 } else {
49844 ZVAL_COPY_VALUE(&generator->value, value);
49845 if (IS_CV == IS_CV) {
49846 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
49847 }
49848 }
49849 }
49850 } else {
49851 /* If no value was specified yield null */
49852 ZVAL_NULL(&generator->value);
49853 }
49854
49855 /* Set the new yielded key */
49856 if (IS_UNUSED != IS_UNUSED) {
49857 zval *key = NULL;
49858 if ((IS_UNUSED & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
49859 key = Z_REFVAL_P(key);
49860 }
49861 ZVAL_COPY(&generator->key, key);
49862
49863 if (Z_TYPE(generator->key) == IS_LONG
49864 && Z_LVAL(generator->key) > generator->largest_used_integer_key
49865 ) {
49866 generator->largest_used_integer_key = Z_LVAL(generator->key);
49867 }
49868 } else {
49869 /* If no key was specified we use auto-increment keys */
49870 generator->largest_used_integer_key++;
49871 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
49872 }
49873
49874 if (RETURN_VALUE_USED(opline)) {
49875 /* If the return value of yield is used set the send
49876 * target and initialize it to NULL */
49877 generator->send_target = EX_VAR(opline->result.var);
49878 ZVAL_NULL(generator->send_target);
49879 } else {
49880 generator->send_target = NULL;
49881 }
49882
49883 /* We increment to the next op, so we are at the correct position when the
49884 * generator is resumed. */
49885 ZEND_VM_INC_OPCODE();
49886
49887 /* The GOTO VM uses a local opline variable. We need to set the opline
49888 * variable in execute_data so we don't resume at an old position. */
49889 SAVE_OPLINE();
49890
49891 ZEND_VM_RETURN();
49892 }
49893
ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49894 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49895 {
49896 USE_OPLINE
49897 zval *op1 = EX_VAR(opline->op1.var);
49898
49899 if (UNEXPECTED(Z_TYPE_INFO_P(op1) == IS_UNDEF)) {
49900 SAVE_OPLINE();
49901 ZVAL_UNDEFINED_OP1();
49902 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49903 }
49904 ZEND_VM_NEXT_OPCODE();
49905 }
49906
ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49907 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49908 {
49909 USE_OPLINE
49910 zval *op1 = EX_VAR(opline->op1.var);
49911
49912 if (IS_CV == IS_CV) {
49913 if (UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
49914 ZVAL_NEW_EMPTY_REF(op1);
49915 Z_SET_REFCOUNT_P(op1, 2);
49916 ZVAL_NULL(Z_REFVAL_P(op1));
49917 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
49918 } else {
49919 if (Z_ISREF_P(op1)) {
49920 Z_ADDREF_P(op1);
49921 } else {
49922 ZVAL_MAKE_REF_EX(op1, 2);
49923 }
49924 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
49925 }
49926 } else if (EXPECTED(Z_TYPE_P(op1) == IS_INDIRECT)) {
49927 op1 = Z_INDIRECT_P(op1);
49928 if (EXPECTED(!Z_ISREF_P(op1))) {
49929 ZVAL_MAKE_REF_EX(op1, 2);
49930 } else {
49931 GC_ADDREF(Z_REF_P(op1));
49932 }
49933 ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(op1));
49934 } else {
49935 ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
49936 }
49937 ZEND_VM_NEXT_OPCODE();
49938 }
49939
ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49940 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49941 {
49942 USE_OPLINE
49943 zval *op1;
49944 zend_long count;
49945
49946 SAVE_OPLINE();
49947 op1 = EX_VAR(opline->op1.var);
49948
49949 while (1) {
49950 if (Z_TYPE_P(op1) == IS_ARRAY) {
49951 count = zend_hash_num_elements(Z_ARRVAL_P(op1));
49952 break;
49953 } else if (Z_TYPE_P(op1) == IS_OBJECT) {
49954 zend_object *zobj = Z_OBJ_P(op1);
49955
49956 /* first, we check if the handler is defined */
49957 if (zobj->handlers->count_elements) {
49958 if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) {
49959 break;
49960 }
49961 if (UNEXPECTED(EG(exception))) {
49962 count = 0;
49963 break;
49964 }
49965 }
49966
49967 /* if not and the object implements Countable we call its count() method */
49968 if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) {
49969 zval retval;
49970
49971 zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));
49972 zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);
49973 count = zval_get_long(&retval);
49974 zval_ptr_dtor(&retval);
49975 break;
49976 }
49977
49978 /* If There's no handler and it doesn't implement Countable then emit a TypeError */
49979 } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
49980 op1 = Z_REFVAL_P(op1);
49981 continue;
49982 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
49983 ZVAL_UNDEFINED_OP1();
49984 }
49985 count = 0;
49986 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));
49987 break;
49988 }
49989
49990 ZVAL_LONG(EX_VAR(opline->result.var), count);
49991
49992 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
49993 }
49994
ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)49995 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
49996 {
49997 USE_OPLINE
49998 zend_array *ht = Z_ARRVAL_P(EX_VAR(opline->op1.var));
49999 ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht));
50000 if (IS_CV & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
50001 SAVE_OPLINE();
50002 zend_array_destroy(ht);
50003 if (EG(exception)) {
50004 HANDLE_EXCEPTION();
50005 }
50006 }
50007 ZEND_VM_NEXT_OPCODE();
50008 }
50009
ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50010 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50011 {
50012 USE_OPLINE
50013
50014 if (IS_CV == IS_UNUSED) {
50015 SAVE_OPLINE();
50016 if (UNEXPECTED(!EX(func)->common.scope)) {
50017 zend_throw_error(NULL, "get_class() without arguments must be called from within a class");
50018 ZVAL_UNDEF(EX_VAR(opline->result.var));
50019 HANDLE_EXCEPTION();
50020 } else {
50021 zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated");
50022 ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name);
50023 if (UNEXPECTED(EG(exception))) {
50024 HANDLE_EXCEPTION();
50025 }
50026 ZEND_VM_NEXT_OPCODE();
50027 }
50028 } else {
50029 zval *op1;
50030
50031 SAVE_OPLINE();
50032 op1 = EX_VAR(opline->op1.var);
50033 while (1) {
50034 if (Z_TYPE_P(op1) == IS_OBJECT) {
50035 ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name);
50036 } else if ((IS_CV & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) {
50037 op1 = Z_REFVAL_P(op1);
50038 continue;
50039 } else {
50040 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
50041 ZVAL_UNDEFINED_OP1();
50042 }
50043 zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1));
50044 ZVAL_UNDEF(EX_VAR(opline->result.var));
50045 }
50046 break;
50047 }
50048
50049 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50050 }
50051 }
50052
ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50053 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50054 {
50055 USE_OPLINE
50056 zval *op1;
50057 zend_string *type;
50058
50059 SAVE_OPLINE();
50060 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50061 type = zend_zval_get_legacy_type(op1);
50062 if (EXPECTED(type)) {
50063 ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type);
50064 } else {
50065 ZVAL_STRING(EX_VAR(opline->result.var), "unknown type");
50066 }
50067
50068 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50069 }
50070
ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50071 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50072 {
50073 USE_OPLINE
50074 zval *varptr, *arg;
50075 uint32_t arg_num = opline->op2.num;
50076
50077 if (QUICK_ARG_SHOULD_BE_SENT_BY_REF(EX(call)->func, arg_num)) {
50078 ZEND_VM_TAIL_CALL(ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
50079 }
50080
50081 varptr = EX_VAR(opline->op1.var);
50082 arg = ZEND_CALL_VAR(EX(call), opline->result.var);
50083
50084 if (IS_CV == IS_CV) {
50085 ZVAL_COPY(arg, varptr);
50086 } else /* if (IS_CV == IS_VAR) */ {
50087 ZVAL_COPY_VALUE(arg, varptr);
50088 }
50089
50090 ZEND_VM_NEXT_OPCODE();
50091 }
50092
ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50093 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50094 {
50095 USE_OPLINE
50096 zval *op1, *op2;
50097
50098 SAVE_OPLINE();
50099 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50100 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50101 div_function(EX_VAR(opline->result.var), op1, op2);
50102
50103
50104 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50105 }
50106
ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50107 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50108 {
50109 USE_OPLINE
50110 zval *op1, *op2;
50111
50112 SAVE_OPLINE();
50113 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50114 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50115 pow_function(EX_VAR(opline->result.var), op1, op2);
50116
50117
50118 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50119 }
50120
ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50121 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50122 {
50123 USE_OPLINE
50124 zval *op1, *op2;
50125
50126 op1 = EX_VAR(opline->op1.var);
50127 op2 = EX_VAR(opline->op2.var);
50128
50129 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
50130 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
50131 zend_string *op1_str = Z_STR_P(op1);
50132 zend_string *op2_str = Z_STR_P(op2);
50133 zend_string *str;
50134 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
50135
50136 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
50137 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
50138 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
50139 } else {
50140 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
50141 }
50142 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50143 zend_string_release_ex(op1_str, 0);
50144 }
50145 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
50146 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
50147 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
50148 } else {
50149 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
50150 }
50151 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50152 zend_string_release_ex(op2_str, 0);
50153 }
50154 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
50155 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
50156 size_t len = ZSTR_LEN(op1_str);
50157
50158 if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
50159 zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
50160 }
50161 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
50162 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
50163 GC_ADD_FLAGS(str, flags);
50164 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
50165 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50166 zend_string_release_ex(op2_str, 0);
50167 }
50168 } else {
50169 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
50170 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
50171 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
50172 GC_ADD_FLAGS(str, flags);
50173 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
50174 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50175 zend_string_release_ex(op1_str, 0);
50176 }
50177 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50178 zend_string_release_ex(op2_str, 0);
50179 }
50180 }
50181 ZEND_VM_NEXT_OPCODE();
50182 } else {
50183 SAVE_OPLINE();
50184
50185 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
50186 op1 = ZVAL_UNDEFINED_OP1();
50187 }
50188 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
50189 op2 = ZVAL_UNDEFINED_OP2();
50190 }
50191 concat_function(EX_VAR(opline->result.var), op1, op2);
50192
50193
50194 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50195 }
50196 }
50197
ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50198 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50199 {
50200 USE_OPLINE
50201 zval *op1, *op2;
50202 bool result;
50203
50204 SAVE_OPLINE();
50205 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50206 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50207 result = fast_is_identical_function(op1, op2);
50208
50209
50210 ZEND_VM_SMART_BRANCH(result, 1);
50211 }
50212
ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50213 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50214 {
50215 USE_OPLINE
50216 zval *op1, *op2;
50217 bool result;
50218
50219 SAVE_OPLINE();
50220 op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50221 op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50222 result = fast_is_not_identical_function(op1, op2);
50223
50224
50225 ZEND_VM_SMART_BRANCH(result, 1);
50226 }
50227
ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50228 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50229 {
50230 USE_OPLINE
50231 zval *op1, *op2;
50232 double d1, d2;
50233
50234 op1 = EX_VAR(opline->op1.var);
50235 op2 = EX_VAR(opline->op2.var);
50236 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50237 /* pass */
50238 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50239 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50240 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
50241 is_equal_true:
50242 ZEND_VM_SMART_BRANCH_TRUE_NONE();
50243 } else {
50244 is_equal_false:
50245 ZEND_VM_SMART_BRANCH_FALSE_NONE();
50246 }
50247 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50248 d1 = (double)Z_LVAL_P(op1);
50249 d2 = Z_DVAL_P(op2);
50250 goto is_equal_double;
50251 }
50252 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50253 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50254 d1 = Z_DVAL_P(op1);
50255 d2 = Z_DVAL_P(op2);
50256 is_equal_double:
50257 if (d1 == d2) {
50258 goto is_equal_true;
50259 } else {
50260 goto is_equal_false;
50261 }
50262 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50263 d1 = Z_DVAL_P(op1);
50264 d2 = (double)Z_LVAL_P(op2);
50265 goto is_equal_double;
50266 }
50267 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50268 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50269 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50270 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50271 zval_ptr_dtor_str(op1);
50272 }
50273 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50274 zval_ptr_dtor_str(op2);
50275 }
50276 if (result) {
50277 goto is_equal_true;
50278 } else {
50279 goto is_equal_false;
50280 }
50281 }
50282 }
50283 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50284 }
50285
ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50286 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50287 {
50288 USE_OPLINE
50289 zval *op1, *op2;
50290 double d1, d2;
50291
50292 op1 = EX_VAR(opline->op1.var);
50293 op2 = EX_VAR(opline->op2.var);
50294 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50295 /* pass */
50296 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50297 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50298 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
50299 is_equal_true:
50300 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
50301 } else {
50302 is_equal_false:
50303 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
50304 }
50305 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50306 d1 = (double)Z_LVAL_P(op1);
50307 d2 = Z_DVAL_P(op2);
50308 goto is_equal_double;
50309 }
50310 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50311 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50312 d1 = Z_DVAL_P(op1);
50313 d2 = Z_DVAL_P(op2);
50314 is_equal_double:
50315 if (d1 == d2) {
50316 goto is_equal_true;
50317 } else {
50318 goto is_equal_false;
50319 }
50320 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50321 d1 = Z_DVAL_P(op1);
50322 d2 = (double)Z_LVAL_P(op2);
50323 goto is_equal_double;
50324 }
50325 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50326 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50327 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50328 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50329 zval_ptr_dtor_str(op1);
50330 }
50331 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50332 zval_ptr_dtor_str(op2);
50333 }
50334 if (result) {
50335 goto is_equal_true;
50336 } else {
50337 goto is_equal_false;
50338 }
50339 }
50340 }
50341 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50342 }
50343
ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50344 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50345 {
50346 USE_OPLINE
50347 zval *op1, *op2;
50348 double d1, d2;
50349
50350 op1 = EX_VAR(opline->op1.var);
50351 op2 = EX_VAR(opline->op2.var);
50352 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50353 /* pass */
50354 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50355 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50356 if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
50357 is_equal_true:
50358 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
50359 } else {
50360 is_equal_false:
50361 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
50362 }
50363 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50364 d1 = (double)Z_LVAL_P(op1);
50365 d2 = Z_DVAL_P(op2);
50366 goto is_equal_double;
50367 }
50368 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50369 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50370 d1 = Z_DVAL_P(op1);
50371 d2 = Z_DVAL_P(op2);
50372 is_equal_double:
50373 if (d1 == d2) {
50374 goto is_equal_true;
50375 } else {
50376 goto is_equal_false;
50377 }
50378 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50379 d1 = Z_DVAL_P(op1);
50380 d2 = (double)Z_LVAL_P(op2);
50381 goto is_equal_double;
50382 }
50383 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50384 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50385 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50386 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50387 zval_ptr_dtor_str(op1);
50388 }
50389 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50390 zval_ptr_dtor_str(op2);
50391 }
50392 if (result) {
50393 goto is_equal_true;
50394 } else {
50395 goto is_equal_false;
50396 }
50397 }
50398 }
50399 ZEND_VM_TAIL_CALL(zend_is_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50400 }
50401
ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50402 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50403 {
50404 USE_OPLINE
50405 zval *op1, *op2;
50406 double d1, d2;
50407
50408 op1 = EX_VAR(opline->op1.var);
50409 op2 = EX_VAR(opline->op2.var);
50410 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50411 /* pass */
50412 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50413 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50414 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
50415 is_not_equal_true:
50416 ZEND_VM_SMART_BRANCH_TRUE_NONE();
50417 } else {
50418 is_not_equal_false:
50419 ZEND_VM_SMART_BRANCH_FALSE_NONE();
50420 }
50421 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50422 d1 = (double)Z_LVAL_P(op1);
50423 d2 = Z_DVAL_P(op2);
50424 goto is_not_equal_double;
50425 }
50426 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50427 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50428 d1 = Z_DVAL_P(op1);
50429 d2 = Z_DVAL_P(op2);
50430 is_not_equal_double:
50431 if (d1 != d2) {
50432 goto is_not_equal_true;
50433 } else {
50434 goto is_not_equal_false;
50435 }
50436 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50437 d1 = Z_DVAL_P(op1);
50438 d2 = (double)Z_LVAL_P(op2);
50439 goto is_not_equal_double;
50440 }
50441 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50442 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50443 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50444 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50445 zval_ptr_dtor_str(op1);
50446 }
50447 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50448 zval_ptr_dtor_str(op2);
50449 }
50450 if (!result) {
50451 goto is_not_equal_true;
50452 } else {
50453 goto is_not_equal_false;
50454 }
50455 }
50456 }
50457 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50458 }
50459
ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50460 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50461 {
50462 USE_OPLINE
50463 zval *op1, *op2;
50464 double d1, d2;
50465
50466 op1 = EX_VAR(opline->op1.var);
50467 op2 = EX_VAR(opline->op2.var);
50468 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50469 /* pass */
50470 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50471 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50472 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
50473 is_not_equal_true:
50474 ZEND_VM_SMART_BRANCH_TRUE_JMPZ();
50475 } else {
50476 is_not_equal_false:
50477 ZEND_VM_SMART_BRANCH_FALSE_JMPZ();
50478 }
50479 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50480 d1 = (double)Z_LVAL_P(op1);
50481 d2 = Z_DVAL_P(op2);
50482 goto is_not_equal_double;
50483 }
50484 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50485 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50486 d1 = Z_DVAL_P(op1);
50487 d2 = Z_DVAL_P(op2);
50488 is_not_equal_double:
50489 if (d1 != d2) {
50490 goto is_not_equal_true;
50491 } else {
50492 goto is_not_equal_false;
50493 }
50494 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50495 d1 = Z_DVAL_P(op1);
50496 d2 = (double)Z_LVAL_P(op2);
50497 goto is_not_equal_double;
50498 }
50499 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50500 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50501 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50502 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50503 zval_ptr_dtor_str(op1);
50504 }
50505 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50506 zval_ptr_dtor_str(op2);
50507 }
50508 if (!result) {
50509 goto is_not_equal_true;
50510 } else {
50511 goto is_not_equal_false;
50512 }
50513 }
50514 }
50515 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50516 }
50517
ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50518 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50519 {
50520 USE_OPLINE
50521 zval *op1, *op2;
50522 double d1, d2;
50523
50524 op1 = EX_VAR(opline->op1.var);
50525 op2 = EX_VAR(opline->op2.var);
50526 if (1 && IS_CV == IS_CONST && IS_CV == IS_CONST) {
50527 /* pass */
50528 } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
50529 if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50530 if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
50531 is_not_equal_true:
50532 ZEND_VM_SMART_BRANCH_TRUE_JMPNZ();
50533 } else {
50534 is_not_equal_false:
50535 ZEND_VM_SMART_BRANCH_FALSE_JMPNZ();
50536 }
50537 } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50538 d1 = (double)Z_LVAL_P(op1);
50539 d2 = Z_DVAL_P(op2);
50540 goto is_not_equal_double;
50541 }
50542 } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
50543 if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
50544 d1 = Z_DVAL_P(op1);
50545 d2 = Z_DVAL_P(op2);
50546 is_not_equal_double:
50547 if (d1 != d2) {
50548 goto is_not_equal_true;
50549 } else {
50550 goto is_not_equal_false;
50551 }
50552 } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
50553 d1 = Z_DVAL_P(op1);
50554 d2 = (double)Z_LVAL_P(op2);
50555 goto is_not_equal_double;
50556 }
50557 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
50558 if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
50559 bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
50560 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50561 zval_ptr_dtor_str(op1);
50562 }
50563 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
50564 zval_ptr_dtor_str(op2);
50565 }
50566 if (!result) {
50567 goto is_not_equal_true;
50568 } else {
50569 goto is_not_equal_false;
50570 }
50571 }
50572 }
50573 ZEND_VM_TAIL_CALL(zend_is_not_equal_helper_SPEC(op1, op2 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
50574 }
50575
ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50576 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50577 {
50578 USE_OPLINE
50579 zval *op1, *op2;
50580
50581 SAVE_OPLINE();
50582 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50583 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50584 compare_function(EX_VAR(opline->result.var), op1, op2);
50585
50586
50587 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50588 }
50589
ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50590 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50591 {
50592 USE_OPLINE
50593 zval *op1, *op2;
50594
50595 SAVE_OPLINE();
50596 op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
50597 op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50598 boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
50599
50600
50601 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50602 }
50603
ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50604 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50605 {
50606 USE_OPLINE
50607 zval *object;
50608 zval *property;
50609 zval *value;
50610 zval *zptr;
50611 void **cache_slot;
50612 zend_property_info *prop_info;
50613 zend_object *zobj;
50614 zend_string *name, *tmp_name;
50615
50616 SAVE_OPLINE();
50617 object = EX_VAR(opline->op1.var);
50618 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50619
50620 do {
50621 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
50622
50623 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
50624 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
50625 object = Z_REFVAL_P(object);
50626 goto assign_op_object;
50627 }
50628 if (IS_CV == IS_CV
50629 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
50630 ZVAL_UNDEFINED_OP1();
50631 }
50632 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
50633 break;
50634 }
50635
50636 assign_op_object:
50637 /* here we are sure we are dealing with an object */
50638 zobj = Z_OBJ_P(object);
50639 if (IS_CV == IS_CONST) {
50640 name = Z_STR_P(property);
50641 } else {
50642 name = zval_try_get_tmp_string(property, &tmp_name);
50643 if (UNEXPECTED(!name)) {
50644 UNDEF_RESULT();
50645 break;
50646 }
50647 }
50648 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
50649 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
50650 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
50651 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50652 ZVAL_NULL(EX_VAR(opline->result.var));
50653 }
50654 } else {
50655 zval *orig_zptr = zptr;
50656 zend_reference *ref;
50657
50658 do {
50659 if (UNEXPECTED(Z_ISREF_P(zptr))) {
50660 ref = Z_REF_P(zptr);
50661 zptr = Z_REFVAL_P(zptr);
50662 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
50663 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
50664 break;
50665 }
50666 }
50667
50668 if (IS_CV == IS_CONST) {
50669 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
50670 } else {
50671 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
50672 }
50673 if (prop_info) {
50674 /* special case for typed properties */
50675 zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
50676 } else {
50677 zend_binary_op(zptr, zptr, value OPLINE_CC);
50678 }
50679 } while (0);
50680
50681 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50682 ZVAL_COPY(EX_VAR(opline->result.var), zptr);
50683 }
50684 }
50685 } else {
50686 zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
50687 }
50688 if (IS_CV != IS_CONST) {
50689 zend_tmp_string_release(tmp_name);
50690 }
50691 } while (0);
50692
50693 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
50694
50695
50696 /* assign_obj has two opcodes! */
50697 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50698 }
50699
50700 /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50701 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50702 {
50703 USE_OPLINE
50704 zval *var_ptr;
50705 zval *value, *container, *dim;
50706 HashTable *ht;
50707
50708 SAVE_OPLINE();
50709 container = EX_VAR(opline->op1.var);
50710
50711 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
50712 assign_dim_op_array:
50713 SEPARATE_ARRAY(container);
50714 ht = Z_ARRVAL_P(container);
50715 assign_dim_op_new_array:
50716 dim = EX_VAR(opline->op2.var);
50717 if (IS_CV == IS_UNUSED) {
50718 var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval));
50719 if (UNEXPECTED(!var_ptr)) {
50720 zend_cannot_add_element();
50721 goto assign_dim_op_ret_null;
50722 }
50723 } else {
50724 if (IS_CV == IS_CONST) {
50725 var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC);
50726 } else {
50727 var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC);
50728 }
50729 if (UNEXPECTED(!var_ptr)) {
50730 goto assign_dim_op_ret_null;
50731 }
50732 }
50733
50734 value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
50735
50736 do {
50737 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
50738 zend_reference *ref = Z_REF_P(var_ptr);
50739 var_ptr = Z_REFVAL_P(var_ptr);
50740 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
50741 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
50742 break;
50743 }
50744 }
50745 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
50746 } while (0);
50747
50748 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50749 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
50750 }
50751 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
50752 } else {
50753 if (EXPECTED(Z_ISREF_P(container))) {
50754 container = Z_REFVAL_P(container);
50755 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
50756 goto assign_dim_op_array;
50757 }
50758 }
50759
50760 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
50761 zend_object *obj = Z_OBJ_P(container);
50762
50763 dim = EX_VAR(opline->op2.var);
50764 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50765 dim++;
50766 }
50767 zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC);
50768 } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
50769 uint8_t old_type;
50770
50771 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
50772 ZVAL_UNDEFINED_OP1();
50773 }
50774 ht = zend_new_array(8);
50775 old_type = Z_TYPE_P(container);
50776 ZVAL_ARR(container, ht);
50777 if (UNEXPECTED(old_type == IS_FALSE)) {
50778 GC_ADDREF(ht);
50779 zend_false_to_array_deprecated();
50780 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
50781 zend_array_destroy(ht);
50782 goto assign_dim_op_ret_null;
50783 }
50784 }
50785 goto assign_dim_op_new_array;
50786 } else {
50787 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50788 zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
50789 assign_dim_op_ret_null:
50790 FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
50791 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50792 ZVAL_NULL(EX_VAR(opline->result.var));
50793 }
50794 }
50795 }
50796
50797
50798 ZEND_VM_NEXT_OPCODE_EX(1, 2);
50799 }
50800
ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50801 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50802 {
50803 USE_OPLINE
50804 zval *var_ptr;
50805 zval *value;
50806
50807 SAVE_OPLINE();
50808 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50809 var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
50810
50811 do {
50812 if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
50813 zend_reference *ref = Z_REF_P(var_ptr);
50814 var_ptr = Z_REFVAL_P(var_ptr);
50815 if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
50816 zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
50817 break;
50818 }
50819 }
50820 zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
50821 } while (0);
50822
50823 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50824 ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
50825 }
50826
50827
50828 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50829 }
50830
ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50831 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50832 {
50833 USE_OPLINE
50834 zval *object;
50835 zval *property;
50836 zval *zptr;
50837 void **cache_slot;
50838 zend_property_info *prop_info;
50839 zend_object *zobj;
50840 zend_string *name, *tmp_name;
50841
50842 SAVE_OPLINE();
50843 object = EX_VAR(opline->op1.var);
50844 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50845
50846 do {
50847 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
50848 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
50849 object = Z_REFVAL_P(object);
50850 goto pre_incdec_object;
50851 }
50852 if (IS_CV == IS_CV
50853 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
50854 ZVAL_UNDEFINED_OP1();
50855 }
50856 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
50857 break;
50858 }
50859
50860 pre_incdec_object:
50861 /* here we are sure we are dealing with an object */
50862 zobj = Z_OBJ_P(object);
50863 if (IS_CV == IS_CONST) {
50864 name = Z_STR_P(property);
50865 } else {
50866 name = zval_try_get_tmp_string(property, &tmp_name);
50867 if (UNEXPECTED(!name)) {
50868 UNDEF_RESULT();
50869 break;
50870 }
50871 }
50872 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
50873 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
50874 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
50875 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
50876 ZVAL_NULL(EX_VAR(opline->result.var));
50877 }
50878 } else {
50879 if (IS_CV == IS_CONST) {
50880 prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
50881 } else {
50882 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
50883 }
50884 zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
50885 }
50886 } else {
50887 zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
50888 }
50889 if (IS_CV != IS_CONST) {
50890 zend_tmp_string_release(tmp_name);
50891 }
50892 } while (0);
50893
50894
50895 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50896 }
50897
ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50898 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50899 {
50900 USE_OPLINE
50901 zval *object;
50902 zval *property;
50903 zval *zptr;
50904 void **cache_slot;
50905 zend_property_info *prop_info;
50906 zend_object *zobj;
50907 zend_string *name, *tmp_name;
50908
50909 SAVE_OPLINE();
50910 object = EX_VAR(opline->op1.var);
50911 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
50912
50913 do {
50914 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
50915 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
50916 object = Z_REFVAL_P(object);
50917 goto post_incdec_object;
50918 }
50919 if (IS_CV == IS_CV
50920 && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
50921 ZVAL_UNDEFINED_OP1();
50922 }
50923 zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
50924 break;
50925 }
50926
50927 post_incdec_object:
50928 /* here we are sure we are dealing with an object */
50929 zobj = Z_OBJ_P(object);
50930 if (IS_CV == IS_CONST) {
50931 name = Z_STR_P(property);
50932 } else {
50933 name = zval_try_get_tmp_string(property, &tmp_name);
50934 if (UNEXPECTED(!name)) {
50935 ZVAL_UNDEF(EX_VAR(opline->result.var));
50936 break;
50937 }
50938 }
50939 cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
50940 if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
50941 if (UNEXPECTED(Z_ISERROR_P(zptr))) {
50942 ZVAL_NULL(EX_VAR(opline->result.var));
50943 } else {
50944 if (IS_CV == IS_CONST) {
50945 prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
50946 } else {
50947 prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
50948 }
50949
50950 zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
50951 }
50952 } else {
50953 zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
50954 }
50955 if (IS_CV != IS_CONST) {
50956 zend_tmp_string_release(tmp_name);
50957 }
50958 } while (0);
50959
50960
50961 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50962 }
50963
ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50964 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
50965 {
50966 USE_OPLINE
50967 zval *container, *dim, *value;
50968
50969 SAVE_OPLINE();
50970 container = EX_VAR(opline->op1.var);
50971 dim = EX_VAR(opline->op2.var);
50972 if (IS_CV != IS_CONST) {
50973 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
50974 fetch_dim_r_array:
50975 value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC);
50976 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
50977 } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) {
50978 container = Z_REFVAL_P(container);
50979 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
50980 goto fetch_dim_r_array;
50981 } else {
50982 goto fetch_dim_r_slow;
50983 }
50984 } else {
50985 fetch_dim_r_slow:
50986 if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
50987 dim++;
50988 }
50989 zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
50990 }
50991 } else {
50992 zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC);
50993 }
50994
50995
50996 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
50997 }
50998
ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)50999 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51000 {
51001 USE_OPLINE
51002 zval *container;
51003
51004 SAVE_OPLINE();
51005 container = EX_VAR(opline->op1.var);
51006 zend_fetch_dimension_address_W(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
51007
51008 if (IS_CV == IS_VAR) {
51009 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51010 }
51011 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51012 }
51013
ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51014 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51015 {
51016 USE_OPLINE
51017 zval *container;
51018
51019 SAVE_OPLINE();
51020 container = EX_VAR(opline->op1.var);
51021 zend_fetch_dimension_address_RW(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
51022
51023 if (IS_CV == IS_VAR) {
51024 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51025 }
51026 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51027 }
51028
ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51029 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51030 {
51031 USE_OPLINE
51032 zval *container;
51033
51034 SAVE_OPLINE();
51035 container = EX_VAR(opline->op1.var);
51036 zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
51037
51038
51039 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51040 }
51041
ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51042 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51043 {
51044 #if 0
51045 USE_OPLINE
51046 #endif
51047
51048 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
51049 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
51050 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51051 }
51052 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51053 } else {
51054 if (IS_CV == IS_UNUSED) {
51055 ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51056 }
51057 ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51058 }
51059 }
51060
ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51061 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51062 {
51063 USE_OPLINE
51064 zval *container;
51065
51066 SAVE_OPLINE();
51067 container = EX_VAR(opline->op1.var);
51068 zend_fetch_dimension_address_UNSET(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC);
51069
51070 if (IS_CV == IS_VAR) {
51071 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51072 }
51073 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51074 }
51075
ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51076 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51077 {
51078 USE_OPLINE
51079 zval *container;
51080 void **cache_slot = NULL;
51081
51082 SAVE_OPLINE();
51083 container = EX_VAR(opline->op1.var);
51084
51085 if (IS_CV == IS_CONST ||
51086 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
51087 do {
51088 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
51089 container = Z_REFVAL_P(container);
51090 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
51091 break;
51092 }
51093 }
51094 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
51095 ZVAL_UNDEFINED_OP1();
51096 }
51097 zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51098 ZVAL_NULL(EX_VAR(opline->result.var));
51099 goto fetch_obj_r_finish;
51100 } while (0);
51101 }
51102
51103 /* here we are sure we are dealing with an object */
51104 do {
51105 zend_object *zobj = Z_OBJ_P(container);
51106 zend_string *name, *tmp_name;
51107 zval *retval;
51108
51109 if (IS_CV == IS_CONST) {
51110 cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
51111
51112 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
51113 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51114
51115 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51116 retval = OBJ_PROP(zobj, prop_offset);
51117 if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) {
51118 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51119 goto fetch_obj_r_copy;
51120 } else {
51121 fetch_obj_r_fast_copy:
51122 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
51123 ZEND_VM_NEXT_OPCODE();
51124 }
51125 }
51126 } else if (EXPECTED(zobj->properties != NULL)) {
51127 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51128 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
51129 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
51130
51131 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
51132 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
51133
51134 if (EXPECTED(p->key == name) ||
51135 (EXPECTED(p->h == ZSTR_H(name)) &&
51136 EXPECTED(p->key != NULL) &&
51137 EXPECTED(zend_string_equal_content(p->key, name)))) {
51138 retval = &p->val;
51139 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51140 goto fetch_obj_r_copy;
51141 } else {
51142 goto fetch_obj_r_fast_copy;
51143 }
51144 }
51145 }
51146 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
51147 }
51148 retval = zend_hash_find_known_hash(zobj->properties, name);
51149 if (EXPECTED(retval)) {
51150 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
51151 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
51152 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51153 goto fetch_obj_r_copy;
51154 } else {
51155 goto fetch_obj_r_fast_copy;
51156 }
51157 }
51158 }
51159 }
51160 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51161 } else {
51162 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51163 if (UNEXPECTED(!name)) {
51164 ZVAL_UNDEF(EX_VAR(opline->result.var));
51165 break;
51166 }
51167 }
51168
51169 #if ZEND_DEBUG
51170 /* For non-standard object handlers, verify a declared property type in debug builds.
51171 * Fetch prop_info before calling read_property(), as it may deallocate the object. */
51172 zend_property_info *prop_info = NULL;
51173 if (zobj->handlers->read_property != zend_std_read_property) {
51174 prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true);
51175 }
51176 #endif
51177 retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var));
51178 #if ZEND_DEBUG
51179 if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO
51180 && ZEND_TYPE_IS_SET(prop_info->type)) {
51181 ZVAL_OPT_DEREF(retval);
51182 zend_verify_property_type(prop_info, retval, /* strict */ true);
51183 }
51184 #endif
51185
51186 if (IS_CV != IS_CONST) {
51187 zend_tmp_string_release(tmp_name);
51188 }
51189
51190 if (retval != EX_VAR(opline->result.var)) {
51191 fetch_obj_r_copy:
51192 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
51193 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
51194 zend_unwrap_reference(retval);
51195 }
51196 } while (0);
51197
51198 fetch_obj_r_finish:
51199
51200
51201 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51202 }
51203
ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51204 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51205 {
51206 USE_OPLINE
51207 zval *property, *container, *result;
51208
51209 SAVE_OPLINE();
51210
51211 container = EX_VAR(opline->op1.var);
51212 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51213 result = EX_VAR(opline->result.var);
51214 zend_fetch_property_address(
51215 result, container, IS_CV, property, IS_CV,
51216 ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
51217 BP_VAR_W, opline->extended_value OPLINE_CC EXECUTE_DATA_CC);
51218
51219 if (IS_CV == IS_VAR) {
51220 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51221 }
51222 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51223 }
51224
ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51225 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51226 {
51227 USE_OPLINE
51228 zval *property, *container, *result;
51229
51230 SAVE_OPLINE();
51231 container = EX_VAR(opline->op1.var);
51232 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51233 result = EX_VAR(opline->result.var);
51234 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 OPLINE_CC EXECUTE_DATA_CC);
51235
51236 if (IS_CV == IS_VAR) {
51237 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51238 }
51239 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51240 }
51241
ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51242 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51243 {
51244 USE_OPLINE
51245 zval *container;
51246 void **cache_slot = NULL;
51247
51248 SAVE_OPLINE();
51249 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
51250
51251 if (IS_CV == IS_CONST ||
51252 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
51253 do {
51254 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
51255 container = Z_REFVAL_P(container);
51256 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
51257 break;
51258 }
51259 }
51260 if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) {
51261 ZVAL_UNDEFINED_OP2();
51262 }
51263 ZVAL_NULL(EX_VAR(opline->result.var));
51264 goto fetch_obj_is_finish;
51265 } while (0);
51266 }
51267
51268 /* here we are sure we are dealing with an object */
51269 do {
51270 zend_object *zobj = Z_OBJ_P(container);
51271 zend_string *name, *tmp_name;
51272 zval *retval;
51273
51274 if (IS_CV == IS_CONST) {
51275 cache_slot = CACHE_ADDR(opline->extended_value);
51276
51277 if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
51278 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51279
51280 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51281 retval = OBJ_PROP(zobj, prop_offset);
51282 if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
51283 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51284 goto fetch_obj_is_copy;
51285 } else {
51286 fetch_obj_is_fast_copy:
51287 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
51288 ZEND_VM_NEXT_OPCODE();
51289 }
51290 }
51291 } else if (EXPECTED(zobj->properties != NULL)) {
51292 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51293 if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
51294 uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
51295
51296 if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
51297 Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
51298
51299 if (EXPECTED(p->key == name) ||
51300 (EXPECTED(p->h == ZSTR_H(name)) &&
51301 EXPECTED(p->key != NULL) &&
51302 EXPECTED(zend_string_equal_content(p->key, name)))) {
51303 retval = &p->val;
51304 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51305 goto fetch_obj_is_copy;
51306 } else {
51307 goto fetch_obj_is_fast_copy;
51308 }
51309 }
51310 }
51311 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
51312 }
51313 retval = zend_hash_find_known_hash(zobj->properties, name);
51314 if (EXPECTED(retval)) {
51315 uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
51316 CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
51317 if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
51318 goto fetch_obj_is_copy;
51319 } else {
51320 goto fetch_obj_is_fast_copy;
51321 }
51322 }
51323 }
51324 }
51325 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51326 } else {
51327 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51328 if (UNEXPECTED(!name)) {
51329 ZVAL_UNDEF(EX_VAR(opline->result.var));
51330 break;
51331 }
51332 }
51333
51334 retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
51335
51336 if (IS_CV != IS_CONST) {
51337 zend_tmp_string_release(tmp_name);
51338 }
51339
51340 if (retval != EX_VAR(opline->result.var)) {
51341 fetch_obj_is_copy:
51342 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
51343 } else if (UNEXPECTED(Z_ISREF_P(retval))) {
51344 zend_unwrap_reference(retval);
51345 }
51346 } while (0);
51347
51348 fetch_obj_is_finish:
51349
51350
51351 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51352 }
51353
ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51354 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51355 {
51356 #if 0
51357 USE_OPLINE
51358 #endif
51359
51360 if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
51361 /* Behave like FETCH_OBJ_W */
51362 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
51363 ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51364 }
51365 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51366 } else {
51367 ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
51368 }
51369 }
51370
ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51371 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51372 {
51373 USE_OPLINE
51374 zval *container, *property, *result;
51375
51376 SAVE_OPLINE();
51377 container = EX_VAR(opline->op1.var);
51378 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
51379 result = EX_VAR(opline->result.var);
51380 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 OPLINE_CC EXECUTE_DATA_CC);
51381
51382 if (IS_CV == IS_VAR) {
51383 FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var);
51384 }
51385 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
51386 }
51387
ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)51388 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51389 {
51390 USE_OPLINE
51391 zval *object, *value, tmp;
51392 zend_object *zobj;
51393 zend_string *name, *tmp_name;
51394 zend_refcounted *garbage = NULL;
51395
51396 SAVE_OPLINE();
51397 object = EX_VAR(opline->op1.var);
51398 value = RT_CONSTANT((opline+1), (opline+1)->op1);
51399
51400 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
51401 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
51402 object = Z_REFVAL_P(object);
51403 goto assign_object;
51404 }
51405 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
51406 value = &EG(uninitialized_zval);
51407 goto free_and_exit_assign_obj;
51408 }
51409
51410 assign_object:
51411 zobj = Z_OBJ_P(object);
51412 if (IS_CV == IS_CONST) {
51413 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
51414 void **cache_slot = CACHE_ADDR(opline->extended_value);
51415 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51416 zval *property_val;
51417
51418 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51419 property_val = OBJ_PROP(zobj, prop_offset);
51420 if (Z_TYPE_P(property_val) != IS_UNDEF) {
51421 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
51422
51423 if (prop_info != NULL) {
51424 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
51425 goto free_and_exit_assign_obj;
51426 } else {
51427 fast_assign_obj:
51428 value = zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
51429 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51430 ZVAL_COPY(EX_VAR(opline->result.var), value);
51431 }
51432 goto exit_assign_obj;
51433 }
51434 }
51435 } else {
51436 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51437 if (EXPECTED(zobj->properties != NULL)) {
51438 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
51439 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
51440 GC_DELREF(zobj->properties);
51441 }
51442 zobj->properties = zend_array_dup(zobj->properties);
51443 }
51444 property_val = zend_hash_find_known_hash(zobj->properties, name);
51445 if (property_val) {
51446 goto fast_assign_obj;
51447 }
51448 }
51449
51450 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
51451 if (EXPECTED(zobj->properties == NULL)) {
51452 rebuild_object_properties(zobj);
51453 }
51454 if (IS_CONST == IS_CONST) {
51455 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
51456 Z_ADDREF_P(value);
51457 }
51458 } else if (IS_CONST != IS_TMP_VAR) {
51459 if (Z_ISREF_P(value)) {
51460 if (IS_CONST == IS_VAR) {
51461 zend_reference *ref = Z_REF_P(value);
51462 if (GC_DELREF(ref) == 0) {
51463 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
51464 efree_size(ref, sizeof(zend_reference));
51465 value = &tmp;
51466 } else {
51467 value = Z_REFVAL_P(value);
51468 Z_TRY_ADDREF_P(value);
51469 }
51470 } else {
51471 value = Z_REFVAL_P(value);
51472 Z_TRY_ADDREF_P(value);
51473 }
51474 } else if (IS_CONST == IS_CV) {
51475 Z_TRY_ADDREF_P(value);
51476 }
51477 }
51478 zend_hash_add_new(zobj->properties, name, value);
51479 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51480 ZVAL_COPY(EX_VAR(opline->result.var), value);
51481 }
51482 goto exit_assign_obj;
51483 }
51484 }
51485 }
51486 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51487 } else {
51488 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51489 if (UNEXPECTED(!name)) {
51490
51491 UNDEF_RESULT();
51492 goto exit_assign_obj;
51493 }
51494 }
51495
51496 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
51497 ZVAL_DEREF(value);
51498 }
51499
51500 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
51501
51502 if (IS_CV != IS_CONST) {
51503 zend_tmp_string_release(tmp_name);
51504 }
51505
51506 free_and_exit_assign_obj:
51507 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
51508 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
51509 }
51510
51511 exit_assign_obj:
51512 if (garbage) {
51513 GC_DTOR_NO_REF(garbage);
51514 }
51515
51516
51517 /* assign_obj has two opcodes! */
51518 ZEND_VM_NEXT_OPCODE_EX(1, 2);
51519 }
51520
51521 /* 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)51522 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51523 {
51524 USE_OPLINE
51525 zval *object, *value, tmp;
51526 zend_object *zobj;
51527 zend_string *name, *tmp_name;
51528 zend_refcounted *garbage = NULL;
51529
51530 SAVE_OPLINE();
51531 object = EX_VAR(opline->op1.var);
51532 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
51533
51534 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
51535 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
51536 object = Z_REFVAL_P(object);
51537 goto assign_object;
51538 }
51539 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
51540 value = &EG(uninitialized_zval);
51541 goto free_and_exit_assign_obj;
51542 }
51543
51544 assign_object:
51545 zobj = Z_OBJ_P(object);
51546 if (IS_CV == IS_CONST) {
51547 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
51548 void **cache_slot = CACHE_ADDR(opline->extended_value);
51549 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51550 zval *property_val;
51551
51552 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51553 property_val = OBJ_PROP(zobj, prop_offset);
51554 if (Z_TYPE_P(property_val) != IS_UNDEF) {
51555 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
51556
51557 if (prop_info != NULL) {
51558 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
51559 goto free_and_exit_assign_obj;
51560 } else {
51561 fast_assign_obj:
51562 value = zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
51563 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51564 ZVAL_COPY(EX_VAR(opline->result.var), value);
51565 }
51566 goto exit_assign_obj;
51567 }
51568 }
51569 } else {
51570 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51571 if (EXPECTED(zobj->properties != NULL)) {
51572 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
51573 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
51574 GC_DELREF(zobj->properties);
51575 }
51576 zobj->properties = zend_array_dup(zobj->properties);
51577 }
51578 property_val = zend_hash_find_known_hash(zobj->properties, name);
51579 if (property_val) {
51580 goto fast_assign_obj;
51581 }
51582 }
51583
51584 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
51585 if (EXPECTED(zobj->properties == NULL)) {
51586 rebuild_object_properties(zobj);
51587 }
51588 if (IS_TMP_VAR == IS_CONST) {
51589 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
51590 Z_ADDREF_P(value);
51591 }
51592 } else if (IS_TMP_VAR != IS_TMP_VAR) {
51593 if (Z_ISREF_P(value)) {
51594 if (IS_TMP_VAR == IS_VAR) {
51595 zend_reference *ref = Z_REF_P(value);
51596 if (GC_DELREF(ref) == 0) {
51597 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
51598 efree_size(ref, sizeof(zend_reference));
51599 value = &tmp;
51600 } else {
51601 value = Z_REFVAL_P(value);
51602 Z_TRY_ADDREF_P(value);
51603 }
51604 } else {
51605 value = Z_REFVAL_P(value);
51606 Z_TRY_ADDREF_P(value);
51607 }
51608 } else if (IS_TMP_VAR == IS_CV) {
51609 Z_TRY_ADDREF_P(value);
51610 }
51611 }
51612 zend_hash_add_new(zobj->properties, name, value);
51613 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51614 ZVAL_COPY(EX_VAR(opline->result.var), value);
51615 }
51616 goto exit_assign_obj;
51617 }
51618 }
51619 }
51620 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51621 } else {
51622 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51623 if (UNEXPECTED(!name)) {
51624 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
51625 UNDEF_RESULT();
51626 goto exit_assign_obj;
51627 }
51628 }
51629
51630 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
51631 ZVAL_DEREF(value);
51632 }
51633
51634 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
51635
51636 if (IS_CV != IS_CONST) {
51637 zend_tmp_string_release(tmp_name);
51638 }
51639
51640 free_and_exit_assign_obj:
51641 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
51642 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
51643 }
51644 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
51645 exit_assign_obj:
51646 if (garbage) {
51647 GC_DTOR_NO_REF(garbage);
51648 }
51649
51650
51651 /* assign_obj has two opcodes! */
51652 ZEND_VM_NEXT_OPCODE_EX(1, 2);
51653 }
51654
51655 /* 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)51656 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51657 {
51658 USE_OPLINE
51659 zval *object, *value, tmp;
51660 zend_object *zobj;
51661 zend_string *name, *tmp_name;
51662 zend_refcounted *garbage = NULL;
51663
51664 SAVE_OPLINE();
51665 object = EX_VAR(opline->op1.var);
51666 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
51667
51668 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
51669 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
51670 object = Z_REFVAL_P(object);
51671 goto assign_object;
51672 }
51673 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
51674 value = &EG(uninitialized_zval);
51675 goto free_and_exit_assign_obj;
51676 }
51677
51678 assign_object:
51679 zobj = Z_OBJ_P(object);
51680 if (IS_CV == IS_CONST) {
51681 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
51682 void **cache_slot = CACHE_ADDR(opline->extended_value);
51683 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51684 zval *property_val;
51685
51686 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51687 property_val = OBJ_PROP(zobj, prop_offset);
51688 if (Z_TYPE_P(property_val) != IS_UNDEF) {
51689 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
51690
51691 if (prop_info != NULL) {
51692 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
51693 goto free_and_exit_assign_obj;
51694 } else {
51695 fast_assign_obj:
51696 value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
51697 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51698 ZVAL_COPY(EX_VAR(opline->result.var), value);
51699 }
51700 goto exit_assign_obj;
51701 }
51702 }
51703 } else {
51704 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51705 if (EXPECTED(zobj->properties != NULL)) {
51706 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
51707 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
51708 GC_DELREF(zobj->properties);
51709 }
51710 zobj->properties = zend_array_dup(zobj->properties);
51711 }
51712 property_val = zend_hash_find_known_hash(zobj->properties, name);
51713 if (property_val) {
51714 goto fast_assign_obj;
51715 }
51716 }
51717
51718 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
51719 if (EXPECTED(zobj->properties == NULL)) {
51720 rebuild_object_properties(zobj);
51721 }
51722 if (IS_VAR == IS_CONST) {
51723 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
51724 Z_ADDREF_P(value);
51725 }
51726 } else if (IS_VAR != IS_TMP_VAR) {
51727 if (Z_ISREF_P(value)) {
51728 if (IS_VAR == IS_VAR) {
51729 zend_reference *ref = Z_REF_P(value);
51730 if (GC_DELREF(ref) == 0) {
51731 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
51732 efree_size(ref, sizeof(zend_reference));
51733 value = &tmp;
51734 } else {
51735 value = Z_REFVAL_P(value);
51736 Z_TRY_ADDREF_P(value);
51737 }
51738 } else {
51739 value = Z_REFVAL_P(value);
51740 Z_TRY_ADDREF_P(value);
51741 }
51742 } else if (IS_VAR == IS_CV) {
51743 Z_TRY_ADDREF_P(value);
51744 }
51745 }
51746 zend_hash_add_new(zobj->properties, name, value);
51747 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51748 ZVAL_COPY(EX_VAR(opline->result.var), value);
51749 }
51750 goto exit_assign_obj;
51751 }
51752 }
51753 }
51754 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51755 } else {
51756 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51757 if (UNEXPECTED(!name)) {
51758 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
51759 UNDEF_RESULT();
51760 goto exit_assign_obj;
51761 }
51762 }
51763
51764 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
51765 ZVAL_DEREF(value);
51766 }
51767
51768 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
51769
51770 if (IS_CV != IS_CONST) {
51771 zend_tmp_string_release(tmp_name);
51772 }
51773
51774 free_and_exit_assign_obj:
51775 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
51776 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
51777 }
51778 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
51779 exit_assign_obj:
51780 if (garbage) {
51781 GC_DTOR_NO_REF(garbage);
51782 }
51783
51784
51785 /* assign_obj has two opcodes! */
51786 ZEND_VM_NEXT_OPCODE_EX(1, 2);
51787 }
51788
51789 /* 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)51790 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51791 {
51792 USE_OPLINE
51793 zval *object, *value, tmp;
51794 zend_object *zobj;
51795 zend_string *name, *tmp_name;
51796 zend_refcounted *garbage = NULL;
51797
51798 SAVE_OPLINE();
51799 object = EX_VAR(opline->op1.var);
51800 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
51801
51802 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
51803 if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
51804 object = Z_REFVAL_P(object);
51805 goto assign_object;
51806 }
51807 zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC);
51808 value = &EG(uninitialized_zval);
51809 goto free_and_exit_assign_obj;
51810 }
51811
51812 assign_object:
51813 zobj = Z_OBJ_P(object);
51814 if (IS_CV == IS_CONST) {
51815 if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) {
51816 void **cache_slot = CACHE_ADDR(opline->extended_value);
51817 uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
51818 zval *property_val;
51819
51820 if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
51821 property_val = OBJ_PROP(zobj, prop_offset);
51822 if (Z_TYPE_P(property_val) != IS_UNDEF) {
51823 zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
51824
51825 if (prop_info != NULL) {
51826 value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC);
51827 goto free_and_exit_assign_obj;
51828 } else {
51829 fast_assign_obj:
51830 value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
51831 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51832 ZVAL_COPY(EX_VAR(opline->result.var), value);
51833 }
51834 goto exit_assign_obj;
51835 }
51836 }
51837 } else {
51838 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51839 if (EXPECTED(zobj->properties != NULL)) {
51840 if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
51841 if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
51842 GC_DELREF(zobj->properties);
51843 }
51844 zobj->properties = zend_array_dup(zobj->properties);
51845 }
51846 property_val = zend_hash_find_known_hash(zobj->properties, name);
51847 if (property_val) {
51848 goto fast_assign_obj;
51849 }
51850 }
51851
51852 if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) {
51853 if (EXPECTED(zobj->properties == NULL)) {
51854 rebuild_object_properties(zobj);
51855 }
51856 if (IS_CV == IS_CONST) {
51857 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
51858 Z_ADDREF_P(value);
51859 }
51860 } else if (IS_CV != IS_TMP_VAR) {
51861 if (Z_ISREF_P(value)) {
51862 if (IS_CV == IS_VAR) {
51863 zend_reference *ref = Z_REF_P(value);
51864 if (GC_DELREF(ref) == 0) {
51865 ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
51866 efree_size(ref, sizeof(zend_reference));
51867 value = &tmp;
51868 } else {
51869 value = Z_REFVAL_P(value);
51870 Z_TRY_ADDREF_P(value);
51871 }
51872 } else {
51873 value = Z_REFVAL_P(value);
51874 Z_TRY_ADDREF_P(value);
51875 }
51876 } else if (IS_CV == IS_CV) {
51877 Z_TRY_ADDREF_P(value);
51878 }
51879 }
51880 zend_hash_add_new(zobj->properties, name, value);
51881 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51882 ZVAL_COPY(EX_VAR(opline->result.var), value);
51883 }
51884 goto exit_assign_obj;
51885 }
51886 }
51887 }
51888 name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC));
51889 } else {
51890 name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name);
51891 if (UNEXPECTED(!name)) {
51892
51893 UNDEF_RESULT();
51894 goto exit_assign_obj;
51895 }
51896 }
51897
51898 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
51899 ZVAL_DEREF(value);
51900 }
51901
51902 value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
51903
51904 if (IS_CV != IS_CONST) {
51905 zend_tmp_string_release(tmp_name);
51906 }
51907
51908 free_and_exit_assign_obj:
51909 if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) {
51910 ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value);
51911 }
51912
51913 exit_assign_obj:
51914 if (garbage) {
51915 GC_DTOR_NO_REF(garbage);
51916 }
51917
51918
51919 /* assign_obj has two opcodes! */
51920 ZEND_VM_NEXT_OPCODE_EX(1, 2);
51921 }
51922
51923 /* 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)51924 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
51925 {
51926 USE_OPLINE
51927 zval *object_ptr, *orig_object_ptr;
51928 zval *value;
51929 zval *variable_ptr;
51930 zval *dim;
51931 zend_refcounted *garbage = NULL;
51932
51933 SAVE_OPLINE();
51934 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
51935
51936 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
51937 try_assign_dim_array:
51938 SEPARATE_ARRAY(object_ptr);
51939 if (IS_CV == IS_UNUSED) {
51940 value = RT_CONSTANT((opline+1), (opline+1)->op1);
51941 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
51942 HashTable *ht = Z_ARRVAL_P(object_ptr);
51943 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
51944 GC_ADDREF(ht);
51945 }
51946 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
51947 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
51948 zend_array_destroy(ht);
51949 goto assign_dim_error;
51950 }
51951 }
51952 if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
51953 ZVAL_DEREF(value);
51954 }
51955 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
51956 if (UNEXPECTED(value == NULL)) {
51957 zend_cannot_add_element();
51958 goto assign_dim_error;
51959 } else if (IS_CONST == IS_CV) {
51960 if (Z_REFCOUNTED_P(value)) {
51961 Z_ADDREF_P(value);
51962 }
51963 } else if (IS_CONST == IS_VAR) {
51964 zval *free_op_data = EX_VAR((opline+1)->op1.var);
51965 if (Z_ISREF_P(free_op_data)) {
51966 if (Z_REFCOUNTED_P(value)) {
51967 Z_ADDREF_P(value);
51968 }
51969 zval_ptr_dtor_nogc(free_op_data);
51970 }
51971 } else if (IS_CONST == IS_CONST) {
51972 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
51973 Z_ADDREF_P(value);
51974 }
51975 }
51976 } else {
51977 dim = EX_VAR(opline->op2.var);
51978 if (IS_CV == IS_CONST) {
51979 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
51980 } else {
51981 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
51982 }
51983 if (UNEXPECTED(variable_ptr == NULL)) {
51984 goto assign_dim_error;
51985 }
51986 value = RT_CONSTANT((opline+1), (opline+1)->op1);
51987 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage);
51988 }
51989 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
51990 ZVAL_COPY(EX_VAR(opline->result.var), value);
51991 }
51992 if (garbage) {
51993 GC_DTOR_NO_REF(garbage);
51994 }
51995 } else {
51996 if (EXPECTED(Z_ISREF_P(object_ptr))) {
51997 object_ptr = Z_REFVAL_P(object_ptr);
51998 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
51999 goto try_assign_dim_array;
52000 }
52001 }
52002 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
52003 zend_object *obj = Z_OBJ_P(object_ptr);
52004
52005 GC_ADDREF(obj);
52006 dim = EX_VAR(opline->op2.var);
52007 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
52008 dim = ZVAL_UNDEFINED_OP2();
52009 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52010 dim++;
52011 }
52012
52013 value = RT_CONSTANT((opline+1), (opline+1)->op1);
52014 if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
52015 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52016 } else if (IS_CONST & (IS_CV|IS_VAR)) {
52017 ZVAL_DEREF(value);
52018 }
52019
52020 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
52021
52022 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
52023 zend_objects_store_del(obj);
52024 }
52025 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
52026 if (IS_CV == IS_UNUSED) {
52027 zend_use_new_element_for_string();
52028
52029 UNDEF_RESULT();
52030 } else {
52031 dim = EX_VAR(opline->op2.var);
52032 value = RT_CONSTANT((opline+1), (opline+1)->op1);
52033 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
52034
52035 }
52036 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
52037 if (Z_ISREF_P(orig_object_ptr)
52038 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
52039 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
52040 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52041
52042 UNDEF_RESULT();
52043 } else {
52044 HashTable *ht = zend_new_array(8);
52045 uint8_t old_type = Z_TYPE_P(object_ptr);
52046
52047 ZVAL_ARR(object_ptr, ht);
52048 if (UNEXPECTED(old_type == IS_FALSE)) {
52049 GC_ADDREF(ht);
52050 zend_false_to_array_deprecated();
52051 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52052 zend_array_destroy(ht);
52053 goto assign_dim_error;
52054 }
52055 }
52056 goto try_assign_dim_array;
52057 }
52058 } else {
52059 zend_use_scalar_as_array();
52060 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52061 assign_dim_error:
52062
52063 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52064 ZVAL_NULL(EX_VAR(opline->result.var));
52065 }
52066 }
52067 }
52068 if (IS_CV != IS_UNUSED) {
52069
52070 }
52071
52072 /* assign_dim has two opcodes! */
52073 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52074 }
52075
ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52076 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52077 {
52078 USE_OPLINE
52079 zval *object_ptr, *orig_object_ptr;
52080 zval *value;
52081 zval *variable_ptr;
52082 zval *dim;
52083 zend_refcounted *garbage = NULL;
52084
52085 SAVE_OPLINE();
52086 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
52087
52088 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52089 try_assign_dim_array:
52090 SEPARATE_ARRAY(object_ptr);
52091 if (IS_CV == IS_UNUSED) {
52092 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
52093 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
52094 HashTable *ht = Z_ARRVAL_P(object_ptr);
52095 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
52096 GC_ADDREF(ht);
52097 }
52098 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52099 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
52100 zend_array_destroy(ht);
52101 goto assign_dim_error;
52102 }
52103 }
52104 if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
52105 ZVAL_DEREF(value);
52106 }
52107 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
52108 if (UNEXPECTED(value == NULL)) {
52109 zend_cannot_add_element();
52110 goto assign_dim_error;
52111 } else if (IS_TMP_VAR == IS_CV) {
52112 if (Z_REFCOUNTED_P(value)) {
52113 Z_ADDREF_P(value);
52114 }
52115 } else if (IS_TMP_VAR == IS_VAR) {
52116 zval *free_op_data = EX_VAR((opline+1)->op1.var);
52117 if (Z_ISREF_P(free_op_data)) {
52118 if (Z_REFCOUNTED_P(value)) {
52119 Z_ADDREF_P(value);
52120 }
52121 zval_ptr_dtor_nogc(free_op_data);
52122 }
52123 } else if (IS_TMP_VAR == IS_CONST) {
52124 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
52125 Z_ADDREF_P(value);
52126 }
52127 }
52128 } else {
52129 dim = EX_VAR(opline->op2.var);
52130 if (IS_CV == IS_CONST) {
52131 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52132 } else {
52133 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52134 }
52135 if (UNEXPECTED(variable_ptr == NULL)) {
52136 goto assign_dim_error;
52137 }
52138 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
52139 value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage);
52140 }
52141 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52142 ZVAL_COPY(EX_VAR(opline->result.var), value);
52143 }
52144 if (garbage) {
52145 GC_DTOR_NO_REF(garbage);
52146 }
52147 } else {
52148 if (EXPECTED(Z_ISREF_P(object_ptr))) {
52149 object_ptr = Z_REFVAL_P(object_ptr);
52150 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52151 goto try_assign_dim_array;
52152 }
52153 }
52154 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
52155 zend_object *obj = Z_OBJ_P(object_ptr);
52156
52157 GC_ADDREF(obj);
52158 dim = EX_VAR(opline->op2.var);
52159 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
52160 dim = ZVAL_UNDEFINED_OP2();
52161 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52162 dim++;
52163 }
52164
52165 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
52166 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
52167 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52168 } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) {
52169 ZVAL_DEREF(value);
52170 }
52171
52172 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
52173
52174 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52175 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
52176 zend_objects_store_del(obj);
52177 }
52178 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
52179 if (IS_CV == IS_UNUSED) {
52180 zend_use_new_element_for_string();
52181 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52182 UNDEF_RESULT();
52183 } else {
52184 dim = EX_VAR(opline->op2.var);
52185 value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC);
52186 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
52187 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52188 }
52189 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
52190 if (Z_ISREF_P(orig_object_ptr)
52191 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
52192 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
52193 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52194 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52195 UNDEF_RESULT();
52196 } else {
52197 HashTable *ht = zend_new_array(8);
52198 uint8_t old_type = Z_TYPE_P(object_ptr);
52199
52200 ZVAL_ARR(object_ptr, ht);
52201 if (UNEXPECTED(old_type == IS_FALSE)) {
52202 GC_ADDREF(ht);
52203 zend_false_to_array_deprecated();
52204 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52205 zend_array_destroy(ht);
52206 goto assign_dim_error;
52207 }
52208 }
52209 goto try_assign_dim_array;
52210 }
52211 } else {
52212 zend_use_scalar_as_array();
52213 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52214 assign_dim_error:
52215 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52216 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52217 ZVAL_NULL(EX_VAR(opline->result.var));
52218 }
52219 }
52220 }
52221 if (IS_CV != IS_UNUSED) {
52222
52223 }
52224
52225 /* assign_dim has two opcodes! */
52226 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52227 }
52228
ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52229 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52230 {
52231 USE_OPLINE
52232 zval *object_ptr, *orig_object_ptr;
52233 zval *value;
52234 zval *variable_ptr;
52235 zval *dim;
52236 zend_refcounted *garbage = NULL;
52237
52238 SAVE_OPLINE();
52239 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
52240
52241 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52242 try_assign_dim_array:
52243 SEPARATE_ARRAY(object_ptr);
52244 if (IS_CV == IS_UNUSED) {
52245 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
52246 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
52247 HashTable *ht = Z_ARRVAL_P(object_ptr);
52248 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
52249 GC_ADDREF(ht);
52250 }
52251 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52252 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
52253 zend_array_destroy(ht);
52254 goto assign_dim_error;
52255 }
52256 }
52257 if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
52258 ZVAL_DEREF(value);
52259 }
52260 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
52261 if (UNEXPECTED(value == NULL)) {
52262 zend_cannot_add_element();
52263 goto assign_dim_error;
52264 } else if (IS_VAR == IS_CV) {
52265 if (Z_REFCOUNTED_P(value)) {
52266 Z_ADDREF_P(value);
52267 }
52268 } else if (IS_VAR == IS_VAR) {
52269 zval *free_op_data = EX_VAR((opline+1)->op1.var);
52270 if (Z_ISREF_P(free_op_data)) {
52271 if (Z_REFCOUNTED_P(value)) {
52272 Z_ADDREF_P(value);
52273 }
52274 zval_ptr_dtor_nogc(free_op_data);
52275 }
52276 } else if (IS_VAR == IS_CONST) {
52277 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
52278 Z_ADDREF_P(value);
52279 }
52280 }
52281 } else {
52282 dim = EX_VAR(opline->op2.var);
52283 if (IS_CV == IS_CONST) {
52284 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52285 } else {
52286 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52287 }
52288 if (UNEXPECTED(variable_ptr == NULL)) {
52289 goto assign_dim_error;
52290 }
52291 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
52292 value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage);
52293 }
52294 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52295 ZVAL_COPY(EX_VAR(opline->result.var), value);
52296 }
52297 if (garbage) {
52298 GC_DTOR_NO_REF(garbage);
52299 }
52300 } else {
52301 if (EXPECTED(Z_ISREF_P(object_ptr))) {
52302 object_ptr = Z_REFVAL_P(object_ptr);
52303 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52304 goto try_assign_dim_array;
52305 }
52306 }
52307 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
52308 zend_object *obj = Z_OBJ_P(object_ptr);
52309
52310 GC_ADDREF(obj);
52311 dim = EX_VAR(opline->op2.var);
52312 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
52313 dim = ZVAL_UNDEFINED_OP2();
52314 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52315 dim++;
52316 }
52317
52318 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
52319 if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
52320 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52321 } else if (IS_VAR & (IS_CV|IS_VAR)) {
52322 ZVAL_DEREF(value);
52323 }
52324
52325 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
52326
52327 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52328 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
52329 zend_objects_store_del(obj);
52330 }
52331 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
52332 if (IS_CV == IS_UNUSED) {
52333 zend_use_new_element_for_string();
52334 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52335 UNDEF_RESULT();
52336 } else {
52337 dim = EX_VAR(opline->op2.var);
52338 value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
52339 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
52340 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52341 }
52342 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
52343 if (Z_ISREF_P(orig_object_ptr)
52344 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
52345 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
52346 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52347 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52348 UNDEF_RESULT();
52349 } else {
52350 HashTable *ht = zend_new_array(8);
52351 uint8_t old_type = Z_TYPE_P(object_ptr);
52352
52353 ZVAL_ARR(object_ptr, ht);
52354 if (UNEXPECTED(old_type == IS_FALSE)) {
52355 GC_ADDREF(ht);
52356 zend_false_to_array_deprecated();
52357 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52358 zend_array_destroy(ht);
52359 goto assign_dim_error;
52360 }
52361 }
52362 goto try_assign_dim_array;
52363 }
52364 } else {
52365 zend_use_scalar_as_array();
52366 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52367 assign_dim_error:
52368 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52369 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52370 ZVAL_NULL(EX_VAR(opline->result.var));
52371 }
52372 }
52373 }
52374 if (IS_CV != IS_UNUSED) {
52375
52376 }
52377
52378 /* assign_dim has two opcodes! */
52379 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52380 }
52381
ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52382 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52383 {
52384 USE_OPLINE
52385 zval *object_ptr, *orig_object_ptr;
52386 zval *value;
52387 zval *variable_ptr;
52388 zval *dim;
52389 zend_refcounted *garbage = NULL;
52390
52391 SAVE_OPLINE();
52392 orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
52393
52394 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52395 try_assign_dim_array:
52396 SEPARATE_ARRAY(object_ptr);
52397 if (IS_CV == IS_UNUSED) {
52398 value = EX_VAR((opline+1)->op1.var);
52399 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) {
52400 HashTable *ht = Z_ARRVAL_P(object_ptr);
52401 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) {
52402 GC_ADDREF(ht);
52403 }
52404 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52405 if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) {
52406 zend_array_destroy(ht);
52407 goto assign_dim_error;
52408 }
52409 }
52410 if (IS_CV == IS_CV || IS_CV == IS_VAR) {
52411 ZVAL_DEREF(value);
52412 }
52413 value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value);
52414 if (UNEXPECTED(value == NULL)) {
52415 zend_cannot_add_element();
52416 goto assign_dim_error;
52417 } else if (IS_CV == IS_CV) {
52418 if (Z_REFCOUNTED_P(value)) {
52419 Z_ADDREF_P(value);
52420 }
52421 } else if (IS_CV == IS_VAR) {
52422 zval *free_op_data = EX_VAR((opline+1)->op1.var);
52423 if (Z_ISREF_P(free_op_data)) {
52424 if (Z_REFCOUNTED_P(value)) {
52425 Z_ADDREF_P(value);
52426 }
52427 zval_ptr_dtor_nogc(free_op_data);
52428 }
52429 } else if (IS_CV == IS_CONST) {
52430 if (UNEXPECTED(Z_REFCOUNTED_P(value))) {
52431 Z_ADDREF_P(value);
52432 }
52433 }
52434 } else {
52435 dim = EX_VAR(opline->op2.var);
52436 if (IS_CV == IS_CONST) {
52437 variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52438 } else {
52439 variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC);
52440 }
52441 if (UNEXPECTED(variable_ptr == NULL)) {
52442 goto assign_dim_error;
52443 }
52444 value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
52445 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
52446 }
52447 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52448 ZVAL_COPY(EX_VAR(opline->result.var), value);
52449 }
52450 if (garbage) {
52451 GC_DTOR_NO_REF(garbage);
52452 }
52453 } else {
52454 if (EXPECTED(Z_ISREF_P(object_ptr))) {
52455 object_ptr = Z_REFVAL_P(object_ptr);
52456 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
52457 goto try_assign_dim_array;
52458 }
52459 }
52460 if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) {
52461 zend_object *obj = Z_OBJ_P(object_ptr);
52462
52463 GC_ADDREF(obj);
52464 dim = EX_VAR(opline->op2.var);
52465 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) {
52466 dim = ZVAL_UNDEFINED_OP2();
52467 } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
52468 dim++;
52469 }
52470
52471 value = EX_VAR((opline+1)->op1.var);
52472 if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) {
52473 value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC);
52474 } else if (IS_CV & (IS_CV|IS_VAR)) {
52475 ZVAL_DEREF(value);
52476 }
52477
52478 zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC);
52479
52480 if (UNEXPECTED(GC_DELREF(obj) == 0)) {
52481 zend_objects_store_del(obj);
52482 }
52483 } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) {
52484 if (IS_CV == IS_UNUSED) {
52485 zend_use_new_element_for_string();
52486
52487 UNDEF_RESULT();
52488 } else {
52489 dim = EX_VAR(opline->op2.var);
52490 value = EX_VAR((opline+1)->op1.var);
52491 zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC);
52492
52493 }
52494 } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
52495 if (Z_ISREF_P(orig_object_ptr)
52496 && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr))
52497 && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) {
52498 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52499
52500 UNDEF_RESULT();
52501 } else {
52502 HashTable *ht = zend_new_array(8);
52503 uint8_t old_type = Z_TYPE_P(object_ptr);
52504
52505 ZVAL_ARR(object_ptr, ht);
52506 if (UNEXPECTED(old_type == IS_FALSE)) {
52507 GC_ADDREF(ht);
52508 zend_false_to_array_deprecated();
52509 if (UNEXPECTED(GC_DELREF(ht) == 0)) {
52510 zend_array_destroy(ht);
52511 goto assign_dim_error;
52512 }
52513 }
52514 goto try_assign_dim_array;
52515 }
52516 } else {
52517 zend_use_scalar_as_array();
52518 dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52519 assign_dim_error:
52520
52521 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52522 ZVAL_NULL(EX_VAR(opline->result.var));
52523 }
52524 }
52525 }
52526 if (IS_CV != IS_UNUSED) {
52527
52528 }
52529
52530 /* assign_dim has two opcodes! */
52531 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52532 }
52533
ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52534 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52535 {
52536 USE_OPLINE
52537 zval *value;
52538 zval *variable_ptr;
52539
52540 SAVE_OPLINE();
52541 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52542 variable_ptr = EX_VAR(opline->op1.var);
52543
52544 if (0 || UNEXPECTED(0)) {
52545 zend_refcounted *garbage = NULL;
52546
52547 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
52548 if (UNEXPECTED(0)) {
52549 ZVAL_COPY(EX_VAR(opline->result.var), value);
52550 }
52551 if (garbage) {
52552 GC_DTOR_NO_REF(garbage);
52553 }
52554 } else {
52555 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
52556 }
52557
52558 /* zend_assign_to_variable() always takes care of op2, never free it! */
52559
52560 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52561 }
52562
ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52563 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52564 {
52565 USE_OPLINE
52566 zval *value;
52567 zval *variable_ptr;
52568
52569 SAVE_OPLINE();
52570 value = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52571 variable_ptr = EX_VAR(opline->op1.var);
52572
52573 if (0 || UNEXPECTED(1)) {
52574 zend_refcounted *garbage = NULL;
52575
52576 value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage);
52577 if (UNEXPECTED(1)) {
52578 ZVAL_COPY(EX_VAR(opline->result.var), value);
52579 }
52580 if (garbage) {
52581 GC_DTOR_NO_REF(garbage);
52582 }
52583 } else {
52584 value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
52585 }
52586
52587 /* zend_assign_to_variable() always takes care of op2, never free it! */
52588
52589 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52590 }
52591
ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52592 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52593 {
52594 USE_OPLINE
52595 zval *variable_ptr;
52596 zval *value_ptr;
52597 zend_refcounted *garbage = NULL;
52598
52599 SAVE_OPLINE();
52600 value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op2.var EXECUTE_DATA_CC);
52601 variable_ptr = EX_VAR(opline->op1.var);
52602
52603 if (IS_CV == IS_VAR &&
52604 UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
52605
52606 zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
52607 variable_ptr = &EG(uninitialized_zval);
52608 } else if (IS_CV == IS_VAR &&
52609 opline->extended_value == ZEND_RETURNS_FUNCTION &&
52610 UNEXPECTED(!Z_ISREF_P(value_ptr))) {
52611
52612 variable_ptr = zend_wrong_assign_to_variable_reference(
52613 variable_ptr, value_ptr, &garbage OPLINE_CC EXECUTE_DATA_CC);
52614 } else {
52615 zend_assign_to_variable_reference(variable_ptr, value_ptr, &garbage);
52616 }
52617
52618 if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
52619 ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
52620 }
52621
52622 if (garbage) {
52623 GC_DTOR(garbage);
52624 }
52625
52626
52627 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52628 }
52629
ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52630 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52631 {
52632 USE_OPLINE
52633 zval *property, *container, *value_ptr;
52634
52635 SAVE_OPLINE();
52636
52637 container = EX_VAR(opline->op1.var);
52638 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52639
52640 value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC);
52641
52642 if (1) {
52643 if (IS_CV == IS_UNUSED) {
52644 if (IS_CV == IS_CONST) {
52645 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52646 } else {
52647 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52648 }
52649 } else {
52650 if (IS_CV == IS_CONST) {
52651 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52652 } else {
52653 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52654 }
52655 }
52656 } else {
52657 zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52658 }
52659
52660
52661 zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
52662 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52663 }
52664
52665 /* 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)52666 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52667 {
52668 USE_OPLINE
52669 zval *property, *container, *value_ptr;
52670
52671 SAVE_OPLINE();
52672
52673 container = EX_VAR(opline->op1.var);
52674 property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
52675
52676 value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
52677
52678 if (1) {
52679 if (IS_CV == IS_UNUSED) {
52680 if (IS_CV == IS_CONST) {
52681 zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52682 } else {
52683 zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52684 }
52685 } else {
52686 if (IS_CV == IS_CONST) {
52687 zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52688 } else {
52689 zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52690 }
52691 }
52692 } else {
52693 zend_assign_to_property_reference(container, IS_CV, property, IS_CV, value_ptr OPLINE_CC EXECUTE_DATA_CC);
52694 }
52695
52696
52697
52698 ZEND_VM_NEXT_OPCODE_EX(1, 2);
52699 }
52700
52701 /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52702 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52703 {
52704 USE_OPLINE
52705 zval *op1, *op2;
52706 zend_string *op1_str, *op2_str, *str;
52707
52708
52709 op1 = EX_VAR(opline->op1.var);
52710 op2 = EX_VAR(opline->op2.var);
52711 if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
52712 (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
52713 zend_string *op1_str = Z_STR_P(op1);
52714 zend_string *op2_str = Z_STR_P(op2);
52715 zend_string *str;
52716 uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str);
52717
52718 if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
52719 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
52720 ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
52721 } else {
52722 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
52723 }
52724 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52725 zend_string_release_ex(op1_str, 0);
52726 }
52727 } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
52728 if (IS_CV == IS_CONST || IS_CV == IS_CV) {
52729 ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
52730 } else {
52731 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
52732 }
52733 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52734 zend_string_release_ex(op2_str, 0);
52735 }
52736 } else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
52737 !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
52738 size_t len = ZSTR_LEN(op1_str);
52739
52740 str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
52741 memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
52742 GC_ADD_FLAGS(str, flags);
52743 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
52744 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52745 zend_string_release_ex(op2_str, 0);
52746 }
52747 } else {
52748 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
52749 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
52750 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
52751 GC_ADD_FLAGS(str, flags);
52752 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
52753 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52754 zend_string_release_ex(op1_str, 0);
52755 }
52756 if (IS_CV & (IS_TMP_VAR|IS_VAR)) {
52757 zend_string_release_ex(op2_str, 0);
52758 }
52759 }
52760 ZEND_VM_NEXT_OPCODE();
52761 }
52762
52763 SAVE_OPLINE();
52764 if (IS_CV == IS_CONST) {
52765 op1_str = Z_STR_P(op1);
52766 } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
52767 op1_str = zend_string_copy(Z_STR_P(op1));
52768 } else {
52769 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
52770 ZVAL_UNDEFINED_OP1();
52771 }
52772 op1_str = zval_get_string_func(op1);
52773 }
52774 if (IS_CV == IS_CONST) {
52775 op2_str = Z_STR_P(op2);
52776 } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
52777 op2_str = zend_string_copy(Z_STR_P(op2));
52778 } else {
52779 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
52780 ZVAL_UNDEFINED_OP2();
52781 }
52782 op2_str = zval_get_string_func(op2);
52783 }
52784 do {
52785 if (IS_CV != IS_CONST) {
52786 if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
52787 if (IS_CV == IS_CONST) {
52788 if (UNEXPECTED(Z_REFCOUNTED_P(op2))) {
52789 GC_ADDREF(op2_str);
52790 }
52791 }
52792 ZVAL_STR(EX_VAR(opline->result.var), op2_str);
52793 zend_string_release_ex(op1_str, 0);
52794 break;
52795 }
52796 }
52797 if (IS_CV != IS_CONST) {
52798 if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
52799 if (IS_CV == IS_CONST) {
52800 if (UNEXPECTED(Z_REFCOUNTED_P(op1))) {
52801 GC_ADDREF(op1_str);
52802 }
52803 }
52804 ZVAL_STR(EX_VAR(opline->result.var), op1_str);
52805 zend_string_release_ex(op2_str, 0);
52806 break;
52807 }
52808 }
52809 str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
52810 memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
52811 memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
52812
52813 ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str);
52814 ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
52815 if (IS_CV != IS_CONST) {
52816 zend_string_release_ex(op1_str, 0);
52817 }
52818 if (IS_CV != IS_CONST) {
52819 zend_string_release_ex(op2_str, 0);
52820 }
52821 } while (0);
52822
52823
52824 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
52825 }
52826
ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52827 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52828 {
52829 USE_OPLINE
52830 zval *function_name;
52831 zval *object;
52832 zend_function *fbc;
52833 zend_class_entry *called_scope;
52834 zend_object *obj;
52835 zend_execute_data *call;
52836 uint32_t call_info;
52837
52838 SAVE_OPLINE();
52839
52840 object = EX_VAR(opline->op1.var);
52841
52842 if (IS_CV != IS_CONST) {
52843 function_name = EX_VAR(opline->op2.var);
52844 }
52845
52846 if (IS_CV != IS_CONST &&
52847 UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
52848 do {
52849 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) {
52850 function_name = Z_REFVAL_P(function_name);
52851 if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
52852 break;
52853 }
52854 } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) {
52855 ZVAL_UNDEFINED_OP2();
52856 if (UNEXPECTED(EG(exception) != NULL)) {
52857
52858 HANDLE_EXCEPTION();
52859 }
52860 }
52861 zend_throw_error(NULL, "Method name must be a string");
52862
52863
52864 HANDLE_EXCEPTION();
52865 } while (0);
52866 }
52867
52868 if (IS_CV == IS_UNUSED) {
52869 obj = Z_OBJ_P(object);
52870 } else {
52871 do {
52872 if (IS_CV != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
52873 obj = Z_OBJ_P(object);
52874 } else {
52875 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) {
52876 zend_reference *ref = Z_REF_P(object);
52877
52878 object = &ref->val;
52879 if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
52880 obj = Z_OBJ_P(object);
52881 if (IS_CV & IS_VAR) {
52882 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
52883 efree_size(ref, sizeof(zend_reference));
52884 } else {
52885 Z_ADDREF_P(object);
52886 }
52887 }
52888 break;
52889 }
52890 }
52891 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
52892 object = ZVAL_UNDEFINED_OP1();
52893 if (UNEXPECTED(EG(exception) != NULL)) {
52894 if (IS_CV != IS_CONST) {
52895
52896 }
52897 HANDLE_EXCEPTION();
52898 }
52899 }
52900 if (IS_CV == IS_CONST) {
52901 function_name = EX_VAR(opline->op2.var);
52902 }
52903 zend_invalid_method_call(object, function_name);
52904
52905
52906 HANDLE_EXCEPTION();
52907 }
52908 } while (0);
52909 }
52910
52911 called_scope = obj->ce;
52912
52913 if (IS_CV == IS_CONST &&
52914 EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
52915 fbc = CACHED_PTR(opline->result.num + sizeof(void*));
52916 } else {
52917 zend_object *orig_obj = obj;
52918
52919 if (IS_CV == IS_CONST) {
52920 function_name = EX_VAR(opline->op2.var);
52921 }
52922
52923 /* First, locate the function. */
52924 fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL));
52925 if (UNEXPECTED(fbc == NULL)) {
52926 if (EXPECTED(!EG(exception))) {
52927 zend_undefined_method(obj->ce, Z_STR_P(function_name));
52928 }
52929
52930 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) {
52931 zend_objects_store_del(orig_obj);
52932 }
52933 HANDLE_EXCEPTION();
52934 }
52935 if (IS_CV == IS_CONST &&
52936 EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) &&
52937 EXPECTED(obj == orig_obj)) {
52938 CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc);
52939 }
52940 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) {
52941 GC_ADDREF(obj); /* For $this pointer */
52942 if (GC_DELREF(orig_obj) == 0) {
52943 zend_objects_store_del(orig_obj);
52944 }
52945 }
52946 if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
52947 init_func_run_time_cache(&fbc->op_array);
52948 }
52949 }
52950
52951 if (IS_CV != IS_CONST) {
52952
52953 }
52954
52955 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS;
52956 if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) {
52957 if ((IS_CV & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) {
52958 zend_objects_store_del(obj);
52959 if (UNEXPECTED(EG(exception))) {
52960 HANDLE_EXCEPTION();
52961 }
52962 }
52963 /* call static method */
52964 obj = (zend_object*)called_scope;
52965 call_info = ZEND_CALL_NESTED_FUNCTION;
52966 } else if (IS_CV & (IS_VAR|IS_TMP_VAR|IS_CV)) {
52967 if (IS_CV == IS_CV) {
52968 GC_ADDREF(obj); /* For $this pointer */
52969 }
52970 /* CV may be changed indirectly (e.g. when it's a reference) */
52971 call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS;
52972 }
52973
52974 call = zend_vm_stack_push_call_frame(call_info,
52975 fbc, opline->extended_value, obj);
52976 call->prev_execute_data = EX(call);
52977 EX(call) = call;
52978
52979 ZEND_VM_NEXT_OPCODE();
52980 }
52981
ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)52982 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
52983 {
52984 USE_OPLINE
52985 zval *expr_ptr, new_expr;
52986
52987 SAVE_OPLINE();
52988 if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
52989 UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
52990 expr_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
52991 if (Z_ISREF_P(expr_ptr)) {
52992 Z_ADDREF_P(expr_ptr);
52993 } else {
52994 ZVAL_MAKE_REF_EX(expr_ptr, 2);
52995 }
52996
52997 } else {
52998 expr_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
52999 if (IS_CV == IS_TMP_VAR) {
53000 /* pass */
53001 } else if (IS_CV == IS_CONST) {
53002 Z_TRY_ADDREF_P(expr_ptr);
53003 } else if (IS_CV == IS_CV) {
53004 ZVAL_DEREF(expr_ptr);
53005 Z_TRY_ADDREF_P(expr_ptr);
53006 } else /* if (IS_CV == IS_VAR) */ {
53007 if (UNEXPECTED(Z_ISREF_P(expr_ptr))) {
53008 zend_refcounted *ref = Z_COUNTED_P(expr_ptr);
53009
53010 expr_ptr = Z_REFVAL_P(expr_ptr);
53011 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
53012 ZVAL_COPY_VALUE(&new_expr, expr_ptr);
53013 expr_ptr = &new_expr;
53014 efree_size(ref, sizeof(zend_reference));
53015 } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) {
53016 Z_ADDREF_P(expr_ptr);
53017 }
53018 }
53019 }
53020 }
53021
53022 if (IS_CV != IS_UNUSED) {
53023 zval *offset = EX_VAR(opline->op2.var);
53024 zend_string *str;
53025 zend_ulong hval;
53026
53027 add_again:
53028 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
53029 str = Z_STR_P(offset);
53030 if (IS_CV != IS_CONST) {
53031 if (ZEND_HANDLE_NUMERIC(str, hval)) {
53032 goto num_index;
53033 }
53034 }
53035 str_index:
53036 zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
53037 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
53038 hval = Z_LVAL_P(offset);
53039 num_index:
53040 zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
53041 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
53042 offset = Z_REFVAL_P(offset);
53043 goto add_again;
53044 } else if (Z_TYPE_P(offset) == IS_NULL) {
53045 str = ZSTR_EMPTY_ALLOC();
53046 goto str_index;
53047 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
53048 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
53049 goto num_index;
53050 } else if (Z_TYPE_P(offset) == IS_FALSE) {
53051 hval = 0;
53052 goto num_index;
53053 } else if (Z_TYPE_P(offset) == IS_TRUE) {
53054 hval = 1;
53055 goto num_index;
53056 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
53057 zend_use_resource_as_offset(offset);
53058 hval = Z_RES_HANDLE_P(offset);
53059 goto num_index;
53060 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
53061 ZVAL_UNDEFINED_OP2();
53062 str = ZSTR_EMPTY_ALLOC();
53063 goto str_index;
53064 } else {
53065 zend_illegal_array_offset_access(offset);
53066 zval_ptr_dtor_nogc(expr_ptr);
53067 }
53068
53069 } else {
53070 if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) {
53071 zend_cannot_add_element();
53072 zval_ptr_dtor_nogc(expr_ptr);
53073 }
53074 }
53075 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
53076 }
53077
ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53078 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53079 {
53080 zval *array;
53081 uint32_t size;
53082 USE_OPLINE
53083
53084 array = EX_VAR(opline->result.var);
53085 if (IS_CV != IS_UNUSED) {
53086 size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
53087 ZVAL_ARR(array, zend_new_array(size));
53088 /* Explicitly initialize array as not-packed if flag is set */
53089 if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
53090 zend_hash_real_init_mixed(Z_ARRVAL_P(array));
53091 }
53092 ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
53093 } else {
53094 ZVAL_ARR(array, zend_new_array(0));
53095 ZEND_VM_NEXT_OPCODE();
53096 }
53097 }
53098
ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53099 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53100 {
53101 USE_OPLINE
53102 zval *container;
53103 zval *offset;
53104 zend_ulong hval;
53105 zend_string *key;
53106
53107 SAVE_OPLINE();
53108 container = EX_VAR(opline->op1.var);
53109 offset = EX_VAR(opline->op2.var);
53110
53111 do {
53112 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
53113 HashTable *ht;
53114
53115 unset_dim_array:
53116 SEPARATE_ARRAY(container);
53117 ht = Z_ARRVAL_P(container);
53118 offset_again:
53119 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
53120 key = Z_STR_P(offset);
53121 if (IS_CV != IS_CONST) {
53122 if (ZEND_HANDLE_NUMERIC(key, hval)) {
53123 goto num_index_dim;
53124 }
53125 }
53126 str_index_dim:
53127 ZEND_ASSERT(ht != &EG(symbol_table));
53128 zend_hash_del(ht, key);
53129 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
53130 hval = Z_LVAL_P(offset);
53131 num_index_dim:
53132 zend_hash_index_del(ht, hval);
53133 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) {
53134 offset = Z_REFVAL_P(offset);
53135 goto offset_again;
53136 } else if (Z_TYPE_P(offset) == IS_DOUBLE) {
53137 hval = zend_dval_to_lval_safe(Z_DVAL_P(offset));
53138 goto num_index_dim;
53139 } else if (Z_TYPE_P(offset) == IS_NULL) {
53140 key = ZSTR_EMPTY_ALLOC();
53141 goto str_index_dim;
53142 } else if (Z_TYPE_P(offset) == IS_FALSE) {
53143 hval = 0;
53144 goto num_index_dim;
53145 } else if (Z_TYPE_P(offset) == IS_TRUE) {
53146 hval = 1;
53147 goto num_index_dim;
53148 } else if (Z_TYPE_P(offset) == IS_RESOURCE) {
53149 zend_use_resource_as_offset(offset);
53150 hval = Z_RES_HANDLE_P(offset);
53151 goto num_index_dim;
53152 } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) {
53153 ZVAL_UNDEFINED_OP2();
53154 key = ZSTR_EMPTY_ALLOC();
53155 goto str_index_dim;
53156 } else {
53157 zend_illegal_array_offset_unset(offset);
53158 }
53159 break;
53160 } else if (Z_ISREF_P(container)) {
53161 container = Z_REFVAL_P(container);
53162 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
53163 goto unset_dim_array;
53164 }
53165 }
53166 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
53167 container = ZVAL_UNDEFINED_OP1();
53168 }
53169 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) {
53170 offset = ZVAL_UNDEFINED_OP2();
53171 }
53172 if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
53173 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
53174 offset++;
53175 }
53176 Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset);
53177 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_STRING)) {
53178 zend_throw_error(NULL, "Cannot unset string offsets");
53179 } else if (UNEXPECTED(Z_TYPE_P(container) > IS_FALSE)) {
53180 zend_throw_error(NULL, "Cannot unset offset in a non-array variable");
53181 } else if (UNEXPECTED(Z_TYPE_P(container) == IS_FALSE)) {
53182 zend_false_to_array_deprecated();
53183 }
53184 } while (0);
53185
53186
53187 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
53188 }
53189
ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53190 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53191 {
53192 USE_OPLINE
53193 zval *container;
53194 zval *offset;
53195 zend_string *name, *tmp_name;
53196
53197 SAVE_OPLINE();
53198 container = EX_VAR(opline->op1.var);
53199 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53200
53201 do {
53202 if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
53203 if (Z_ISREF_P(container)) {
53204 container = Z_REFVAL_P(container);
53205 if (Z_TYPE_P(container) != IS_OBJECT) {
53206 if (IS_CV == IS_CV
53207 && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
53208 ZVAL_UNDEFINED_OP1();
53209 }
53210 break;
53211 }
53212 } else {
53213 break;
53214 }
53215 }
53216 if (IS_CV == IS_CONST) {
53217 name = Z_STR_P(offset);
53218 } else {
53219 name = zval_try_get_tmp_string(offset, &tmp_name);
53220 if (UNEXPECTED(!name)) {
53221 break;
53222 }
53223 }
53224 Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL));
53225 if (IS_CV != IS_CONST) {
53226 zend_tmp_string_release(tmp_name);
53227 }
53228 } while (0);
53229
53230
53231 ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
53232 }
53233
ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53234 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53235 {
53236 USE_OPLINE
53237 zval *container;
53238 bool result;
53239 zend_ulong hval;
53240 zval *offset;
53241
53242 SAVE_OPLINE();
53243 container = EX_VAR(opline->op1.var);
53244 offset = EX_VAR(opline->op2.var);
53245
53246 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
53247 HashTable *ht;
53248 zval *value;
53249 zend_string *str;
53250
53251 isset_dim_obj_array:
53252 ht = Z_ARRVAL_P(container);
53253 isset_again:
53254 if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) {
53255 str = Z_STR_P(offset);
53256 if (IS_CV != IS_CONST) {
53257 if (ZEND_HANDLE_NUMERIC(str, hval)) {
53258 goto num_index_prop;
53259 }
53260 }
53261 value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST);
53262 } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) {
53263 hval = Z_LVAL_P(offset);
53264 num_index_prop:
53265 value = zend_hash_index_find(ht, hval);
53266 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) {
53267 offset = Z_REFVAL_P(offset);
53268 goto isset_again;
53269 } else {
53270 value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC);
53271 if (UNEXPECTED(EG(exception))) {
53272 result = 0;
53273 goto isset_dim_obj_exit;
53274 }
53275 }
53276
53277 if (!(opline->extended_value & ZEND_ISEMPTY)) {
53278 /* > IS_NULL means not IS_UNDEF and not IS_NULL */
53279 result = value != NULL && Z_TYPE_P(value) > IS_NULL &&
53280 (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
53281
53282 if (IS_CV & (IS_CONST|IS_CV)) {
53283 /* avoid exception check */
53284
53285 ZEND_VM_SMART_BRANCH(result, 0);
53286 }
53287 } else {
53288 result = (value == NULL || !i_zend_is_true(value));
53289 }
53290 goto isset_dim_obj_exit;
53291 } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) {
53292 container = Z_REFVAL_P(container);
53293 if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
53294 goto isset_dim_obj_array;
53295 }
53296 }
53297
53298 if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) {
53299 offset++;
53300 }
53301 if (!(opline->extended_value & ZEND_ISEMPTY)) {
53302 result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC);
53303 } else {
53304 result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC);
53305 }
53306
53307 isset_dim_obj_exit:
53308
53309
53310 ZEND_VM_SMART_BRANCH(result, 1);
53311 }
53312
ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53313 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53314 {
53315 USE_OPLINE
53316 zval *container;
53317 int result;
53318 zval *offset;
53319 zend_string *name, *tmp_name;
53320
53321 SAVE_OPLINE();
53322 container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
53323 offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53324
53325 if (IS_CV == IS_CONST ||
53326 (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
53327 if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
53328 container = Z_REFVAL_P(container);
53329 if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
53330 result = (opline->extended_value & ZEND_ISEMPTY);
53331 goto isset_object_finish;
53332 }
53333 } else {
53334 result = (opline->extended_value & ZEND_ISEMPTY);
53335 goto isset_object_finish;
53336 }
53337 }
53338
53339 if (IS_CV == IS_CONST) {
53340 name = Z_STR_P(offset);
53341 } else {
53342 name = zval_try_get_tmp_string(offset, &tmp_name);
53343 if (UNEXPECTED(!name)) {
53344 result = 0;
53345 goto isset_object_finish;
53346 }
53347 }
53348
53349 result =
53350 (opline->extended_value & ZEND_ISEMPTY) ^
53351 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));
53352
53353 if (IS_CV != IS_CONST) {
53354 zend_tmp_string_release(tmp_name);
53355 }
53356
53357 isset_object_finish:
53358
53359
53360 ZEND_VM_SMART_BRANCH(result, 1);
53361 }
53362
ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53363 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53364 {
53365 USE_OPLINE
53366
53367 zval *key, *subject;
53368 HashTable *ht;
53369 bool result;
53370
53371 SAVE_OPLINE();
53372
53373 key = EX_VAR(opline->op1.var);
53374 subject = EX_VAR(opline->op2.var);
53375
53376 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
53377 array_key_exists_array:
53378 ht = Z_ARRVAL_P(subject);
53379 result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC);
53380 } else {
53381 if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) {
53382 subject = Z_REFVAL_P(subject);
53383 if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
53384 goto array_key_exists_array;
53385 }
53386 }
53387 zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC);
53388 result = 0;
53389 }
53390
53391
53392 ZEND_VM_SMART_BRANCH(result, 1);
53393 }
53394
53395 /* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */
ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53396 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53397 {
53398 USE_OPLINE
53399
53400 zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
53401
53402 SAVE_OPLINE();
53403 if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) {
53404 ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
53405 }
53406
53407 /* Destroy the previously yielded value */
53408 zval_ptr_dtor(&generator->value);
53409
53410 /* Destroy the previously yielded key */
53411 zval_ptr_dtor(&generator->key);
53412
53413 /* Set the new yielded value */
53414 if (IS_CV != IS_UNUSED) {
53415 if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
53416 /* Constants and temporary variables aren't yieldable by reference,
53417 * but we still allow them with a notice. */
53418 if (IS_CV & (IS_CONST|IS_TMP_VAR)) {
53419 zval *value;
53420
53421 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
53422
53423 value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
53424 ZVAL_COPY_VALUE(&generator->value, value);
53425 if (IS_CV == IS_CONST) {
53426 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
53427 Z_ADDREF(generator->value);
53428 }
53429 }
53430 } else {
53431 zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
53432
53433 /* If a function call result is yielded and the function did
53434 * not return by reference we throw a notice. */
53435 do {
53436 if (IS_CV == IS_VAR) {
53437 ZEND_ASSERT(value_ptr != &EG(uninitialized_zval));
53438 if (opline->extended_value == ZEND_RETURNS_FUNCTION
53439 && !Z_ISREF_P(value_ptr)) {
53440 zend_error(E_NOTICE, "Only variable references should be yielded by reference");
53441 ZVAL_COPY(&generator->value, value_ptr);
53442 break;
53443 }
53444 }
53445 if (Z_ISREF_P(value_ptr)) {
53446 Z_ADDREF_P(value_ptr);
53447 } else {
53448 ZVAL_MAKE_REF_EX(value_ptr, 2);
53449 }
53450 ZVAL_REF(&generator->value, Z_REF_P(value_ptr));
53451 } while (0);
53452
53453 }
53454 } else {
53455 zval *value = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
53456
53457 /* Consts, temporary variables and references need copying */
53458 if (IS_CV == IS_CONST) {
53459 ZVAL_COPY_VALUE(&generator->value, value);
53460 if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) {
53461 Z_ADDREF(generator->value);
53462 }
53463 } else if (IS_CV == IS_TMP_VAR) {
53464 ZVAL_COPY_VALUE(&generator->value, value);
53465 } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
53466 ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
53467
53468 } else {
53469 ZVAL_COPY_VALUE(&generator->value, value);
53470 if (IS_CV == IS_CV) {
53471 if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
53472 }
53473 }
53474 }
53475 } else {
53476 /* If no value was specified yield null */
53477 ZVAL_NULL(&generator->value);
53478 }
53479
53480 /* Set the new yielded key */
53481 if (IS_CV != IS_UNUSED) {
53482 zval *key = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
53483 if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) {
53484 key = Z_REFVAL_P(key);
53485 }
53486 ZVAL_COPY(&generator->key, key);
53487
53488 if (Z_TYPE(generator->key) == IS_LONG
53489 && Z_LVAL(generator->key) > generator->largest_used_integer_key
53490 ) {
53491 generator->largest_used_integer_key = Z_LVAL(generator->key);
53492 }
53493 } else {
53494 /* If no key was specified we use auto-increment keys */
53495 generator->largest_used_integer_key++;
53496 ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
53497 }
53498
53499 if (RETURN_VALUE_USED(opline)) {
53500 /* If the return value of yield is used set the send
53501 * target and initialize it to NULL */
53502 generator->send_target = EX_VAR(opline->result.var);
53503 ZVAL_NULL(generator->send_target);
53504 } else {
53505 generator->send_target = NULL;
53506 }
53507
53508 /* We increment to the next op, so we are at the correct position when the
53509 * generator is resumed. */
53510 ZEND_VM_INC_OPCODE();
53511
53512 /* The GOTO VM uses a local opline variable. We need to set the opline
53513 * variable in execute_data so we don't resume at an old position. */
53514 SAVE_OPLINE();
53515
53516 ZEND_VM_RETURN();
53517 }
53518
ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53519 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53520 {
53521 /* This is declared below the specializations for MAY_BE_LONG/MAY_BE_DOUBLE so those will be used instead if possible. */
53522 /* This optimizes $x === SOME_CONST_EXPR and $x === $y for non-refs and non-undef, which can't throw. */
53523 /* (Infinite recursion when comparing arrays is an uncatchable fatal error) */
53524 USE_OPLINE
53525 zval *op1, *op2;
53526 bool result;
53527
53528 op1 = EX_VAR(opline->op1.var);
53529 op2 = EX_VAR(opline->op2.var);
53530 result = fast_is_identical_function(op1, op2);
53531 /* Free is a no-op for const/cv */
53532 ZEND_VM_SMART_BRANCH(result, 0);
53533 }
53534
ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53535 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53536 {
53537 USE_OPLINE
53538 zval *op1, *op2;
53539 bool result;
53540
53541 op1 = EX_VAR(opline->op1.var);
53542 op2 = EX_VAR(opline->op2.var);
53543 result = fast_is_identical_function(op1, op2);
53544 /* Free is a no-op for const/cv */
53545 ZEND_VM_SMART_BRANCH(!result, 0);
53546 }
53547
ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)53548 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
53549 {
53550 USE_OPLINE
53551
53552 SAVE_OPLINE();
53553 zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type);
53554 ZEND_VM_NEXT_OPCODE(); /* Never reached */
53555 }
53556
53557
53558 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
53559 # undef ZEND_VM_TAIL_CALL
53560 # undef ZEND_VM_CONTINUE
53561 # undef ZEND_VM_RETURN
53562
53563 # define ZEND_VM_TAIL_CALL(call) call; ZEND_VM_CONTINUE()
53564 # define ZEND_VM_CONTINUE() HYBRID_NEXT()
53565 # define ZEND_VM_RETURN() goto HYBRID_HALT_LABEL
53566 #endif
53567
53568
53569 #if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
53570 # pragma GCC push_options
53571 # pragma GCC optimize("no-gcse")
53572 # pragma GCC optimize("no-ivopts")
53573 #endif
execute_ex(zend_execute_data * ex)53574 ZEND_API void execute_ex(zend_execute_data *ex)
53575 {
53576 DCL_OPLINE
53577
53578 #if defined(ZEND_VM_IP_GLOBAL_REG) || defined(ZEND_VM_FP_GLOBAL_REG)
53579 struct {
53580 #ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
53581 char hybrid_jit_red_zone[ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE];
53582 #endif
53583 #ifdef ZEND_VM_IP_GLOBAL_REG
53584 const zend_op *orig_opline;
53585 #endif
53586 #ifdef ZEND_VM_FP_GLOBAL_REG
53587 zend_execute_data *orig_execute_data;
53588 #endif
53589 } vm_stack_data;
53590 #endif
53591 #ifdef ZEND_VM_IP_GLOBAL_REG
53592 vm_stack_data.orig_opline = opline;
53593 #endif
53594 #ifdef ZEND_VM_FP_GLOBAL_REG
53595 vm_stack_data.orig_execute_data = execute_data;
53596 execute_data = ex;
53597 #else
53598 zend_execute_data *execute_data = ex;
53599 #endif
53600
53601 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
53602 if (UNEXPECTED(execute_data == NULL)) {
53603 static const void * const labels[] = {
53604 (void*)&&ZEND_NOP_SPEC_LABEL,
53605 (void*)&&ZEND_ADD_SPEC_CONST_CONST_LABEL,
53606 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
53607 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
53608 (void*)&&ZEND_NULL_LABEL,
53609 (void*)&&ZEND_ADD_SPEC_CONST_TMPVARCV_LABEL,
53610 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
53611 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53612 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53613 (void*)&&ZEND_NULL_LABEL,
53614 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53615 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
53616 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53617 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53618 (void*)&&ZEND_NULL_LABEL,
53619 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53620 (void*)&&ZEND_NULL_LABEL,
53621 (void*)&&ZEND_NULL_LABEL,
53622 (void*)&&ZEND_NULL_LABEL,
53623 (void*)&&ZEND_NULL_LABEL,
53624 (void*)&&ZEND_NULL_LABEL,
53625 (void*)&&ZEND_ADD_SPEC_TMPVARCV_CONST_LABEL,
53626 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53627 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53628 (void*)&&ZEND_NULL_LABEL,
53629 (void*)&&ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53630 (void*)&&ZEND_SUB_SPEC_CONST_CONST_LABEL,
53631 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
53632 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
53633 (void*)&&ZEND_NULL_LABEL,
53634 (void*)&&ZEND_SUB_SPEC_CONST_TMPVARCV_LABEL,
53635 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
53636 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53637 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53638 (void*)&&ZEND_NULL_LABEL,
53639 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53640 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
53641 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53642 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53643 (void*)&&ZEND_NULL_LABEL,
53644 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53645 (void*)&&ZEND_NULL_LABEL,
53646 (void*)&&ZEND_NULL_LABEL,
53647 (void*)&&ZEND_NULL_LABEL,
53648 (void*)&&ZEND_NULL_LABEL,
53649 (void*)&&ZEND_NULL_LABEL,
53650 (void*)&&ZEND_SUB_SPEC_TMPVARCV_CONST_LABEL,
53651 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53652 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53653 (void*)&&ZEND_NULL_LABEL,
53654 (void*)&&ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_LABEL,
53655 (void*)&&ZEND_MUL_SPEC_CONST_CONST_LABEL,
53656 (void*)&&ZEND_NULL_LABEL,
53657 (void*)&&ZEND_NULL_LABEL,
53658 (void*)&&ZEND_NULL_LABEL,
53659 (void*)&&ZEND_NULL_LABEL,
53660 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
53661 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53662 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53663 (void*)&&ZEND_NULL_LABEL,
53664 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53665 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
53666 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53667 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53668 (void*)&&ZEND_NULL_LABEL,
53669 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53670 (void*)&&ZEND_NULL_LABEL,
53671 (void*)&&ZEND_NULL_LABEL,
53672 (void*)&&ZEND_NULL_LABEL,
53673 (void*)&&ZEND_NULL_LABEL,
53674 (void*)&&ZEND_NULL_LABEL,
53675 (void*)&&ZEND_MUL_SPEC_TMPVARCV_CONST_LABEL,
53676 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53677 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53678 (void*)&&ZEND_NULL_LABEL,
53679 (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53680 (void*)&&ZEND_DIV_SPEC_CONST_CONST_LABEL,
53681 (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
53682 (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL,
53683 (void*)&&ZEND_NULL_LABEL,
53684 (void*)&&ZEND_DIV_SPEC_CONST_CV_LABEL,
53685 (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
53686 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
53687 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
53688 (void*)&&ZEND_NULL_LABEL,
53689 (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
53690 (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL,
53691 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
53692 (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL,
53693 (void*)&&ZEND_NULL_LABEL,
53694 (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL,
53695 (void*)&&ZEND_NULL_LABEL,
53696 (void*)&&ZEND_NULL_LABEL,
53697 (void*)&&ZEND_NULL_LABEL,
53698 (void*)&&ZEND_NULL_LABEL,
53699 (void*)&&ZEND_NULL_LABEL,
53700 (void*)&&ZEND_DIV_SPEC_CV_CONST_LABEL,
53701 (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
53702 (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL,
53703 (void*)&&ZEND_NULL_LABEL,
53704 (void*)&&ZEND_DIV_SPEC_CV_CV_LABEL,
53705 (void*)&&ZEND_MOD_SPEC_CONST_CONST_LABEL,
53706 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
53707 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
53708 (void*)&&ZEND_NULL_LABEL,
53709 (void*)&&ZEND_MOD_SPEC_CONST_TMPVARCV_LABEL,
53710 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
53711 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53712 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53713 (void*)&&ZEND_NULL_LABEL,
53714 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53715 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
53716 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53717 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53718 (void*)&&ZEND_NULL_LABEL,
53719 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53720 (void*)&&ZEND_NULL_LABEL,
53721 (void*)&&ZEND_NULL_LABEL,
53722 (void*)&&ZEND_NULL_LABEL,
53723 (void*)&&ZEND_NULL_LABEL,
53724 (void*)&&ZEND_NULL_LABEL,
53725 (void*)&&ZEND_MOD_SPEC_TMPVARCV_CONST_LABEL,
53726 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53727 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53728 (void*)&&ZEND_NULL_LABEL,
53729 (void*)&&ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_LABEL,
53730 (void*)&&ZEND_SL_SPEC_CONST_CONST_LABEL,
53731 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
53732 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
53733 (void*)&&ZEND_NULL_LABEL,
53734 (void*)&&ZEND_SL_SPEC_CONST_TMPVARCV_LABEL,
53735 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
53736 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53737 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53738 (void*)&&ZEND_NULL_LABEL,
53739 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53740 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
53741 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53742 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53743 (void*)&&ZEND_NULL_LABEL,
53744 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53745 (void*)&&ZEND_NULL_LABEL,
53746 (void*)&&ZEND_NULL_LABEL,
53747 (void*)&&ZEND_NULL_LABEL,
53748 (void*)&&ZEND_NULL_LABEL,
53749 (void*)&&ZEND_NULL_LABEL,
53750 (void*)&&ZEND_SL_SPEC_TMPVARCV_CONST_LABEL,
53751 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53752 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53753 (void*)&&ZEND_NULL_LABEL,
53754 (void*)&&ZEND_SL_SPEC_TMPVARCV_TMPVARCV_LABEL,
53755 (void*)&&ZEND_SR_SPEC_CONST_CONST_LABEL,
53756 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
53757 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
53758 (void*)&&ZEND_NULL_LABEL,
53759 (void*)&&ZEND_SR_SPEC_CONST_TMPVARCV_LABEL,
53760 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
53761 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53762 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53763 (void*)&&ZEND_NULL_LABEL,
53764 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53765 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
53766 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53767 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53768 (void*)&&ZEND_NULL_LABEL,
53769 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53770 (void*)&&ZEND_NULL_LABEL,
53771 (void*)&&ZEND_NULL_LABEL,
53772 (void*)&&ZEND_NULL_LABEL,
53773 (void*)&&ZEND_NULL_LABEL,
53774 (void*)&&ZEND_NULL_LABEL,
53775 (void*)&&ZEND_SR_SPEC_TMPVARCV_CONST_LABEL,
53776 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53777 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53778 (void*)&&ZEND_NULL_LABEL,
53779 (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53780 (void*)&&ZEND_NULL_LABEL,
53781 (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
53782 (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL,
53783 (void*)&&ZEND_NULL_LABEL,
53784 (void*)&&ZEND_CONCAT_SPEC_CONST_CV_LABEL,
53785 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
53786 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
53787 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
53788 (void*)&&ZEND_NULL_LABEL,
53789 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
53790 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL,
53791 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
53792 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
53793 (void*)&&ZEND_NULL_LABEL,
53794 (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL,
53795 (void*)&&ZEND_NULL_LABEL,
53796 (void*)&&ZEND_NULL_LABEL,
53797 (void*)&&ZEND_NULL_LABEL,
53798 (void*)&&ZEND_NULL_LABEL,
53799 (void*)&&ZEND_NULL_LABEL,
53800 (void*)&&ZEND_CONCAT_SPEC_CV_CONST_LABEL,
53801 (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
53802 (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL,
53803 (void*)&&ZEND_NULL_LABEL,
53804 (void*)&&ZEND_CONCAT_SPEC_CV_CV_LABEL,
53805 (void*)&&ZEND_BW_OR_SPEC_CONST_CONST_LABEL,
53806 (void*)&&ZEND_NULL_LABEL,
53807 (void*)&&ZEND_NULL_LABEL,
53808 (void*)&&ZEND_NULL_LABEL,
53809 (void*)&&ZEND_NULL_LABEL,
53810 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
53811 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53812 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53813 (void*)&&ZEND_NULL_LABEL,
53814 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53815 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
53816 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53817 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53818 (void*)&&ZEND_NULL_LABEL,
53819 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53820 (void*)&&ZEND_NULL_LABEL,
53821 (void*)&&ZEND_NULL_LABEL,
53822 (void*)&&ZEND_NULL_LABEL,
53823 (void*)&&ZEND_NULL_LABEL,
53824 (void*)&&ZEND_NULL_LABEL,
53825 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_CONST_LABEL,
53826 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53827 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53828 (void*)&&ZEND_NULL_LABEL,
53829 (void*)&&ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53830 (void*)&&ZEND_BW_AND_SPEC_CONST_CONST_LABEL,
53831 (void*)&&ZEND_NULL_LABEL,
53832 (void*)&&ZEND_NULL_LABEL,
53833 (void*)&&ZEND_NULL_LABEL,
53834 (void*)&&ZEND_NULL_LABEL,
53835 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
53836 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53837 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53838 (void*)&&ZEND_NULL_LABEL,
53839 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53840 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
53841 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53842 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53843 (void*)&&ZEND_NULL_LABEL,
53844 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53845 (void*)&&ZEND_NULL_LABEL,
53846 (void*)&&ZEND_NULL_LABEL,
53847 (void*)&&ZEND_NULL_LABEL,
53848 (void*)&&ZEND_NULL_LABEL,
53849 (void*)&&ZEND_NULL_LABEL,
53850 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_CONST_LABEL,
53851 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53852 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53853 (void*)&&ZEND_NULL_LABEL,
53854 (void*)&&ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_LABEL,
53855 (void*)&&ZEND_BW_XOR_SPEC_CONST_CONST_LABEL,
53856 (void*)&&ZEND_NULL_LABEL,
53857 (void*)&&ZEND_NULL_LABEL,
53858 (void*)&&ZEND_NULL_LABEL,
53859 (void*)&&ZEND_NULL_LABEL,
53860 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
53861 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53862 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53863 (void*)&&ZEND_NULL_LABEL,
53864 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53865 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
53866 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53867 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53868 (void*)&&ZEND_NULL_LABEL,
53869 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53870 (void*)&&ZEND_NULL_LABEL,
53871 (void*)&&ZEND_NULL_LABEL,
53872 (void*)&&ZEND_NULL_LABEL,
53873 (void*)&&ZEND_NULL_LABEL,
53874 (void*)&&ZEND_NULL_LABEL,
53875 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_CONST_LABEL,
53876 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53877 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53878 (void*)&&ZEND_NULL_LABEL,
53879 (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL,
53880 (void*)&&ZEND_POW_SPEC_CONST_CONST_LABEL,
53881 (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
53882 (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL,
53883 (void*)&&ZEND_NULL_LABEL,
53884 (void*)&&ZEND_POW_SPEC_CONST_CV_LABEL,
53885 (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
53886 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
53887 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
53888 (void*)&&ZEND_NULL_LABEL,
53889 (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
53890 (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL,
53891 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
53892 (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL,
53893 (void*)&&ZEND_NULL_LABEL,
53894 (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL,
53895 (void*)&&ZEND_NULL_LABEL,
53896 (void*)&&ZEND_NULL_LABEL,
53897 (void*)&&ZEND_NULL_LABEL,
53898 (void*)&&ZEND_NULL_LABEL,
53899 (void*)&&ZEND_NULL_LABEL,
53900 (void*)&&ZEND_POW_SPEC_CV_CONST_LABEL,
53901 (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
53902 (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL,
53903 (void*)&&ZEND_NULL_LABEL,
53904 (void*)&&ZEND_POW_SPEC_CV_CV_LABEL,
53905 (void*)&&ZEND_BW_NOT_SPEC_CONST_LABEL,
53906 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
53907 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
53908 (void*)&&ZEND_NULL_LABEL,
53909 (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL,
53910 (void*)&&ZEND_BOOL_NOT_SPEC_CONST_LABEL,
53911 (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
53912 (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL,
53913 (void*)&&ZEND_NULL_LABEL,
53914 (void*)&&ZEND_BOOL_NOT_SPEC_CV_LABEL,
53915 (void*)&&ZEND_BOOL_XOR_SPEC_CONST_CONST_LABEL,
53916 (void*)&&ZEND_NULL_LABEL,
53917 (void*)&&ZEND_NULL_LABEL,
53918 (void*)&&ZEND_NULL_LABEL,
53919 (void*)&&ZEND_NULL_LABEL,
53920 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
53921 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
53922 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
53923 (void*)&&ZEND_NULL_LABEL,
53924 (void*)&&ZEND_NULL_LABEL,
53925 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL,
53926 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
53927 (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL,
53928 (void*)&&ZEND_NULL_LABEL,
53929 (void*)&&ZEND_NULL_LABEL,
53930 (void*)&&ZEND_NULL_LABEL,
53931 (void*)&&ZEND_NULL_LABEL,
53932 (void*)&&ZEND_NULL_LABEL,
53933 (void*)&&ZEND_NULL_LABEL,
53934 (void*)&&ZEND_NULL_LABEL,
53935 (void*)&&ZEND_BOOL_XOR_SPEC_CV_CONST_LABEL,
53936 (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
53937 (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL,
53938 (void*)&&ZEND_NULL_LABEL,
53939 (void*)&&ZEND_BOOL_XOR_SPEC_CV_CV_LABEL,
53940 (void*)&&ZEND_IS_IDENTICAL_SPEC_CONST_CONST_LABEL,
53941 (void*)&&ZEND_NULL_LABEL,
53942 (void*)&&ZEND_NULL_LABEL,
53943 (void*)&&ZEND_NULL_LABEL,
53944 (void*)&&ZEND_NULL_LABEL,
53945 (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_CONST_LABEL,
53946 (void*)&&ZEND_IS_IDENTICAL_SPEC_TMP_TMP_LABEL,
53947 (void*)&&ZEND_NULL_LABEL,
53948 (void*)&&ZEND_NULL_LABEL,
53949 (void*)&&ZEND_NULL_LABEL,
53950 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_CONST_LABEL,
53951 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_TMP_LABEL,
53952 (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_VAR_LABEL,
53953 (void*)&&ZEND_NULL_LABEL,
53954 (void*)&&ZEND_NULL_LABEL,
53955 (void*)&&ZEND_NULL_LABEL,
53956 (void*)&&ZEND_NULL_LABEL,
53957 (void*)&&ZEND_NULL_LABEL,
53958 (void*)&&ZEND_NULL_LABEL,
53959 (void*)&&ZEND_NULL_LABEL,
53960 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CONST_LABEL,
53961 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_TMP_LABEL,
53962 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_VAR_LABEL,
53963 (void*)&&ZEND_NULL_LABEL,
53964 (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CV_LABEL,
53965 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_LABEL,
53966 (void*)&&ZEND_NULL_LABEL,
53967 (void*)&&ZEND_NULL_LABEL,
53968 (void*)&&ZEND_NULL_LABEL,
53969 (void*)&&ZEND_NULL_LABEL,
53970 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_LABEL,
53971 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_LABEL,
53972 (void*)&&ZEND_NULL_LABEL,
53973 (void*)&&ZEND_NULL_LABEL,
53974 (void*)&&ZEND_NULL_LABEL,
53975 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_LABEL,
53976 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_LABEL,
53977 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_LABEL,
53978 (void*)&&ZEND_NULL_LABEL,
53979 (void*)&&ZEND_NULL_LABEL,
53980 (void*)&&ZEND_NULL_LABEL,
53981 (void*)&&ZEND_NULL_LABEL,
53982 (void*)&&ZEND_NULL_LABEL,
53983 (void*)&&ZEND_NULL_LABEL,
53984 (void*)&&ZEND_NULL_LABEL,
53985 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_LABEL,
53986 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_LABEL,
53987 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_LABEL,
53988 (void*)&&ZEND_NULL_LABEL,
53989 (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_LABEL,
53990 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
53991 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
53992 (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL,
53993 (void*)&&ZEND_NULL_LABEL,
53994 (void*)&&ZEND_NULL_LABEL,
53995 (void*)&&ZEND_NULL_LABEL,
53996 (void*)&&ZEND_NULL_LABEL,
53997 (void*)&&ZEND_NULL_LABEL,
53998 (void*)&&ZEND_NULL_LABEL,
53999 (void*)&&ZEND_NULL_LABEL,
54000 (void*)&&ZEND_NULL_LABEL,
54001 (void*)&&ZEND_NULL_LABEL,
54002 (void*)&&ZEND_NULL_LABEL,
54003 (void*)&&ZEND_NULL_LABEL,
54004 (void*)&&ZEND_NULL_LABEL,
54005 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL,
54006 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
54007 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
54008 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54009 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54010 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54011 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54012 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54013 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54014 (void*)&&ZEND_NULL_LABEL,
54015 (void*)&&ZEND_NULL_LABEL,
54016 (void*)&&ZEND_NULL_LABEL,
54017 (void*)&&ZEND_NULL_LABEL,
54018 (void*)&&ZEND_NULL_LABEL,
54019 (void*)&&ZEND_NULL_LABEL,
54020 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL,
54021 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
54022 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
54023 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54024 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54025 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54026 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54027 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54028 (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54029 (void*)&&ZEND_NULL_LABEL,
54030 (void*)&&ZEND_NULL_LABEL,
54031 (void*)&&ZEND_NULL_LABEL,
54032 (void*)&&ZEND_NULL_LABEL,
54033 (void*)&&ZEND_NULL_LABEL,
54034 (void*)&&ZEND_NULL_LABEL,
54035 (void*)&&ZEND_NULL_LABEL,
54036 (void*)&&ZEND_NULL_LABEL,
54037 (void*)&&ZEND_NULL_LABEL,
54038 (void*)&&ZEND_NULL_LABEL,
54039 (void*)&&ZEND_NULL_LABEL,
54040 (void*)&&ZEND_NULL_LABEL,
54041 (void*)&&ZEND_NULL_LABEL,
54042 (void*)&&ZEND_NULL_LABEL,
54043 (void*)&&ZEND_NULL_LABEL,
54044 (void*)&&ZEND_NULL_LABEL,
54045 (void*)&&ZEND_NULL_LABEL,
54046 (void*)&&ZEND_NULL_LABEL,
54047 (void*)&&ZEND_NULL_LABEL,
54048 (void*)&&ZEND_NULL_LABEL,
54049 (void*)&&ZEND_NULL_LABEL,
54050 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_LABEL,
54051 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
54052 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
54053 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
54054 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
54055 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
54056 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL,
54057 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
54058 (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
54059 (void*)&&ZEND_NULL_LABEL,
54060 (void*)&&ZEND_NULL_LABEL,
54061 (void*)&&ZEND_NULL_LABEL,
54062 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_LABEL,
54063 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
54064 (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
54065 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
54066 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
54067 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL,
54068 (void*)&&ZEND_NULL_LABEL,
54069 (void*)&&ZEND_NULL_LABEL,
54070 (void*)&&ZEND_NULL_LABEL,
54071 (void*)&&ZEND_NULL_LABEL,
54072 (void*)&&ZEND_NULL_LABEL,
54073 (void*)&&ZEND_NULL_LABEL,
54074 (void*)&&ZEND_NULL_LABEL,
54075 (void*)&&ZEND_NULL_LABEL,
54076 (void*)&&ZEND_NULL_LABEL,
54077 (void*)&&ZEND_NULL_LABEL,
54078 (void*)&&ZEND_NULL_LABEL,
54079 (void*)&&ZEND_NULL_LABEL,
54080 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
54081 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
54082 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
54083 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54084 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54085 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54086 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54087 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54088 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54089 (void*)&&ZEND_NULL_LABEL,
54090 (void*)&&ZEND_NULL_LABEL,
54091 (void*)&&ZEND_NULL_LABEL,
54092 (void*)&&ZEND_NULL_LABEL,
54093 (void*)&&ZEND_NULL_LABEL,
54094 (void*)&&ZEND_NULL_LABEL,
54095 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL,
54096 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL,
54097 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL,
54098 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54099 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54100 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54101 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL,
54102 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL,
54103 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL,
54104 (void*)&&ZEND_NULL_LABEL,
54105 (void*)&&ZEND_NULL_LABEL,
54106 (void*)&&ZEND_NULL_LABEL,
54107 (void*)&&ZEND_NULL_LABEL,
54108 (void*)&&ZEND_NULL_LABEL,
54109 (void*)&&ZEND_NULL_LABEL,
54110 (void*)&&ZEND_NULL_LABEL,
54111 (void*)&&ZEND_NULL_LABEL,
54112 (void*)&&ZEND_NULL_LABEL,
54113 (void*)&&ZEND_NULL_LABEL,
54114 (void*)&&ZEND_NULL_LABEL,
54115 (void*)&&ZEND_NULL_LABEL,
54116 (void*)&&ZEND_NULL_LABEL,
54117 (void*)&&ZEND_NULL_LABEL,
54118 (void*)&&ZEND_NULL_LABEL,
54119 (void*)&&ZEND_NULL_LABEL,
54120 (void*)&&ZEND_NULL_LABEL,
54121 (void*)&&ZEND_NULL_LABEL,
54122 (void*)&&ZEND_NULL_LABEL,
54123 (void*)&&ZEND_NULL_LABEL,
54124 (void*)&&ZEND_NULL_LABEL,
54125 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_LABEL,
54126 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_LABEL,
54127 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL,
54128 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
54129 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
54130 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
54131 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL,
54132 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL,
54133 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL,
54134 (void*)&&ZEND_NULL_LABEL,
54135 (void*)&&ZEND_NULL_LABEL,
54136 (void*)&&ZEND_NULL_LABEL,
54137 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_LABEL,
54138 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_LABEL,
54139 (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_LABEL,
54140 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
54141 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
54142 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_CONST_LABEL,
54143 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
54144 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54145 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54146 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
54147 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54148 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54149 (void*)&&ZEND_NULL_LABEL,
54150 (void*)&&ZEND_NULL_LABEL,
54151 (void*)&&ZEND_NULL_LABEL,
54152 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_LABEL,
54153 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54154 (void*)&&ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54155 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
54156 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54157 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
54158 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54159 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54160 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54161 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54162 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54163 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54164 (void*)&&ZEND_NULL_LABEL,
54165 (void*)&&ZEND_NULL_LABEL,
54166 (void*)&&ZEND_NULL_LABEL,
54167 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54168 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54169 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54170 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
54171 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54172 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
54173 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54174 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54175 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54176 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54177 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54178 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54179 (void*)&&ZEND_NULL_LABEL,
54180 (void*)&&ZEND_NULL_LABEL,
54181 (void*)&&ZEND_NULL_LABEL,
54182 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54183 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54184 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54185 (void*)&&ZEND_NULL_LABEL,
54186 (void*)&&ZEND_NULL_LABEL,
54187 (void*)&&ZEND_NULL_LABEL,
54188 (void*)&&ZEND_NULL_LABEL,
54189 (void*)&&ZEND_NULL_LABEL,
54190 (void*)&&ZEND_NULL_LABEL,
54191 (void*)&&ZEND_NULL_LABEL,
54192 (void*)&&ZEND_NULL_LABEL,
54193 (void*)&&ZEND_NULL_LABEL,
54194 (void*)&&ZEND_NULL_LABEL,
54195 (void*)&&ZEND_NULL_LABEL,
54196 (void*)&&ZEND_NULL_LABEL,
54197 (void*)&&ZEND_NULL_LABEL,
54198 (void*)&&ZEND_NULL_LABEL,
54199 (void*)&&ZEND_NULL_LABEL,
54200 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_LABEL,
54201 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54202 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
54203 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54204 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54205 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54206 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54207 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54208 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54209 (void*)&&ZEND_NULL_LABEL,
54210 (void*)&&ZEND_NULL_LABEL,
54211 (void*)&&ZEND_NULL_LABEL,
54212 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_LABEL,
54213 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54214 (void*)&&ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54215 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
54216 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
54217 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_LABEL,
54218 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
54219 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54220 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54221 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
54222 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54223 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54224 (void*)&&ZEND_NULL_LABEL,
54225 (void*)&&ZEND_NULL_LABEL,
54226 (void*)&&ZEND_NULL_LABEL,
54227 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_LABEL,
54228 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
54229 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
54230 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
54231 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54232 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
54233 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54234 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54235 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54236 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54237 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54238 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54239 (void*)&&ZEND_NULL_LABEL,
54240 (void*)&&ZEND_NULL_LABEL,
54241 (void*)&&ZEND_NULL_LABEL,
54242 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54243 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54244 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54245 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
54246 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54247 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
54248 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54249 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54250 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54251 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54252 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54253 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54254 (void*)&&ZEND_NULL_LABEL,
54255 (void*)&&ZEND_NULL_LABEL,
54256 (void*)&&ZEND_NULL_LABEL,
54257 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54258 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54259 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54260 (void*)&&ZEND_NULL_LABEL,
54261 (void*)&&ZEND_NULL_LABEL,
54262 (void*)&&ZEND_NULL_LABEL,
54263 (void*)&&ZEND_NULL_LABEL,
54264 (void*)&&ZEND_NULL_LABEL,
54265 (void*)&&ZEND_NULL_LABEL,
54266 (void*)&&ZEND_NULL_LABEL,
54267 (void*)&&ZEND_NULL_LABEL,
54268 (void*)&&ZEND_NULL_LABEL,
54269 (void*)&&ZEND_NULL_LABEL,
54270 (void*)&&ZEND_NULL_LABEL,
54271 (void*)&&ZEND_NULL_LABEL,
54272 (void*)&&ZEND_NULL_LABEL,
54273 (void*)&&ZEND_NULL_LABEL,
54274 (void*)&&ZEND_NULL_LABEL,
54275 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_LABEL,
54276 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
54277 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
54278 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54279 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54280 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54281 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54282 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54283 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54284 (void*)&&ZEND_NULL_LABEL,
54285 (void*)&&ZEND_NULL_LABEL,
54286 (void*)&&ZEND_NULL_LABEL,
54287 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_LABEL,
54288 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
54289 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
54290 (void*)&&ZEND_NULL_LABEL,
54291 (void*)&&ZEND_NULL_LABEL,
54292 (void*)&&ZEND_NULL_LABEL,
54293 (void*)&&ZEND_NULL_LABEL,
54294 (void*)&&ZEND_NULL_LABEL,
54295 (void*)&&ZEND_NULL_LABEL,
54296 (void*)&&ZEND_NULL_LABEL,
54297 (void*)&&ZEND_NULL_LABEL,
54298 (void*)&&ZEND_NULL_LABEL,
54299 (void*)&&ZEND_NULL_LABEL,
54300 (void*)&&ZEND_NULL_LABEL,
54301 (void*)&&ZEND_NULL_LABEL,
54302 (void*)&&ZEND_NULL_LABEL,
54303 (void*)&&ZEND_NULL_LABEL,
54304 (void*)&&ZEND_NULL_LABEL,
54305 (void*)&&ZEND_NULL_LABEL,
54306 (void*)&&ZEND_NULL_LABEL,
54307 (void*)&&ZEND_NULL_LABEL,
54308 (void*)&&ZEND_NULL_LABEL,
54309 (void*)&&ZEND_NULL_LABEL,
54310 (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_LABEL,
54311 (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_LABEL,
54312 (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_LABEL,
54313 (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_LABEL,
54314 (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_LABEL,
54315 (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_LABEL,
54316 (void*)&&ZEND_NULL_LABEL,
54317 (void*)&&ZEND_NULL_LABEL,
54318 (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
54319 (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_LABEL,
54320 (void*)&&ZEND_NULL_LABEL,
54321 (void*)&&ZEND_NULL_LABEL,
54322 (void*)&&ZEND_NULL_LABEL,
54323 (void*)&&ZEND_NULL_LABEL,
54324 (void*)&&ZEND_NULL_LABEL,
54325 (void*)&&ZEND_NULL_LABEL,
54326 (void*)&&ZEND_NULL_LABEL,
54327 (void*)&&ZEND_NULL_LABEL,
54328 (void*)&&ZEND_NULL_LABEL,
54329 (void*)&&ZEND_NULL_LABEL,
54330 (void*)&&ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_LABEL,
54331 (void*)&&ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_LABEL,
54332 (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_LABEL,
54333 (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_LABEL,
54334 (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_LABEL,
54335 (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_LABEL,
54336 (void*)&&ZEND_NULL_LABEL,
54337 (void*)&&ZEND_NULL_LABEL,
54338 (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_LABEL,
54339 (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_LABEL,
54340 (void*)&&ZEND_NULL_LABEL,
54341 (void*)&&ZEND_NULL_LABEL,
54342 (void*)&&ZEND_NULL_LABEL,
54343 (void*)&&ZEND_NULL_LABEL,
54344 (void*)&&ZEND_NULL_LABEL,
54345 (void*)&&ZEND_NULL_LABEL,
54346 (void*)&&ZEND_NULL_LABEL,
54347 (void*)&&ZEND_NULL_LABEL,
54348 (void*)&&ZEND_NULL_LABEL,
54349 (void*)&&ZEND_NULL_LABEL,
54350 (void*)&&ZEND_NULL_LABEL,
54351 (void*)&&ZEND_NULL_LABEL,
54352 (void*)&&ZEND_NULL_LABEL,
54353 (void*)&&ZEND_NULL_LABEL,
54354 (void*)&&ZEND_NULL_LABEL,
54355 (void*)&&ZEND_NULL_LABEL,
54356 (void*)&&ZEND_NULL_LABEL,
54357 (void*)&&ZEND_NULL_LABEL,
54358 (void*)&&ZEND_NULL_LABEL,
54359 (void*)&&ZEND_NULL_LABEL,
54360 (void*)&&ZEND_NULL_LABEL,
54361 (void*)&&ZEND_NULL_LABEL,
54362 (void*)&&ZEND_NULL_LABEL,
54363 (void*)&&ZEND_NULL_LABEL,
54364 (void*)&&ZEND_NULL_LABEL,
54365 (void*)&&ZEND_NULL_LABEL,
54366 (void*)&&ZEND_NULL_LABEL,
54367 (void*)&&ZEND_NULL_LABEL,
54368 (void*)&&ZEND_NULL_LABEL,
54369 (void*)&&ZEND_NULL_LABEL,
54370 (void*)&&ZEND_NULL_LABEL,
54371 (void*)&&ZEND_NULL_LABEL,
54372 (void*)&&ZEND_NULL_LABEL,
54373 (void*)&&ZEND_NULL_LABEL,
54374 (void*)&&ZEND_NULL_LABEL,
54375 (void*)&&ZEND_NULL_LABEL,
54376 (void*)&&ZEND_NULL_LABEL,
54377 (void*)&&ZEND_NULL_LABEL,
54378 (void*)&&ZEND_NULL_LABEL,
54379 (void*)&&ZEND_NULL_LABEL,
54380 (void*)&&ZEND_NULL_LABEL,
54381 (void*)&&ZEND_NULL_LABEL,
54382 (void*)&&ZEND_NULL_LABEL,
54383 (void*)&&ZEND_NULL_LABEL,
54384 (void*)&&ZEND_NULL_LABEL,
54385 (void*)&&ZEND_NULL_LABEL,
54386 (void*)&&ZEND_NULL_LABEL,
54387 (void*)&&ZEND_NULL_LABEL,
54388 (void*)&&ZEND_NULL_LABEL,
54389 (void*)&&ZEND_NULL_LABEL,
54390 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
54391 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
54392 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
54393 (void*)&&ZEND_NULL_LABEL,
54394 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
54395 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
54396 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
54397 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54398 (void*)&&ZEND_NULL_LABEL,
54399 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54400 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
54401 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
54402 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54403 (void*)&&ZEND_NULL_LABEL,
54404 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54405 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_LABEL,
54406 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_LABEL,
54407 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_LABEL,
54408 (void*)&&ZEND_NULL_LABEL,
54409 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_LABEL,
54410 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
54411 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
54412 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
54413 (void*)&&ZEND_NULL_LABEL,
54414 (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_LABEL,
54415 (void*)&&ZEND_NULL_LABEL,
54416 (void*)&&ZEND_NULL_LABEL,
54417 (void*)&&ZEND_NULL_LABEL,
54418 (void*)&&ZEND_NULL_LABEL,
54419 (void*)&&ZEND_NULL_LABEL,
54420 (void*)&&ZEND_NULL_LABEL,
54421 (void*)&&ZEND_NULL_LABEL,
54422 (void*)&&ZEND_NULL_LABEL,
54423 (void*)&&ZEND_NULL_LABEL,
54424 (void*)&&ZEND_NULL_LABEL,
54425 (void*)&&ZEND_NULL_LABEL,
54426 (void*)&&ZEND_NULL_LABEL,
54427 (void*)&&ZEND_NULL_LABEL,
54428 (void*)&&ZEND_NULL_LABEL,
54429 (void*)&&ZEND_NULL_LABEL,
54430 (void*)&&ZEND_NULL_LABEL,
54431 (void*)&&ZEND_NULL_LABEL,
54432 (void*)&&ZEND_NULL_LABEL,
54433 (void*)&&ZEND_NULL_LABEL,
54434 (void*)&&ZEND_NULL_LABEL,
54435 (void*)&&ZEND_NULL_LABEL,
54436 (void*)&&ZEND_NULL_LABEL,
54437 (void*)&&ZEND_NULL_LABEL,
54438 (void*)&&ZEND_NULL_LABEL,
54439 (void*)&&ZEND_NULL_LABEL,
54440 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
54441 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
54442 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
54443 (void*)&&ZEND_NULL_LABEL,
54444 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_LABEL,
54445 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
54446 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
54447 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54448 (void*)&&ZEND_NULL_LABEL,
54449 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
54450 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
54451 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
54452 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54453 (void*)&&ZEND_NULL_LABEL,
54454 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
54455 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_LABEL,
54456 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_LABEL,
54457 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_LABEL,
54458 (void*)&&ZEND_NULL_LABEL,
54459 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_LABEL,
54460 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_LABEL,
54461 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_LABEL,
54462 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_LABEL,
54463 (void*)&&ZEND_NULL_LABEL,
54464 (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_LABEL,
54465 (void*)&&ZEND_NULL_LABEL,
54466 (void*)&&ZEND_NULL_LABEL,
54467 (void*)&&ZEND_NULL_LABEL,
54468 (void*)&&ZEND_NULL_LABEL,
54469 (void*)&&ZEND_NULL_LABEL,
54470 (void*)&&ZEND_NULL_LABEL,
54471 (void*)&&ZEND_NULL_LABEL,
54472 (void*)&&ZEND_NULL_LABEL,
54473 (void*)&&ZEND_NULL_LABEL,
54474 (void*)&&ZEND_NULL_LABEL,
54475 (void*)&&ZEND_NULL_LABEL,
54476 (void*)&&ZEND_NULL_LABEL,
54477 (void*)&&ZEND_NULL_LABEL,
54478 (void*)&&ZEND_NULL_LABEL,
54479 (void*)&&ZEND_NULL_LABEL,
54480 (void*)&&ZEND_NULL_LABEL,
54481 (void*)&&ZEND_NULL_LABEL,
54482 (void*)&&ZEND_NULL_LABEL,
54483 (void*)&&ZEND_NULL_LABEL,
54484 (void*)&&ZEND_NULL_LABEL,
54485 (void*)&&ZEND_NULL_LABEL,
54486 (void*)&&ZEND_NULL_LABEL,
54487 (void*)&&ZEND_NULL_LABEL,
54488 (void*)&&ZEND_NULL_LABEL,
54489 (void*)&&ZEND_NULL_LABEL,
54490 (void*)&&ZEND_NULL_LABEL,
54491 (void*)&&ZEND_NULL_LABEL,
54492 (void*)&&ZEND_NULL_LABEL,
54493 (void*)&&ZEND_NULL_LABEL,
54494 (void*)&&ZEND_NULL_LABEL,
54495 (void*)&&ZEND_NULL_LABEL,
54496 (void*)&&ZEND_NULL_LABEL,
54497 (void*)&&ZEND_NULL_LABEL,
54498 (void*)&&ZEND_NULL_LABEL,
54499 (void*)&&ZEND_NULL_LABEL,
54500 (void*)&&ZEND_NULL_LABEL,
54501 (void*)&&ZEND_NULL_LABEL,
54502 (void*)&&ZEND_NULL_LABEL,
54503 (void*)&&ZEND_NULL_LABEL,
54504 (void*)&&ZEND_NULL_LABEL,
54505 (void*)&&ZEND_NULL_LABEL,
54506 (void*)&&ZEND_NULL_LABEL,
54507 (void*)&&ZEND_NULL_LABEL,
54508 (void*)&&ZEND_NULL_LABEL,
54509 (void*)&&ZEND_NULL_LABEL,
54510 (void*)&&ZEND_NULL_LABEL,
54511 (void*)&&ZEND_NULL_LABEL,
54512 (void*)&&ZEND_NULL_LABEL,
54513 (void*)&&ZEND_NULL_LABEL,
54514 (void*)&&ZEND_NULL_LABEL,
54515 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_LABEL,
54516 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_LABEL,
54517 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
54518 (void*)&&ZEND_NULL_LABEL,
54519 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
54520 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
54521 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
54522 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54523 (void*)&&ZEND_NULL_LABEL,
54524 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54525 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL,
54526 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL,
54527 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54528 (void*)&&ZEND_NULL_LABEL,
54529 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54530 (void*)&&ZEND_NULL_LABEL,
54531 (void*)&&ZEND_NULL_LABEL,
54532 (void*)&&ZEND_NULL_LABEL,
54533 (void*)&&ZEND_NULL_LABEL,
54534 (void*)&&ZEND_NULL_LABEL,
54535 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_LABEL,
54536 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_LABEL,
54537 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
54538 (void*)&&ZEND_NULL_LABEL,
54539 (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_LABEL,
54540 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_LABEL,
54541 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_LABEL,
54542 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
54543 (void*)&&ZEND_NULL_LABEL,
54544 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
54545 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
54546 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
54547 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
54548 (void*)&&ZEND_NULL_LABEL,
54549 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
54550 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL,
54551 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL,
54552 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
54553 (void*)&&ZEND_NULL_LABEL,
54554 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
54555 (void*)&&ZEND_NULL_LABEL,
54556 (void*)&&ZEND_NULL_LABEL,
54557 (void*)&&ZEND_NULL_LABEL,
54558 (void*)&&ZEND_NULL_LABEL,
54559 (void*)&&ZEND_NULL_LABEL,
54560 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_LABEL,
54561 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_LABEL,
54562 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
54563 (void*)&&ZEND_NULL_LABEL,
54564 (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
54565 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
54566 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
54567 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
54568 (void*)&&ZEND_NULL_LABEL,
54569 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_LABEL,
54570 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
54571 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
54572 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54573 (void*)&&ZEND_NULL_LABEL,
54574 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
54575 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL,
54576 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL,
54577 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54578 (void*)&&ZEND_NULL_LABEL,
54579 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
54580 (void*)&&ZEND_NULL_LABEL,
54581 (void*)&&ZEND_NULL_LABEL,
54582 (void*)&&ZEND_NULL_LABEL,
54583 (void*)&&ZEND_NULL_LABEL,
54584 (void*)&&ZEND_NULL_LABEL,
54585 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_LABEL,
54586 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_LABEL,
54587 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_LABEL,
54588 (void*)&&ZEND_NULL_LABEL,
54589 (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_LABEL,
54590 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_LABEL,
54591 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_LABEL,
54592 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_LABEL,
54593 (void*)&&ZEND_NULL_LABEL,
54594 (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_LABEL,
54595 (void*)&&ZEND_NULL_LABEL,
54596 (void*)&&ZEND_NULL_LABEL,
54597 (void*)&&ZEND_NULL_LABEL,
54598 (void*)&&ZEND_NULL_LABEL,
54599 (void*)&&ZEND_NULL_LABEL,
54600 (void*)&&ZEND_NULL_LABEL,
54601 (void*)&&ZEND_NULL_LABEL,
54602 (void*)&&ZEND_NULL_LABEL,
54603 (void*)&&ZEND_NULL_LABEL,
54604 (void*)&&ZEND_NULL_LABEL,
54605 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CONST_LABEL,
54606 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
54607 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL,
54608 (void*)&&ZEND_NULL_LABEL,
54609 (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CV_LABEL,
54610 (void*)&&ZEND_NULL_LABEL,
54611 (void*)&&ZEND_NULL_LABEL,
54612 (void*)&&ZEND_NULL_LABEL,
54613 (void*)&&ZEND_NULL_LABEL,
54614 (void*)&&ZEND_NULL_LABEL,
54615 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CONST_LABEL,
54616 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
54617 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL,
54618 (void*)&&ZEND_NULL_LABEL,
54619 (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CV_LABEL,
54620 (void*)&&ZEND_NULL_LABEL,
54621 (void*)&&ZEND_NULL_LABEL,
54622 (void*)&&ZEND_NULL_LABEL,
54623 (void*)&&ZEND_NULL_LABEL,
54624 (void*)&&ZEND_NULL_LABEL,
54625 (void*)&&ZEND_NULL_LABEL,
54626 (void*)&&ZEND_NULL_LABEL,
54627 (void*)&&ZEND_NULL_LABEL,
54628 (void*)&&ZEND_NULL_LABEL,
54629 (void*)&&ZEND_NULL_LABEL,
54630 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_LABEL,
54631 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
54632 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL,
54633 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_LABEL,
54634 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_LABEL,
54635 (void*)&&ZEND_NULL_LABEL,
54636 (void*)&&ZEND_NULL_LABEL,
54637 (void*)&&ZEND_NULL_LABEL,
54638 (void*)&&ZEND_NULL_LABEL,
54639 (void*)&&ZEND_NULL_LABEL,
54640 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_LABEL,
54641 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
54642 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL,
54643 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_LABEL,
54644 (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_LABEL,
54645 (void*)&&ZEND_NULL_LABEL,
54646 (void*)&&ZEND_NULL_LABEL,
54647 (void*)&&ZEND_NULL_LABEL,
54648 (void*)&&ZEND_NULL_LABEL,
54649 (void*)&&ZEND_NULL_LABEL,
54650 (void*)&&ZEND_NULL_LABEL,
54651 (void*)&&ZEND_NULL_LABEL,
54652 (void*)&&ZEND_NULL_LABEL,
54653 (void*)&&ZEND_NULL_LABEL,
54654 (void*)&&ZEND_NULL_LABEL,
54655 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_LABEL,
54656 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
54657 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL,
54658 (void*)&&ZEND_NULL_LABEL,
54659 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_LABEL,
54660 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_LABEL,
54661 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
54662 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL,
54663 (void*)&&ZEND_NULL_LABEL,
54664 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_LABEL,
54665 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_LABEL,
54666 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
54667 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL,
54668 (void*)&&ZEND_NULL_LABEL,
54669 (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_LABEL,
54670 (void*)&&ZEND_ASSIGN_STATIC_PROP_OP_SPEC_LABEL,
54671 (void*)&&ZEND_NULL_LABEL,
54672 (void*)&&ZEND_NULL_LABEL,
54673 (void*)&&ZEND_NULL_LABEL,
54674 (void*)&&ZEND_NULL_LABEL,
54675 (void*)&&ZEND_NULL_LABEL,
54676 (void*)&&ZEND_NULL_LABEL,
54677 (void*)&&ZEND_NULL_LABEL,
54678 (void*)&&ZEND_NULL_LABEL,
54679 (void*)&&ZEND_NULL_LABEL,
54680 (void*)&&ZEND_NULL_LABEL,
54681 (void*)&&ZEND_NULL_LABEL,
54682 (void*)&&ZEND_NULL_LABEL,
54683 (void*)&&ZEND_ASSIGN_REF_SPEC_VAR_VAR_LABEL,
54684 (void*)&&ZEND_NULL_LABEL,
54685 (void*)&&ZEND_ASSIGN_REF_SPEC_VAR_CV_LABEL,
54686 (void*)&&ZEND_NULL_LABEL,
54687 (void*)&&ZEND_NULL_LABEL,
54688 (void*)&&ZEND_NULL_LABEL,
54689 (void*)&&ZEND_NULL_LABEL,
54690 (void*)&&ZEND_NULL_LABEL,
54691 (void*)&&ZEND_NULL_LABEL,
54692 (void*)&&ZEND_NULL_LABEL,
54693 (void*)&&ZEND_ASSIGN_REF_SPEC_CV_VAR_LABEL,
54694 (void*)&&ZEND_NULL_LABEL,
54695 (void*)&&ZEND_ASSIGN_REF_SPEC_CV_CV_LABEL,
54696 (void*)&&ZEND_QM_ASSIGN_SPEC_CONST_LABEL,
54697 (void*)&&ZEND_QM_ASSIGN_SPEC_TMP_LABEL,
54698 (void*)&&ZEND_QM_ASSIGN_SPEC_VAR_LABEL,
54699 (void*)&&ZEND_NULL_LABEL,
54700 (void*)&&ZEND_QM_ASSIGN_SPEC_CV_LABEL,
54701 (void*)&&ZEND_NULL_LABEL,
54702 (void*)&&ZEND_NULL_LABEL,
54703 (void*)&&ZEND_NULL_LABEL,
54704 (void*)&&ZEND_NULL_LABEL,
54705 (void*)&&ZEND_NULL_LABEL,
54706 (void*)&&ZEND_NULL_LABEL,
54707 (void*)&&ZEND_NULL_LABEL,
54708 (void*)&&ZEND_NULL_LABEL,
54709 (void*)&&ZEND_NULL_LABEL,
54710 (void*)&&ZEND_NULL_LABEL,
54711 (void*)&&ZEND_NULL_LABEL,
54712 (void*)&&ZEND_NULL_LABEL,
54713 (void*)&&ZEND_NULL_LABEL,
54714 (void*)&&ZEND_NULL_LABEL,
54715 (void*)&&ZEND_NULL_LABEL,
54716 (void*)&&ZEND_NULL_LABEL,
54717 (void*)&&ZEND_NULL_LABEL,
54718 (void*)&&ZEND_NULL_LABEL,
54719 (void*)&&ZEND_NULL_LABEL,
54720 (void*)&&ZEND_NULL_LABEL,
54721 (void*)&&ZEND_NULL_LABEL,
54722 (void*)&&ZEND_NULL_LABEL,
54723 (void*)&&ZEND_NULL_LABEL,
54724 (void*)&&ZEND_NULL_LABEL,
54725 (void*)&&ZEND_NULL_LABEL,
54726 (void*)&&ZEND_NULL_LABEL,
54727 (void*)&&ZEND_NULL_LABEL,
54728 (void*)&&ZEND_NULL_LABEL,
54729 (void*)&&ZEND_NULL_LABEL,
54730 (void*)&&ZEND_NULL_LABEL,
54731 (void*)&&ZEND_NULL_LABEL,
54732 (void*)&&ZEND_NULL_LABEL,
54733 (void*)&&ZEND_NULL_LABEL,
54734 (void*)&&ZEND_NULL_LABEL,
54735 (void*)&&ZEND_NULL_LABEL,
54736 (void*)&&ZEND_NULL_LABEL,
54737 (void*)&&ZEND_NULL_LABEL,
54738 (void*)&&ZEND_NULL_LABEL,
54739 (void*)&&ZEND_NULL_LABEL,
54740 (void*)&&ZEND_NULL_LABEL,
54741 (void*)&&ZEND_NULL_LABEL,
54742 (void*)&&ZEND_NULL_LABEL,
54743 (void*)&&ZEND_NULL_LABEL,
54744 (void*)&&ZEND_NULL_LABEL,
54745 (void*)&&ZEND_NULL_LABEL,
54746 (void*)&&ZEND_NULL_LABEL,
54747 (void*)&&ZEND_NULL_LABEL,
54748 (void*)&&ZEND_NULL_LABEL,
54749 (void*)&&ZEND_NULL_LABEL,
54750 (void*)&&ZEND_NULL_LABEL,
54751 (void*)&&ZEND_NULL_LABEL,
54752 (void*)&&ZEND_NULL_LABEL,
54753 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
54754 (void*)&&ZEND_NULL_LABEL,
54755 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
54756 (void*)&&ZEND_NULL_LABEL,
54757 (void*)&&ZEND_NULL_LABEL,
54758 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54759 (void*)&&ZEND_NULL_LABEL,
54760 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54761 (void*)&&ZEND_NULL_LABEL,
54762 (void*)&&ZEND_NULL_LABEL,
54763 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
54764 (void*)&&ZEND_NULL_LABEL,
54765 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
54766 (void*)&&ZEND_NULL_LABEL,
54767 (void*)&&ZEND_NULL_LABEL,
54768 (void*)&&ZEND_NULL_LABEL,
54769 (void*)&&ZEND_NULL_LABEL,
54770 (void*)&&ZEND_NULL_LABEL,
54771 (void*)&&ZEND_NULL_LABEL,
54772 (void*)&&ZEND_NULL_LABEL,
54773 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
54774 (void*)&&ZEND_NULL_LABEL,
54775 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_LABEL,
54776 (void*)&&ZEND_NULL_LABEL,
54777 (void*)&&ZEND_NULL_LABEL,
54778 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
54779 (void*)&&ZEND_NULL_LABEL,
54780 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
54781 (void*)&&ZEND_NULL_LABEL,
54782 (void*)&&ZEND_NULL_LABEL,
54783 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
54784 (void*)&&ZEND_NULL_LABEL,
54785 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
54786 (void*)&&ZEND_NULL_LABEL,
54787 (void*)&&ZEND_NULL_LABEL,
54788 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
54789 (void*)&&ZEND_NULL_LABEL,
54790 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
54791 (void*)&&ZEND_NULL_LABEL,
54792 (void*)&&ZEND_NULL_LABEL,
54793 (void*)&&ZEND_NULL_LABEL,
54794 (void*)&&ZEND_NULL_LABEL,
54795 (void*)&&ZEND_NULL_LABEL,
54796 (void*)&&ZEND_NULL_LABEL,
54797 (void*)&&ZEND_NULL_LABEL,
54798 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
54799 (void*)&&ZEND_NULL_LABEL,
54800 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
54801 (void*)&&ZEND_NULL_LABEL,
54802 (void*)&&ZEND_NULL_LABEL,
54803 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
54804 (void*)&&ZEND_NULL_LABEL,
54805 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_LABEL,
54806 (void*)&&ZEND_NULL_LABEL,
54807 (void*)&&ZEND_NULL_LABEL,
54808 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54809 (void*)&&ZEND_NULL_LABEL,
54810 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
54811 (void*)&&ZEND_NULL_LABEL,
54812 (void*)&&ZEND_NULL_LABEL,
54813 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
54814 (void*)&&ZEND_NULL_LABEL,
54815 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
54816 (void*)&&ZEND_NULL_LABEL,
54817 (void*)&&ZEND_NULL_LABEL,
54818 (void*)&&ZEND_NULL_LABEL,
54819 (void*)&&ZEND_NULL_LABEL,
54820 (void*)&&ZEND_NULL_LABEL,
54821 (void*)&&ZEND_NULL_LABEL,
54822 (void*)&&ZEND_NULL_LABEL,
54823 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_LABEL,
54824 (void*)&&ZEND_NULL_LABEL,
54825 (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_LABEL,
54826 (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_LABEL,
54827 (void*)&&ZEND_NULL_LABEL,
54828 (void*)&&ZEND_NULL_LABEL,
54829 (void*)&&ZEND_NULL_LABEL,
54830 (void*)&&ZEND_NULL_LABEL,
54831 (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_LABEL,
54832 (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_LABEL,
54833 (void*)&&ZEND_NULL_LABEL,
54834 (void*)&&ZEND_NULL_LABEL,
54835 (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_LABEL,
54836 (void*)&&ZEND_PRE_INC_SPEC_CV_RETVAL_USED_LABEL,
54837 (void*)&&ZEND_NULL_LABEL,
54838 (void*)&&ZEND_NULL_LABEL,
54839 (void*)&&ZEND_NULL_LABEL,
54840 (void*)&&ZEND_NULL_LABEL,
54841 (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_LABEL,
54842 (void*)&&ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_LABEL,
54843 (void*)&&ZEND_NULL_LABEL,
54844 (void*)&&ZEND_NULL_LABEL,
54845 (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_LABEL,
54846 (void*)&&ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_LABEL,
54847 (void*)&&ZEND_NULL_LABEL,
54848 (void*)&&ZEND_NULL_LABEL,
54849 (void*)&&ZEND_POST_INC_SPEC_VAR_LABEL,
54850 (void*)&&ZEND_NULL_LABEL,
54851 (void*)&&ZEND_POST_INC_SPEC_CV_LABEL,
54852 (void*)&&ZEND_NULL_LABEL,
54853 (void*)&&ZEND_NULL_LABEL,
54854 (void*)&&ZEND_POST_DEC_SPEC_VAR_LABEL,
54855 (void*)&&ZEND_NULL_LABEL,
54856 (void*)&&ZEND_POST_DEC_SPEC_CV_LABEL,
54857 (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_LABEL,
54858 (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_LABEL,
54859 (void*)&&ZEND_JMP_SPEC_LABEL,
54860 (void*)&&ZEND_JMPZ_SPEC_CONST_LABEL,
54861 (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
54862 (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL,
54863 (void*)&&ZEND_NULL_LABEL,
54864 (void*)&&ZEND_JMPZ_SPEC_CV_LABEL,
54865 (void*)&&ZEND_JMPNZ_SPEC_CONST_LABEL,
54866 (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
54867 (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL,
54868 (void*)&&ZEND_NULL_LABEL,
54869 (void*)&&ZEND_JMPNZ_SPEC_CV_LABEL,
54870 (void*)&&ZEND_JMPZ_EX_SPEC_CONST_LABEL,
54871 (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
54872 (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL,
54873 (void*)&&ZEND_NULL_LABEL,
54874 (void*)&&ZEND_JMPZ_EX_SPEC_CV_LABEL,
54875 (void*)&&ZEND_JMPNZ_EX_SPEC_CONST_LABEL,
54876 (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
54877 (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL,
54878 (void*)&&ZEND_NULL_LABEL,
54879 (void*)&&ZEND_JMPNZ_EX_SPEC_CV_LABEL,
54880 (void*)&&ZEND_CASE_SPEC_TMPVAR_CONST_LABEL,
54881 (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
54882 (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL,
54883 (void*)&&ZEND_NULL_LABEL,
54884 (void*)&&ZEND_CASE_SPEC_TMPVAR_CV_LABEL,
54885 (void*)&&ZEND_CHECK_VAR_SPEC_CV_UNUSED_LABEL,
54886 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
54887 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL,
54888 (void*)&&ZEND_NULL_LABEL,
54889 (void*)&&ZEND_NULL_LABEL,
54890 (void*)&&ZEND_NULL_LABEL,
54891 (void*)&&ZEND_NULL_LABEL,
54892 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_LABEL,
54893 (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
54894 (void*)&&ZEND_NULL_LABEL,
54895 (void*)&&ZEND_NULL_LABEL,
54896 (void*)&&ZEND_CAST_SPEC_CONST_LABEL,
54897 (void*)&&ZEND_CAST_SPEC_TMP_LABEL,
54898 (void*)&&ZEND_CAST_SPEC_VAR_LABEL,
54899 (void*)&&ZEND_NULL_LABEL,
54900 (void*)&&ZEND_CAST_SPEC_CV_LABEL,
54901 (void*)&&ZEND_BOOL_SPEC_CONST_LABEL,
54902 (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
54903 (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL,
54904 (void*)&&ZEND_NULL_LABEL,
54905 (void*)&&ZEND_BOOL_SPEC_CV_LABEL,
54906 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CONST_LABEL,
54907 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
54908 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL,
54909 (void*)&&ZEND_NULL_LABEL,
54910 (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CV_LABEL,
54911 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
54912 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
54913 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
54914 (void*)&&ZEND_NULL_LABEL,
54915 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
54916 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL,
54917 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
54918 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL,
54919 (void*)&&ZEND_NULL_LABEL,
54920 (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL,
54921 (void*)&&ZEND_NULL_LABEL,
54922 (void*)&&ZEND_NULL_LABEL,
54923 (void*)&&ZEND_NULL_LABEL,
54924 (void*)&&ZEND_NULL_LABEL,
54925 (void*)&&ZEND_NULL_LABEL,
54926 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CONST_LABEL,
54927 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
54928 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL,
54929 (void*)&&ZEND_NULL_LABEL,
54930 (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CV_LABEL,
54931 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CONST_LABEL,
54932 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
54933 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL,
54934 (void*)&&ZEND_NULL_LABEL,
54935 (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CV_LABEL,
54936 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CONST_LABEL,
54937 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
54938 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL,
54939 (void*)&&ZEND_NULL_LABEL,
54940 (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CV_LABEL,
54941 (void*)&&ZEND_ROPE_END_SPEC_TMP_CONST_LABEL,
54942 (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
54943 (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL,
54944 (void*)&&ZEND_NULL_LABEL,
54945 (void*)&&ZEND_ROPE_END_SPEC_TMP_CV_LABEL,
54946 (void*)&&ZEND_BEGIN_SILENCE_SPEC_LABEL,
54947 (void*)&&ZEND_END_SILENCE_SPEC_TMP_LABEL,
54948 (void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_LABEL,
54949 (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_LABEL,
54950 (void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_LABEL,
54951 (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
54952 (void*)&&ZEND_DO_FCALL_SPEC_OBSERVER_LABEL,
54953 (void*)&&ZEND_INIT_FCALL_SPEC_CONST_LABEL,
54954 (void*)&&ZEND_RETURN_SPEC_CONST_LABEL,
54955 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
54956 (void*)&&ZEND_RETURN_SPEC_TMP_LABEL,
54957 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
54958 (void*)&&ZEND_RETURN_SPEC_VAR_LABEL,
54959 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
54960 (void*)&&ZEND_NULL_LABEL,
54961 (void*)&&ZEND_NULL_LABEL,
54962 (void*)&&ZEND_RETURN_SPEC_CV_LABEL,
54963 (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL,
54964 (void*)&&ZEND_RECV_SPEC_UNUSED_LABEL,
54965 (void*)&&ZEND_RECV_INIT_SPEC_CONST_LABEL,
54966 (void*)&&ZEND_SEND_VAL_SPEC_CONST_CONST_LABEL,
54967 (void*)&&ZEND_NULL_LABEL,
54968 (void*)&&ZEND_NULL_LABEL,
54969 (void*)&&ZEND_SEND_VAL_SPEC_CONST_UNUSED_LABEL,
54970 (void*)&&ZEND_NULL_LABEL,
54971 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
54972 (void*)&&ZEND_NULL_LABEL,
54973 (void*)&&ZEND_NULL_LABEL,
54974 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_LABEL,
54975 (void*)&&ZEND_NULL_LABEL,
54976 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_CONST_LABEL,
54977 (void*)&&ZEND_NULL_LABEL,
54978 (void*)&&ZEND_NULL_LABEL,
54979 (void*)&&ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_LABEL,
54980 (void*)&&ZEND_NULL_LABEL,
54981 (void*)&&ZEND_NULL_LABEL,
54982 (void*)&&ZEND_NULL_LABEL,
54983 (void*)&&ZEND_NULL_LABEL,
54984 (void*)&&ZEND_NULL_LABEL,
54985 (void*)&&ZEND_NULL_LABEL,
54986 (void*)&&ZEND_NULL_LABEL,
54987 (void*)&&ZEND_NULL_LABEL,
54988 (void*)&&ZEND_NULL_LABEL,
54989 (void*)&&ZEND_NULL_LABEL,
54990 (void*)&&ZEND_NULL_LABEL,
54991 (void*)&&ZEND_NULL_LABEL,
54992 (void*)&&ZEND_NULL_LABEL,
54993 (void*)&&ZEND_NULL_LABEL,
54994 (void*)&&ZEND_NULL_LABEL,
54995 (void*)&&ZEND_NULL_LABEL,
54996 (void*)&&ZEND_NULL_LABEL,
54997 (void*)&&ZEND_NULL_LABEL,
54998 (void*)&&ZEND_NULL_LABEL,
54999 (void*)&&ZEND_NULL_LABEL,
55000 (void*)&&ZEND_NULL_LABEL,
55001 (void*)&&ZEND_NULL_LABEL,
55002 (void*)&&ZEND_NULL_LABEL,
55003 (void*)&&ZEND_NULL_LABEL,
55004 (void*)&&ZEND_NULL_LABEL,
55005 (void*)&&ZEND_NULL_LABEL,
55006 (void*)&&ZEND_NULL_LABEL,
55007 (void*)&&ZEND_NULL_LABEL,
55008 (void*)&&ZEND_NULL_LABEL,
55009 (void*)&&ZEND_NULL_LABEL,
55010 (void*)&&ZEND_NULL_LABEL,
55011 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
55012 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_CONST_LABEL,
55013 (void*)&&ZEND_NULL_LABEL,
55014 (void*)&&ZEND_NULL_LABEL,
55015 (void*)&&ZEND_NULL_LABEL,
55016 (void*)&&ZEND_NULL_LABEL,
55017 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_LABEL,
55018 (void*)&&ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_LABEL,
55019 (void*)&&ZEND_NULL_LABEL,
55020 (void*)&&ZEND_NULL_LABEL,
55021 (void*)&&ZEND_NULL_LABEL,
55022 (void*)&&ZEND_NULL_LABEL,
55023 (void*)&&ZEND_NULL_LABEL,
55024 (void*)&&ZEND_NULL_LABEL,
55025 (void*)&&ZEND_NULL_LABEL,
55026 (void*)&&ZEND_NULL_LABEL,
55027 (void*)&&ZEND_NULL_LABEL,
55028 (void*)&&ZEND_NULL_LABEL,
55029 (void*)&&ZEND_NULL_LABEL,
55030 (void*)&&ZEND_NULL_LABEL,
55031 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
55032 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_CONST_LABEL,
55033 (void*)&&ZEND_NULL_LABEL,
55034 (void*)&&ZEND_NULL_LABEL,
55035 (void*)&&ZEND_NULL_LABEL,
55036 (void*)&&ZEND_NULL_LABEL,
55037 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_LABEL,
55038 (void*)&&ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_LABEL,
55039 (void*)&&ZEND_NULL_LABEL,
55040 (void*)&&ZEND_NULL_LABEL,
55041 (void*)&&ZEND_NULL_LABEL,
55042 (void*)&&ZEND_NULL_LABEL,
55043 (void*)&&ZEND_NULL_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_NULL_LABEL,
55050 (void*)&&ZEND_NULL_LABEL,
55051 (void*)&&ZEND_SEND_REF_SPEC_VAR_CONST_LABEL,
55052 (void*)&&ZEND_NULL_LABEL,
55053 (void*)&&ZEND_NULL_LABEL,
55054 (void*)&&ZEND_SEND_REF_SPEC_VAR_UNUSED_LABEL,
55055 (void*)&&ZEND_NULL_LABEL,
55056 (void*)&&ZEND_NULL_LABEL,
55057 (void*)&&ZEND_NULL_LABEL,
55058 (void*)&&ZEND_NULL_LABEL,
55059 (void*)&&ZEND_NULL_LABEL,
55060 (void*)&&ZEND_NULL_LABEL,
55061 (void*)&&ZEND_SEND_REF_SPEC_CV_CONST_LABEL,
55062 (void*)&&ZEND_NULL_LABEL,
55063 (void*)&&ZEND_NULL_LABEL,
55064 (void*)&&ZEND_SEND_REF_SPEC_CV_UNUSED_LABEL,
55065 (void*)&&ZEND_NULL_LABEL,
55066 (void*)&&ZEND_NEW_SPEC_CONST_UNUSED_LABEL,
55067 (void*)&&ZEND_NULL_LABEL,
55068 (void*)&&ZEND_NEW_SPEC_VAR_UNUSED_LABEL,
55069 (void*)&&ZEND_NEW_SPEC_UNUSED_UNUSED_LABEL,
55070 (void*)&&ZEND_NULL_LABEL,
55071 (void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_LABEL,
55072 (void*)&&ZEND_FREE_SPEC_TMPVAR_LABEL,
55073 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CONST_LABEL,
55074 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
55075 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL,
55076 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_LABEL,
55077 (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CV_LABEL,
55078 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CONST_LABEL,
55079 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
55080 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL,
55081 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_LABEL,
55082 (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CV_LABEL,
55083 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CONST_LABEL,
55084 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
55085 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL,
55086 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_LABEL,
55087 (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CV_LABEL,
55088 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_LABEL,
55089 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
55090 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL,
55091 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_LABEL,
55092 (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CV_LABEL,
55093 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CONST_LABEL,
55094 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
55095 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL,
55096 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_UNUSED_LABEL,
55097 (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CV_LABEL,
55098 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_LABEL,
55099 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
55100 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL,
55101 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_LABEL,
55102 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_LABEL,
55103 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_LABEL,
55104 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
55105 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL,
55106 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_LABEL,
55107 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_LABEL,
55108 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_LABEL,
55109 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
55110 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL,
55111 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_LABEL,
55112 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_LABEL,
55113 (void*)&&ZEND_NULL_LABEL,
55114 (void*)&&ZEND_NULL_LABEL,
55115 (void*)&&ZEND_NULL_LABEL,
55116 (void*)&&ZEND_NULL_LABEL,
55117 (void*)&&ZEND_NULL_LABEL,
55118 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_LABEL,
55119 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
55120 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL,
55121 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_LABEL,
55122 (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_LABEL,
55123 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CONST_LABEL,
55124 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
55125 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
55126 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
55127 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
55128 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
55129 (void*)&&ZEND_NULL_LABEL,
55130 (void*)&&ZEND_NULL_LABEL,
55131 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CV_LABEL,
55132 (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL,
55133 (void*)&&ZEND_UNSET_VAR_SPEC_CONST_UNUSED_LABEL,
55134 (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
55135 (void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
55136 (void*)&&ZEND_NULL_LABEL,
55137 (void*)&&ZEND_UNSET_VAR_SPEC_CV_UNUSED_LABEL,
55138 (void*)&&ZEND_NULL_LABEL,
55139 (void*)&&ZEND_NULL_LABEL,
55140 (void*)&&ZEND_NULL_LABEL,
55141 (void*)&&ZEND_NULL_LABEL,
55142 (void*)&&ZEND_NULL_LABEL,
55143 (void*)&&ZEND_NULL_LABEL,
55144 (void*)&&ZEND_NULL_LABEL,
55145 (void*)&&ZEND_NULL_LABEL,
55146 (void*)&&ZEND_NULL_LABEL,
55147 (void*)&&ZEND_NULL_LABEL,
55148 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CONST_LABEL,
55149 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
55150 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL,
55151 (void*)&&ZEND_NULL_LABEL,
55152 (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CV_LABEL,
55153 (void*)&&ZEND_NULL_LABEL,
55154 (void*)&&ZEND_NULL_LABEL,
55155 (void*)&&ZEND_NULL_LABEL,
55156 (void*)&&ZEND_NULL_LABEL,
55157 (void*)&&ZEND_NULL_LABEL,
55158 (void*)&&ZEND_UNSET_DIM_SPEC_CV_CONST_LABEL,
55159 (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
55160 (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL,
55161 (void*)&&ZEND_NULL_LABEL,
55162 (void*)&&ZEND_UNSET_DIM_SPEC_CV_CV_LABEL,
55163 (void*)&&ZEND_NULL_LABEL,
55164 (void*)&&ZEND_NULL_LABEL,
55165 (void*)&&ZEND_NULL_LABEL,
55166 (void*)&&ZEND_NULL_LABEL,
55167 (void*)&&ZEND_NULL_LABEL,
55168 (void*)&&ZEND_NULL_LABEL,
55169 (void*)&&ZEND_NULL_LABEL,
55170 (void*)&&ZEND_NULL_LABEL,
55171 (void*)&&ZEND_NULL_LABEL,
55172 (void*)&&ZEND_NULL_LABEL,
55173 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CONST_LABEL,
55174 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
55175 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL,
55176 (void*)&&ZEND_NULL_LABEL,
55177 (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CV_LABEL,
55178 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_LABEL,
55179 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55180 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55181 (void*)&&ZEND_NULL_LABEL,
55182 (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CV_LABEL,
55183 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CONST_LABEL,
55184 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
55185 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL,
55186 (void*)&&ZEND_NULL_LABEL,
55187 (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CV_LABEL,
55188 (void*)&&ZEND_FE_RESET_R_SPEC_CONST_LABEL,
55189 (void*)&&ZEND_FE_RESET_R_SPEC_TMP_LABEL,
55190 (void*)&&ZEND_FE_RESET_R_SPEC_VAR_LABEL,
55191 (void*)&&ZEND_NULL_LABEL,
55192 (void*)&&ZEND_FE_RESET_R_SPEC_CV_LABEL,
55193 (void*)&&ZEND_FE_FETCH_R_SPEC_VAR_LABEL,
55194 (void*)&&ZEND_EXIT_SPEC_LABEL,
55195 (void*)&&ZEND_FETCH_R_SPEC_CONST_UNUSED_LABEL,
55196 (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
55197 (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL,
55198 (void*)&&ZEND_NULL_LABEL,
55199 (void*)&&ZEND_FETCH_R_SPEC_CV_UNUSED_LABEL,
55200 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CONST_LABEL,
55201 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
55202 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL,
55203 (void*)&&ZEND_NULL_LABEL,
55204 (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CV_LABEL,
55205 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
55206 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
55207 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
55208 (void*)&&ZEND_NULL_LABEL,
55209 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
55210 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL,
55211 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
55212 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL,
55213 (void*)&&ZEND_NULL_LABEL,
55214 (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL,
55215 (void*)&&ZEND_NULL_LABEL,
55216 (void*)&&ZEND_NULL_LABEL,
55217 (void*)&&ZEND_NULL_LABEL,
55218 (void*)&&ZEND_NULL_LABEL,
55219 (void*)&&ZEND_NULL_LABEL,
55220 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CONST_LABEL,
55221 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
55222 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL,
55223 (void*)&&ZEND_NULL_LABEL,
55224 (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CV_LABEL,
55225 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_LABEL,
55226 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
55227 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL,
55228 (void*)&&ZEND_NULL_LABEL,
55229 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CV_LABEL,
55230 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
55231 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
55232 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
55233 (void*)&&ZEND_NULL_LABEL,
55234 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
55235 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL,
55236 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
55237 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL,
55238 (void*)&&ZEND_NULL_LABEL,
55239 (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL,
55240 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_LABEL,
55241 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
55242 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL,
55243 (void*)&&ZEND_NULL_LABEL,
55244 (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_LABEL,
55245 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CONST_LABEL,
55246 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
55247 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL,
55248 (void*)&&ZEND_NULL_LABEL,
55249 (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CV_LABEL,
55250 (void*)&&ZEND_FETCH_W_SPEC_CONST_UNUSED_LABEL,
55251 (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
55252 (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL,
55253 (void*)&&ZEND_NULL_LABEL,
55254 (void*)&&ZEND_FETCH_W_SPEC_CV_UNUSED_LABEL,
55255 (void*)&&ZEND_NULL_LABEL,
55256 (void*)&&ZEND_NULL_LABEL,
55257 (void*)&&ZEND_NULL_LABEL,
55258 (void*)&&ZEND_NULL_LABEL,
55259 (void*)&&ZEND_NULL_LABEL,
55260 (void*)&&ZEND_NULL_LABEL,
55261 (void*)&&ZEND_NULL_LABEL,
55262 (void*)&&ZEND_NULL_LABEL,
55263 (void*)&&ZEND_NULL_LABEL,
55264 (void*)&&ZEND_NULL_LABEL,
55265 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CONST_LABEL,
55266 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
55267 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL,
55268 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_LABEL,
55269 (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CV_LABEL,
55270 (void*)&&ZEND_NULL_LABEL,
55271 (void*)&&ZEND_NULL_LABEL,
55272 (void*)&&ZEND_NULL_LABEL,
55273 (void*)&&ZEND_NULL_LABEL,
55274 (void*)&&ZEND_NULL_LABEL,
55275 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CONST_LABEL,
55276 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
55277 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL,
55278 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_LABEL,
55279 (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CV_LABEL,
55280 (void*)&&ZEND_NULL_LABEL,
55281 (void*)&&ZEND_NULL_LABEL,
55282 (void*)&&ZEND_NULL_LABEL,
55283 (void*)&&ZEND_NULL_LABEL,
55284 (void*)&&ZEND_NULL_LABEL,
55285 (void*)&&ZEND_NULL_LABEL,
55286 (void*)&&ZEND_NULL_LABEL,
55287 (void*)&&ZEND_NULL_LABEL,
55288 (void*)&&ZEND_NULL_LABEL,
55289 (void*)&&ZEND_NULL_LABEL,
55290 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_LABEL,
55291 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
55292 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL,
55293 (void*)&&ZEND_NULL_LABEL,
55294 (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CV_LABEL,
55295 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_LABEL,
55296 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
55297 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL,
55298 (void*)&&ZEND_NULL_LABEL,
55299 (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_LABEL,
55300 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CONST_LABEL,
55301 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
55302 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL,
55303 (void*)&&ZEND_NULL_LABEL,
55304 (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CV_LABEL,
55305 (void*)&&ZEND_FETCH_RW_SPEC_CONST_UNUSED_LABEL,
55306 (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
55307 (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL,
55308 (void*)&&ZEND_NULL_LABEL,
55309 (void*)&&ZEND_FETCH_RW_SPEC_CV_UNUSED_LABEL,
55310 (void*)&&ZEND_NULL_LABEL,
55311 (void*)&&ZEND_NULL_LABEL,
55312 (void*)&&ZEND_NULL_LABEL,
55313 (void*)&&ZEND_NULL_LABEL,
55314 (void*)&&ZEND_NULL_LABEL,
55315 (void*)&&ZEND_NULL_LABEL,
55316 (void*)&&ZEND_NULL_LABEL,
55317 (void*)&&ZEND_NULL_LABEL,
55318 (void*)&&ZEND_NULL_LABEL,
55319 (void*)&&ZEND_NULL_LABEL,
55320 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_LABEL,
55321 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
55322 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL,
55323 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_LABEL,
55324 (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CV_LABEL,
55325 (void*)&&ZEND_NULL_LABEL,
55326 (void*)&&ZEND_NULL_LABEL,
55327 (void*)&&ZEND_NULL_LABEL,
55328 (void*)&&ZEND_NULL_LABEL,
55329 (void*)&&ZEND_NULL_LABEL,
55330 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CONST_LABEL,
55331 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
55332 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL,
55333 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_LABEL,
55334 (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CV_LABEL,
55335 (void*)&&ZEND_NULL_LABEL,
55336 (void*)&&ZEND_NULL_LABEL,
55337 (void*)&&ZEND_NULL_LABEL,
55338 (void*)&&ZEND_NULL_LABEL,
55339 (void*)&&ZEND_NULL_LABEL,
55340 (void*)&&ZEND_NULL_LABEL,
55341 (void*)&&ZEND_NULL_LABEL,
55342 (void*)&&ZEND_NULL_LABEL,
55343 (void*)&&ZEND_NULL_LABEL,
55344 (void*)&&ZEND_NULL_LABEL,
55345 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_LABEL,
55346 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
55347 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL,
55348 (void*)&&ZEND_NULL_LABEL,
55349 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_LABEL,
55350 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_LABEL,
55351 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
55352 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL,
55353 (void*)&&ZEND_NULL_LABEL,
55354 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_LABEL,
55355 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_LABEL,
55356 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
55357 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL,
55358 (void*)&&ZEND_NULL_LABEL,
55359 (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CV_LABEL,
55360 (void*)&&ZEND_FETCH_IS_SPEC_CONST_UNUSED_LABEL,
55361 (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
55362 (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL,
55363 (void*)&&ZEND_NULL_LABEL,
55364 (void*)&&ZEND_FETCH_IS_SPEC_CV_UNUSED_LABEL,
55365 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_LABEL,
55366 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
55367 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL,
55368 (void*)&&ZEND_NULL_LABEL,
55369 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CV_LABEL,
55370 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
55371 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55372 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55373 (void*)&&ZEND_NULL_LABEL,
55374 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
55375 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL,
55376 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55377 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55378 (void*)&&ZEND_NULL_LABEL,
55379 (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL,
55380 (void*)&&ZEND_NULL_LABEL,
55381 (void*)&&ZEND_NULL_LABEL,
55382 (void*)&&ZEND_NULL_LABEL,
55383 (void*)&&ZEND_NULL_LABEL,
55384 (void*)&&ZEND_NULL_LABEL,
55385 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CONST_LABEL,
55386 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
55387 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL,
55388 (void*)&&ZEND_NULL_LABEL,
55389 (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CV_LABEL,
55390 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_LABEL,
55391 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
55392 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL,
55393 (void*)&&ZEND_NULL_LABEL,
55394 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_LABEL,
55395 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
55396 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55397 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55398 (void*)&&ZEND_NULL_LABEL,
55399 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
55400 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL,
55401 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55402 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL,
55403 (void*)&&ZEND_NULL_LABEL,
55404 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL,
55405 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_LABEL,
55406 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
55407 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL,
55408 (void*)&&ZEND_NULL_LABEL,
55409 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_LABEL,
55410 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_LABEL,
55411 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
55412 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL,
55413 (void*)&&ZEND_NULL_LABEL,
55414 (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CV_LABEL,
55415 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
55416 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
55417 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
55418 (void*)&&ZEND_NULL_LABEL,
55419 (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
55420 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_LABEL,
55421 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
55422 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
55423 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
55424 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_LABEL,
55425 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_LABEL,
55426 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
55427 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
55428 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_LABEL,
55429 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_LABEL,
55430 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_LABEL,
55431 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
55432 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
55433 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
55434 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_LABEL,
55435 (void*)&&ZEND_NULL_LABEL,
55436 (void*)&&ZEND_NULL_LABEL,
55437 (void*)&&ZEND_NULL_LABEL,
55438 (void*)&&ZEND_NULL_LABEL,
55439 (void*)&&ZEND_NULL_LABEL,
55440 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_LABEL,
55441 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
55442 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
55443 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
55444 (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_LABEL,
55445 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_LABEL,
55446 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
55447 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL,
55448 (void*)&&ZEND_NULL_LABEL,
55449 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_LABEL,
55450 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_LABEL,
55451 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
55452 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL,
55453 (void*)&&ZEND_NULL_LABEL,
55454 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_LABEL,
55455 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_LABEL,
55456 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
55457 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL,
55458 (void*)&&ZEND_NULL_LABEL,
55459 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_LABEL,
55460 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
55461 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
55462 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL,
55463 (void*)&&ZEND_NULL_LABEL,
55464 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_LABEL,
55465 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_LABEL,
55466 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
55467 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL,
55468 (void*)&&ZEND_NULL_LABEL,
55469 (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_LABEL,
55470 (void*)&&ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_LABEL,
55471 (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
55472 (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
55473 (void*)&&ZEND_NULL_LABEL,
55474 (void*)&&ZEND_FETCH_UNSET_SPEC_CV_UNUSED_LABEL,
55475 (void*)&&ZEND_NULL_LABEL,
55476 (void*)&&ZEND_NULL_LABEL,
55477 (void*)&&ZEND_NULL_LABEL,
55478 (void*)&&ZEND_NULL_LABEL,
55479 (void*)&&ZEND_NULL_LABEL,
55480 (void*)&&ZEND_NULL_LABEL,
55481 (void*)&&ZEND_NULL_LABEL,
55482 (void*)&&ZEND_NULL_LABEL,
55483 (void*)&&ZEND_NULL_LABEL,
55484 (void*)&&ZEND_NULL_LABEL,
55485 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_LABEL,
55486 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
55487 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL,
55488 (void*)&&ZEND_NULL_LABEL,
55489 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_LABEL,
55490 (void*)&&ZEND_NULL_LABEL,
55491 (void*)&&ZEND_NULL_LABEL,
55492 (void*)&&ZEND_NULL_LABEL,
55493 (void*)&&ZEND_NULL_LABEL,
55494 (void*)&&ZEND_NULL_LABEL,
55495 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_LABEL,
55496 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
55497 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL,
55498 (void*)&&ZEND_NULL_LABEL,
55499 (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_LABEL,
55500 (void*)&&ZEND_NULL_LABEL,
55501 (void*)&&ZEND_NULL_LABEL,
55502 (void*)&&ZEND_NULL_LABEL,
55503 (void*)&&ZEND_NULL_LABEL,
55504 (void*)&&ZEND_NULL_LABEL,
55505 (void*)&&ZEND_NULL_LABEL,
55506 (void*)&&ZEND_NULL_LABEL,
55507 (void*)&&ZEND_NULL_LABEL,
55508 (void*)&&ZEND_NULL_LABEL,
55509 (void*)&&ZEND_NULL_LABEL,
55510 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_LABEL,
55511 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
55512 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL,
55513 (void*)&&ZEND_NULL_LABEL,
55514 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_LABEL,
55515 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_LABEL,
55516 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
55517 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL,
55518 (void*)&&ZEND_NULL_LABEL,
55519 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_LABEL,
55520 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_LABEL,
55521 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
55522 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL,
55523 (void*)&&ZEND_NULL_LABEL,
55524 (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_LABEL,
55525 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CONST_LABEL,
55526 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
55527 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL,
55528 (void*)&&ZEND_NULL_LABEL,
55529 (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CV_LABEL,
55530 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
55531 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55532 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55533 (void*)&&ZEND_NULL_LABEL,
55534 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
55535 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
55536 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55537 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55538 (void*)&&ZEND_NULL_LABEL,
55539 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_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_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL,
55546 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55547 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL,
55548 (void*)&&ZEND_NULL_LABEL,
55549 (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL,
55550 (void*)&&ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_LABEL,
55551 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
55552 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_LABEL,
55553 (void*)&&ZEND_NULL_LABEL,
55554 (void*)&&ZEND_NULL_LABEL,
55555 (void*)&&ZEND_NULL_LABEL,
55556 (void*)&&ZEND_NULL_LABEL,
55557 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_LABEL,
55558 (void*)&&ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_LABEL,
55559 (void*)&&ZEND_NULL_LABEL,
55560 (void*)&&ZEND_NULL_LABEL,
55561 (void*)&&ZEND_EXT_STMT_SPEC_LABEL,
55562 (void*)&&ZEND_EXT_FCALL_BEGIN_SPEC_LABEL,
55563 (void*)&&ZEND_EXT_FCALL_END_SPEC_LABEL,
55564 (void*)&&ZEND_EXT_NOP_SPEC_LABEL,
55565 (void*)&&ZEND_TICKS_SPEC_LABEL,
55566 (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_LABEL,
55567 (void*)&&ZEND_NULL_LABEL,
55568 (void*)&&ZEND_NULL_LABEL,
55569 (void*)&&ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_LABEL,
55570 (void*)&&ZEND_NULL_LABEL,
55571 (void*)&&ZEND_CATCH_SPEC_CONST_LABEL,
55572 (void*)&&ZEND_THROW_SPEC_CONST_LABEL,
55573 (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
55574 (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL,
55575 (void*)&&ZEND_NULL_LABEL,
55576 (void*)&&ZEND_THROW_SPEC_CV_LABEL,
55577 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_LABEL,
55578 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
55579 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL,
55580 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_LABEL,
55581 (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CV_LABEL,
55582 (void*)&&ZEND_CLONE_SPEC_CONST_LABEL,
55583 (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
55584 (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL,
55585 (void*)&&ZEND_CLONE_SPEC_UNUSED_LABEL,
55586 (void*)&&ZEND_CLONE_SPEC_CV_LABEL,
55587 (void*)&&ZEND_RETURN_BY_REF_SPEC_CONST_LABEL,
55588 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
55589 (void*)&&ZEND_RETURN_BY_REF_SPEC_TMP_LABEL,
55590 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
55591 (void*)&&ZEND_RETURN_BY_REF_SPEC_VAR_LABEL,
55592 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
55593 (void*)&&ZEND_NULL_LABEL,
55594 (void*)&&ZEND_NULL_LABEL,
55595 (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_LABEL,
55596 (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL,
55597 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_LABEL,
55598 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
55599 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
55600 (void*)&&ZEND_NULL_LABEL,
55601 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_LABEL,
55602 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
55603 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
55604 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
55605 (void*)&&ZEND_NULL_LABEL,
55606 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
55607 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL,
55608 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
55609 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL,
55610 (void*)&&ZEND_NULL_LABEL,
55611 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL,
55612 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
55613 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
55614 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
55615 (void*)&&ZEND_NULL_LABEL,
55616 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
55617 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_LABEL,
55618 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
55619 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL,
55620 (void*)&&ZEND_NULL_LABEL,
55621 (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CV_LABEL,
55622 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_LABEL,
55623 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
55624 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
55625 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_LABEL,
55626 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_LABEL,
55627 (void*)&&ZEND_NULL_LABEL,
55628 (void*)&&ZEND_NULL_LABEL,
55629 (void*)&&ZEND_NULL_LABEL,
55630 (void*)&&ZEND_NULL_LABEL,
55631 (void*)&&ZEND_NULL_LABEL,
55632 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_LABEL,
55633 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
55634 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL,
55635 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_LABEL,
55636 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_LABEL,
55637 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_LABEL,
55638 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
55639 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL,
55640 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_LABEL,
55641 (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_LABEL,
55642 (void*)&&ZEND_NULL_LABEL,
55643 (void*)&&ZEND_NULL_LABEL,
55644 (void*)&&ZEND_NULL_LABEL,
55645 (void*)&&ZEND_NULL_LABEL,
55646 (void*)&&ZEND_NULL_LABEL,
55647 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_LABEL,
55648 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
55649 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL,
55650 (void*)&&ZEND_NULL_LABEL,
55651 (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_LABEL,
55652 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_LABEL,
55653 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
55654 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL,
55655 (void*)&&ZEND_NULL_LABEL,
55656 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_LABEL,
55657 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
55658 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55659 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55660 (void*)&&ZEND_NULL_LABEL,
55661 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
55662 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL,
55663 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55664 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55665 (void*)&&ZEND_NULL_LABEL,
55666 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL,
55667 (void*)&&ZEND_NULL_LABEL,
55668 (void*)&&ZEND_NULL_LABEL,
55669 (void*)&&ZEND_NULL_LABEL,
55670 (void*)&&ZEND_NULL_LABEL,
55671 (void*)&&ZEND_NULL_LABEL,
55672 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_LABEL,
55673 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
55674 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL,
55675 (void*)&&ZEND_NULL_LABEL,
55676 (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_LABEL,
55677 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
55678 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL,
55679 (void*)&&ZEND_NULL_LABEL,
55680 (void*)&&ZEND_NULL_LABEL,
55681 (void*)&&ZEND_NULL_LABEL,
55682 (void*)&&ZEND_NULL_LABEL,
55683 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_LABEL,
55684 (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_LABEL,
55685 (void*)&&ZEND_NULL_LABEL,
55686 (void*)&&ZEND_NULL_LABEL,
55687 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
55688 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_CONST_LABEL,
55689 (void*)&&ZEND_NULL_LABEL,
55690 (void*)&&ZEND_NULL_LABEL,
55691 (void*)&&ZEND_NULL_LABEL,
55692 (void*)&&ZEND_NULL_LABEL,
55693 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_LABEL,
55694 (void*)&&ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_LABEL,
55695 (void*)&&ZEND_NULL_LABEL,
55696 (void*)&&ZEND_NULL_LABEL,
55697 (void*)&&ZEND_NULL_LABEL,
55698 (void*)&&ZEND_NULL_LABEL,
55699 (void*)&&ZEND_NULL_LABEL,
55700 (void*)&&ZEND_NULL_LABEL,
55701 (void*)&&ZEND_NULL_LABEL,
55702 (void*)&&ZEND_NULL_LABEL,
55703 (void*)&&ZEND_NULL_LABEL,
55704 (void*)&&ZEND_NULL_LABEL,
55705 (void*)&&ZEND_NULL_LABEL,
55706 (void*)&&ZEND_NULL_LABEL,
55707 (void*)&&ZEND_NULL_LABEL,
55708 (void*)&&ZEND_NULL_LABEL,
55709 (void*)&&ZEND_NULL_LABEL,
55710 (void*)&&ZEND_NULL_LABEL,
55711 (void*)&&ZEND_NULL_LABEL,
55712 (void*)&&ZEND_NULL_LABEL,
55713 (void*)&&ZEND_NULL_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_NULL_LABEL,
55735 (void*)&&ZEND_NULL_LABEL,
55736 (void*)&&ZEND_NULL_LABEL,
55737 (void*)&&ZEND_SEND_VAR_SPEC_VAR_CONST_LABEL,
55738 (void*)&&ZEND_NULL_LABEL,
55739 (void*)&&ZEND_NULL_LABEL,
55740 (void*)&&ZEND_SEND_VAR_SPEC_VAR_UNUSED_LABEL,
55741 (void*)&&ZEND_NULL_LABEL,
55742 (void*)&&ZEND_NULL_LABEL,
55743 (void*)&&ZEND_NULL_LABEL,
55744 (void*)&&ZEND_NULL_LABEL,
55745 (void*)&&ZEND_NULL_LABEL,
55746 (void*)&&ZEND_NULL_LABEL,
55747 (void*)&&ZEND_SEND_VAR_SPEC_CV_CONST_LABEL,
55748 (void*)&&ZEND_NULL_LABEL,
55749 (void*)&&ZEND_NULL_LABEL,
55750 (void*)&&ZEND_SEND_VAR_SPEC_CV_UNUSED_LABEL,
55751 (void*)&&ZEND_NULL_LABEL,
55752 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_LABEL,
55753 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
55754 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL,
55755 (void*)&&ZEND_NULL_LABEL,
55756 (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_LABEL,
55757 (void*)&&ZEND_SEND_ARRAY_SPEC_LABEL,
55758 (void*)&&ZEND_SEND_USER_SPEC_CONST_LABEL,
55759 (void*)&&ZEND_SEND_USER_SPEC_TMP_LABEL,
55760 (void*)&&ZEND_SEND_USER_SPEC_VAR_LABEL,
55761 (void*)&&ZEND_NULL_LABEL,
55762 (void*)&&ZEND_SEND_USER_SPEC_CV_LABEL,
55763 (void*)&&ZEND_STRLEN_SPEC_CONST_LABEL,
55764 (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
55765 (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL,
55766 (void*)&&ZEND_NULL_LABEL,
55767 (void*)&&ZEND_STRLEN_SPEC_CV_LABEL,
55768 (void*)&&ZEND_DEFINED_SPEC_CONST_LABEL,
55769 (void*)&&ZEND_TYPE_CHECK_SPEC_CONST_LABEL,
55770 (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
55771 (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL,
55772 (void*)&&ZEND_NULL_LABEL,
55773 (void*)&&ZEND_TYPE_CHECK_SPEC_CV_LABEL,
55774 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_LABEL,
55775 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_LABEL,
55776 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_LABEL,
55777 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_LABEL,
55778 (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_LABEL,
55779 (void*)&&ZEND_FE_RESET_RW_SPEC_CONST_LABEL,
55780 (void*)&&ZEND_FE_RESET_RW_SPEC_TMP_LABEL,
55781 (void*)&&ZEND_FE_RESET_RW_SPEC_VAR_LABEL,
55782 (void*)&&ZEND_NULL_LABEL,
55783 (void*)&&ZEND_FE_RESET_RW_SPEC_CV_LABEL,
55784 (void*)&&ZEND_FE_FETCH_RW_SPEC_VAR_LABEL,
55785 (void*)&&ZEND_FE_FREE_SPEC_TMPVAR_LABEL,
55786 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_LABEL,
55787 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
55788 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL,
55789 (void*)&&ZEND_NULL_LABEL,
55790 (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CV_LABEL,
55791 (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_LABEL,
55792 (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_USED_LABEL,
55793 (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
55794 (void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
55795 (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_LABEL,
55796 (void*)&&ZEND_DO_UCALL_SPEC_RETVAL_USED_LABEL,
55797 (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
55798 (void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
55799 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_LABEL,
55800 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_LABEL,
55801 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_LABEL,
55802 (void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_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_PRE_INC_OBJ_SPEC_VAR_CONST_LABEL,
55814 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
55815 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
55816 (void*)&&ZEND_NULL_LABEL,
55817 (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CV_LABEL,
55818 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
55819 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55820 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55821 (void*)&&ZEND_NULL_LABEL,
55822 (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_LABEL,
55823 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CONST_LABEL,
55824 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
55825 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
55826 (void*)&&ZEND_NULL_LABEL,
55827 (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CV_LABEL,
55828 (void*)&&ZEND_NULL_LABEL,
55829 (void*)&&ZEND_NULL_LABEL,
55830 (void*)&&ZEND_NULL_LABEL,
55831 (void*)&&ZEND_NULL_LABEL,
55832 (void*)&&ZEND_NULL_LABEL,
55833 (void*)&&ZEND_NULL_LABEL,
55834 (void*)&&ZEND_NULL_LABEL,
55835 (void*)&&ZEND_NULL_LABEL,
55836 (void*)&&ZEND_NULL_LABEL,
55837 (void*)&&ZEND_NULL_LABEL,
55838 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CONST_LABEL,
55839 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
55840 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL,
55841 (void*)&&ZEND_NULL_LABEL,
55842 (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CV_LABEL,
55843 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_LABEL,
55844 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55845 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55846 (void*)&&ZEND_NULL_LABEL,
55847 (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_LABEL,
55848 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CONST_LABEL,
55849 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
55850 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL,
55851 (void*)&&ZEND_NULL_LABEL,
55852 (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CV_LABEL,
55853 (void*)&&ZEND_ECHO_SPEC_CONST_LABEL,
55854 (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
55855 (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL,
55856 (void*)&&ZEND_NULL_LABEL,
55857 (void*)&&ZEND_ECHO_SPEC_CV_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_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
55865 (void*)&&ZEND_NULL_LABEL,
55866 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
55867 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
55868 (void*)&&ZEND_NULL_LABEL,
55869 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL,
55870 (void*)&&ZEND_NULL_LABEL,
55871 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL,
55872 (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL,
55873 (void*)&&ZEND_NULL_LABEL,
55874 (void*)&&ZEND_NULL_LABEL,
55875 (void*)&&ZEND_NULL_LABEL,
55876 (void*)&&ZEND_NULL_LABEL,
55877 (void*)&&ZEND_NULL_LABEL,
55878 (void*)&&ZEND_NULL_LABEL,
55879 (void*)&&ZEND_INSTANCEOF_SPEC_CV_CONST_LABEL,
55880 (void*)&&ZEND_NULL_LABEL,
55881 (void*)&&ZEND_INSTANCEOF_SPEC_CV_VAR_LABEL,
55882 (void*)&&ZEND_INSTANCEOF_SPEC_CV_UNUSED_LABEL,
55883 (void*)&&ZEND_NULL_LABEL,
55884 (void*)&&ZEND_GENERATOR_CREATE_SPEC_LABEL,
55885 (void*)&&ZEND_NULL_LABEL,
55886 (void*)&&ZEND_NULL_LABEL,
55887 (void*)&&ZEND_MAKE_REF_SPEC_VAR_UNUSED_LABEL,
55888 (void*)&&ZEND_NULL_LABEL,
55889 (void*)&&ZEND_MAKE_REF_SPEC_CV_UNUSED_LABEL,
55890 (void*)&&ZEND_DECLARE_FUNCTION_SPEC_LABEL,
55891 (void*)&&ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_LABEL,
55892 (void*)&&ZEND_DECLARE_CONST_SPEC_CONST_CONST_LABEL,
55893 (void*)&&ZEND_DECLARE_CLASS_SPEC_CONST_LABEL,
55894 (void*)&&ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_LABEL,
55895 (void*)&&ZEND_DECLARE_ANON_CLASS_SPEC_LABEL,
55896 (void*)&&ZEND_ADD_ARRAY_UNPACK_SPEC_LABEL,
55897 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_LABEL,
55898 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
55899 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL,
55900 (void*)&&ZEND_NULL_LABEL,
55901 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_LABEL,
55902 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
55903 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55904 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55905 (void*)&&ZEND_NULL_LABEL,
55906 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
55907 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL,
55908 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55909 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL,
55910 (void*)&&ZEND_NULL_LABEL,
55911 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL,
55912 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_LABEL,
55913 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55914 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL,
55915 (void*)&&ZEND_NULL_LABEL,
55916 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_LABEL,
55917 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_LABEL,
55918 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
55919 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL,
55920 (void*)&&ZEND_NULL_LABEL,
55921 (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_LABEL,
55922 (void*)&&ZEND_HANDLE_EXCEPTION_SPEC_LABEL,
55923 (void*)&&ZEND_USER_OPCODE_SPEC_LABEL,
55924 (void*)&&ZEND_ASSERT_CHECK_SPEC_LABEL,
55925 (void*)&&ZEND_JMP_SET_SPEC_CONST_LABEL,
55926 (void*)&&ZEND_JMP_SET_SPEC_TMP_LABEL,
55927 (void*)&&ZEND_JMP_SET_SPEC_VAR_LABEL,
55928 (void*)&&ZEND_NULL_LABEL,
55929 (void*)&&ZEND_JMP_SET_SPEC_CV_LABEL,
55930 (void*)&&ZEND_UNSET_CV_SPEC_CV_UNUSED_LABEL,
55931 (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_LABEL,
55932 (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_LABEL,
55933 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CONST_LABEL,
55934 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
55935 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
55936 (void*)&&ZEND_NULL_LABEL,
55937 (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CV_LABEL,
55938 (void*)&&ZEND_SEPARATE_SPEC_VAR_UNUSED_LABEL,
55939 (void*)&&ZEND_NULL_LABEL,
55940 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
55941 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL,
55942 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_LABEL,
55943 (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_CV_LABEL,
55944 (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_LABEL,
55945 (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_LABEL,
55946 (void*)&&ZEND_DISCARD_EXCEPTION_SPEC_LABEL,
55947 (void*)&&ZEND_YIELD_SPEC_CONST_CONST_LABEL,
55948 (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
55949 (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
55950 (void*)&&ZEND_YIELD_SPEC_CONST_UNUSED_LABEL,
55951 (void*)&&ZEND_YIELD_SPEC_CONST_CV_LABEL,
55952 (void*)&&ZEND_YIELD_SPEC_TMP_CONST_LABEL,
55953 (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
55954 (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL,
55955 (void*)&&ZEND_YIELD_SPEC_TMP_UNUSED_LABEL,
55956 (void*)&&ZEND_YIELD_SPEC_TMP_CV_LABEL,
55957 (void*)&&ZEND_YIELD_SPEC_VAR_CONST_LABEL,
55958 (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
55959 (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL,
55960 (void*)&&ZEND_YIELD_SPEC_VAR_UNUSED_LABEL,
55961 (void*)&&ZEND_YIELD_SPEC_VAR_CV_LABEL,
55962 (void*)&&ZEND_YIELD_SPEC_UNUSED_CONST_LABEL,
55963 (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
55964 (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL,
55965 (void*)&&ZEND_YIELD_SPEC_UNUSED_UNUSED_LABEL,
55966 (void*)&&ZEND_YIELD_SPEC_UNUSED_CV_LABEL,
55967 (void*)&&ZEND_YIELD_SPEC_CV_CONST_LABEL,
55968 (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
55969 (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL,
55970 (void*)&&ZEND_YIELD_SPEC_CV_UNUSED_LABEL,
55971 (void*)&&ZEND_YIELD_SPEC_CV_CV_LABEL,
55972 (void*)&&ZEND_GENERATOR_RETURN_SPEC_CONST_LABEL,
55973 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
55974 (void*)&&ZEND_GENERATOR_RETURN_SPEC_TMP_LABEL,
55975 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
55976 (void*)&&ZEND_GENERATOR_RETURN_SPEC_VAR_LABEL,
55977 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
55978 (void*)&&ZEND_NULL_LABEL,
55979 (void*)&&ZEND_NULL_LABEL,
55980 (void*)&&ZEND_GENERATOR_RETURN_SPEC_CV_LABEL,
55981 (void*)&&ZEND_GENERATOR_RETURN_SPEC_OBSERVER_LABEL,
55982 (void*)&&ZEND_FAST_CALL_SPEC_LABEL,
55983 (void*)&&ZEND_FAST_RET_SPEC_LABEL,
55984 (void*)&&ZEND_RECV_VARIADIC_SPEC_UNUSED_LABEL,
55985 (void*)&&ZEND_SEND_UNPACK_SPEC_LABEL,
55986 (void*)&&ZEND_YIELD_FROM_SPEC_CONST_LABEL,
55987 (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
55988 (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL,
55989 (void*)&&ZEND_NULL_LABEL,
55990 (void*)&&ZEND_YIELD_FROM_SPEC_CV_LABEL,
55991 (void*)&&ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_LABEL,
55992 (void*)&&ZEND_BIND_GLOBAL_SPEC_CV_CONST_LABEL,
55993 (void*)&&ZEND_COALESCE_SPEC_CONST_LABEL,
55994 (void*)&&ZEND_COALESCE_SPEC_TMP_LABEL,
55995 (void*)&&ZEND_COALESCE_SPEC_VAR_LABEL,
55996 (void*)&&ZEND_NULL_LABEL,
55997 (void*)&&ZEND_COALESCE_SPEC_CV_LABEL,
55998 (void*)&&ZEND_SPACESHIP_SPEC_CONST_CONST_LABEL,
55999 (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
56000 (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
56001 (void*)&&ZEND_NULL_LABEL,
56002 (void*)&&ZEND_SPACESHIP_SPEC_CONST_CV_LABEL,
56003 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
56004 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
56005 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
56006 (void*)&&ZEND_NULL_LABEL,
56007 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
56008 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
56009 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
56010 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
56011 (void*)&&ZEND_NULL_LABEL,
56012 (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
56013 (void*)&&ZEND_NULL_LABEL,
56014 (void*)&&ZEND_NULL_LABEL,
56015 (void*)&&ZEND_NULL_LABEL,
56016 (void*)&&ZEND_NULL_LABEL,
56017 (void*)&&ZEND_NULL_LABEL,
56018 (void*)&&ZEND_SPACESHIP_SPEC_CV_CONST_LABEL,
56019 (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
56020 (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
56021 (void*)&&ZEND_NULL_LABEL,
56022 (void*)&&ZEND_SPACESHIP_SPEC_CV_CV_LABEL,
56023 (void*)&&ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_LABEL,
56024 (void*)&&ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_LABEL,
56025 (void*)&&ZEND_NULL_LABEL,
56026 (void*)&&ZEND_NULL_LABEL,
56027 (void*)&&ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_LABEL,
56028 (void*)&&ZEND_NULL_LABEL,
56029 (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_LABEL,
56030 (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_LABEL,
56031 (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_LABEL,
56032 (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_LABEL,
56033 (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_LABEL,
56034 (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_LABEL,
56035 (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_LABEL,
56036 (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_LABEL,
56037 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_LABEL,
56038 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
56039 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
56040 (void*)&&ZEND_NULL_LABEL,
56041 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_LABEL,
56042 (void*)&&ZEND_NULL_LABEL,
56043 (void*)&&ZEND_NULL_LABEL,
56044 (void*)&&ZEND_NULL_LABEL,
56045 (void*)&&ZEND_NULL_LABEL,
56046 (void*)&&ZEND_NULL_LABEL,
56047 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_LABEL,
56048 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
56049 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
56050 (void*)&&ZEND_NULL_LABEL,
56051 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_LABEL,
56052 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_LABEL,
56053 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
56054 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
56055 (void*)&&ZEND_NULL_LABEL,
56056 (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_LABEL,
56057 (void*)&&ZEND_NULL_LABEL,
56058 (void*)&&ZEND_NULL_LABEL,
56059 (void*)&&ZEND_NULL_LABEL,
56060 (void*)&&ZEND_NULL_LABEL,
56061 (void*)&&ZEND_NULL_LABEL,
56062 (void*)&&ZEND_BIND_LEXICAL_SPEC_TMP_CV_LABEL,
56063 (void*)&&ZEND_BIND_STATIC_SPEC_CV_LABEL,
56064 (void*)&&ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_LABEL,
56065 (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_LABEL,
56066 (void*)&&ZEND_NULL_LABEL,
56067 (void*)&&ZEND_NULL_LABEL,
56068 (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_LABEL,
56069 (void*)&&ZEND_NULL_LABEL,
56070 (void*)&&ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_LABEL,
56071 (void*)&&ZEND_SWITCH_LONG_SPEC_CONST_CONST_LABEL,
56072 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
56073 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
56074 (void*)&&ZEND_NULL_LABEL,
56075 (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
56076 (void*)&&ZEND_SWITCH_STRING_SPEC_CONST_CONST_LABEL,
56077 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
56078 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
56079 (void*)&&ZEND_NULL_LABEL,
56080 (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
56081 (void*)&&ZEND_IN_ARRAY_SPEC_CONST_CONST_LABEL,
56082 (void*)&&ZEND_IN_ARRAY_SPEC_TMP_CONST_LABEL,
56083 (void*)&&ZEND_IN_ARRAY_SPEC_VAR_CONST_LABEL,
56084 (void*)&&ZEND_NULL_LABEL,
56085 (void*)&&ZEND_IN_ARRAY_SPEC_CV_CONST_LABEL,
56086 (void*)&&ZEND_COUNT_SPEC_CONST_UNUSED_LABEL,
56087 (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
56088 (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL,
56089 (void*)&&ZEND_NULL_LABEL,
56090 (void*)&&ZEND_COUNT_SPEC_CV_UNUSED_LABEL,
56091 (void*)&&ZEND_GET_CLASS_SPEC_CONST_UNUSED_LABEL,
56092 (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
56093 (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL,
56094 (void*)&&ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_LABEL,
56095 (void*)&&ZEND_GET_CLASS_SPEC_CV_UNUSED_LABEL,
56096 (void*)&&ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_LABEL,
56097 (void*)&&ZEND_GET_TYPE_SPEC_CONST_UNUSED_LABEL,
56098 (void*)&&ZEND_GET_TYPE_SPEC_TMP_UNUSED_LABEL,
56099 (void*)&&ZEND_GET_TYPE_SPEC_VAR_UNUSED_LABEL,
56100 (void*)&&ZEND_NULL_LABEL,
56101 (void*)&&ZEND_GET_TYPE_SPEC_CV_UNUSED_LABEL,
56102 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_LABEL,
56103 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
56104 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
56105 (void*)&&ZEND_NULL_LABEL,
56106 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_LABEL,
56107 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
56108 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
56109 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
56110 (void*)&&ZEND_NULL_LABEL,
56111 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
56112 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
56113 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
56114 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
56115 (void*)&&ZEND_NULL_LABEL,
56116 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
56117 (void*)&&ZEND_NULL_LABEL,
56118 (void*)&&ZEND_NULL_LABEL,
56119 (void*)&&ZEND_NULL_LABEL,
56120 (void*)&&ZEND_NULL_LABEL,
56121 (void*)&&ZEND_NULL_LABEL,
56122 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_LABEL,
56123 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
56124 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
56125 (void*)&&ZEND_NULL_LABEL,
56126 (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL,
56127 (void*)&&ZEND_MATCH_SPEC_CONST_CONST_LABEL,
56128 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
56129 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL,
56130 (void*)&&ZEND_NULL_LABEL,
56131 (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_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_CASE_STRICT_SPEC_TMP_CONST_LABEL,
56138 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_TMP_LABEL,
56139 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_VAR_LABEL,
56140 (void*)&&ZEND_NULL_LABEL,
56141 (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CV_LABEL,
56142 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CONST_LABEL,
56143 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_TMP_LABEL,
56144 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_VAR_LABEL,
56145 (void*)&&ZEND_NULL_LABEL,
56146 (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CV_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_MATCH_ERROR_SPEC_CONST_UNUSED_LABEL,
56158 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
56159 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
56160 (void*)&&ZEND_NULL_LABEL,
56161 (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL,
56162 (void*)&&ZEND_JMP_NULL_SPEC_CONST_LABEL,
56163 (void*)&&ZEND_JMP_NULL_SPEC_TMP_LABEL,
56164 (void*)&&ZEND_JMP_NULL_SPEC_VAR_LABEL,
56165 (void*)&&ZEND_NULL_LABEL,
56166 (void*)&&ZEND_JMP_NULL_SPEC_CV_LABEL,
56167 (void*)&&ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_LABEL,
56168 (void*)&&ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_LABEL,
56169 (void*)&&ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_LABEL,
56170 (void*)&&ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_LABEL,
56171 (void*)&&ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_LABEL,
56172 (void*)&&ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_LABEL,
56173 (void*)&&ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_LABEL,
56174 (void*)&&ZEND_FRAMELESS_ICALL_2_SPEC_LABEL,
56175 (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_LABEL,
56176 (void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL,
56177 (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL,
56178 (void*)&&ZEND_NULL_LABEL,
56179 (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
56180 (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL,
56181 (void*)&&ZEND_NULL_LABEL,
56182 (void*)&&ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_LABEL,
56183 (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL,
56184 (void*)&&ZEND_NULL_LABEL,
56185 (void*)&&ZEND_NULL_LABEL,
56186 (void*)&&ZEND_NULL_LABEL,
56187 (void*)&&ZEND_NULL_LABEL,
56188 (void*)&&ZEND_NULL_LABEL,
56189 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56190 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56191 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56192 (void*)&&ZEND_NULL_LABEL,
56193 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56194 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56195 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56196 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56197 (void*)&&ZEND_NULL_LABEL,
56198 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56199 (void*)&&ZEND_NULL_LABEL,
56200 (void*)&&ZEND_NULL_LABEL,
56201 (void*)&&ZEND_NULL_LABEL,
56202 (void*)&&ZEND_NULL_LABEL,
56203 (void*)&&ZEND_NULL_LABEL,
56204 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56205 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56206 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56207 (void*)&&ZEND_NULL_LABEL,
56208 (void*)&&ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56209 (void*)&&ZEND_NULL_LABEL,
56210 (void*)&&ZEND_NULL_LABEL,
56211 (void*)&&ZEND_NULL_LABEL,
56212 (void*)&&ZEND_NULL_LABEL,
56213 (void*)&&ZEND_NULL_LABEL,
56214 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
56215 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56216 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56217 (void*)&&ZEND_NULL_LABEL,
56218 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56219 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
56220 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56221 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56222 (void*)&&ZEND_NULL_LABEL,
56223 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56224 (void*)&&ZEND_NULL_LABEL,
56225 (void*)&&ZEND_NULL_LABEL,
56226 (void*)&&ZEND_NULL_LABEL,
56227 (void*)&&ZEND_NULL_LABEL,
56228 (void*)&&ZEND_NULL_LABEL,
56229 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_LABEL,
56230 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56231 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56232 (void*)&&ZEND_NULL_LABEL,
56233 (void*)&&ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56234 (void*)&&ZEND_NULL_LABEL,
56235 (void*)&&ZEND_NULL_LABEL,
56236 (void*)&&ZEND_NULL_LABEL,
56237 (void*)&&ZEND_NULL_LABEL,
56238 (void*)&&ZEND_NULL_LABEL,
56239 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56240 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56241 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56242 (void*)&&ZEND_NULL_LABEL,
56243 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56244 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56245 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56246 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56247 (void*)&&ZEND_NULL_LABEL,
56248 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56249 (void*)&&ZEND_NULL_LABEL,
56250 (void*)&&ZEND_NULL_LABEL,
56251 (void*)&&ZEND_NULL_LABEL,
56252 (void*)&&ZEND_NULL_LABEL,
56253 (void*)&&ZEND_NULL_LABEL,
56254 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56255 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56256 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56257 (void*)&&ZEND_NULL_LABEL,
56258 (void*)&&ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56259 (void*)&&ZEND_NULL_LABEL,
56260 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
56261 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
56262 (void*)&&ZEND_NULL_LABEL,
56263 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_LABEL,
56264 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56265 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56266 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56267 (void*)&&ZEND_NULL_LABEL,
56268 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56269 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56270 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56271 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56272 (void*)&&ZEND_NULL_LABEL,
56273 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56274 (void*)&&ZEND_NULL_LABEL,
56275 (void*)&&ZEND_NULL_LABEL,
56276 (void*)&&ZEND_NULL_LABEL,
56277 (void*)&&ZEND_NULL_LABEL,
56278 (void*)&&ZEND_NULL_LABEL,
56279 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56280 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56281 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56282 (void*)&&ZEND_NULL_LABEL,
56283 (void*)&&ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56284 (void*)&&ZEND_NULL_LABEL,
56285 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
56286 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
56287 (void*)&&ZEND_NULL_LABEL,
56288 (void*)&&ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_LABEL,
56289 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
56290 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56291 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56292 (void*)&&ZEND_NULL_LABEL,
56293 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56294 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
56295 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56296 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56297 (void*)&&ZEND_NULL_LABEL,
56298 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56299 (void*)&&ZEND_NULL_LABEL,
56300 (void*)&&ZEND_NULL_LABEL,
56301 (void*)&&ZEND_NULL_LABEL,
56302 (void*)&&ZEND_NULL_LABEL,
56303 (void*)&&ZEND_NULL_LABEL,
56304 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_LABEL,
56305 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56306 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56307 (void*)&&ZEND_NULL_LABEL,
56308 (void*)&&ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56309 (void*)&&ZEND_NULL_LABEL,
56310 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56311 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56312 (void*)&&ZEND_NULL_LABEL,
56313 (void*)&&ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56314 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56315 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56316 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56317 (void*)&&ZEND_NULL_LABEL,
56318 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56319 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56320 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56321 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56322 (void*)&&ZEND_NULL_LABEL,
56323 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56324 (void*)&&ZEND_NULL_LABEL,
56325 (void*)&&ZEND_NULL_LABEL,
56326 (void*)&&ZEND_NULL_LABEL,
56327 (void*)&&ZEND_NULL_LABEL,
56328 (void*)&&ZEND_NULL_LABEL,
56329 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56330 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56331 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56332 (void*)&&ZEND_NULL_LABEL,
56333 (void*)&&ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56334 (void*)&&ZEND_NULL_LABEL,
56335 (void*)&&ZEND_NULL_LABEL,
56336 (void*)&&ZEND_NULL_LABEL,
56337 (void*)&&ZEND_NULL_LABEL,
56338 (void*)&&ZEND_NULL_LABEL,
56339 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56340 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56341 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56342 (void*)&&ZEND_NULL_LABEL,
56343 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56344 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56345 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56346 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56347 (void*)&&ZEND_NULL_LABEL,
56348 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56349 (void*)&&ZEND_NULL_LABEL,
56350 (void*)&&ZEND_NULL_LABEL,
56351 (void*)&&ZEND_NULL_LABEL,
56352 (void*)&&ZEND_NULL_LABEL,
56353 (void*)&&ZEND_NULL_LABEL,
56354 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_LABEL,
56355 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56356 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56357 (void*)&&ZEND_NULL_LABEL,
56358 (void*)&&ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_LABEL,
56359 (void*)&&ZEND_NULL_LABEL,
56360 (void*)&&ZEND_NULL_LABEL,
56361 (void*)&&ZEND_NULL_LABEL,
56362 (void*)&&ZEND_NULL_LABEL,
56363 (void*)&&ZEND_NULL_LABEL,
56364 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56365 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56366 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56367 (void*)&&ZEND_NULL_LABEL,
56368 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56369 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56370 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56371 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56372 (void*)&&ZEND_NULL_LABEL,
56373 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56374 (void*)&&ZEND_NULL_LABEL,
56375 (void*)&&ZEND_NULL_LABEL,
56376 (void*)&&ZEND_NULL_LABEL,
56377 (void*)&&ZEND_NULL_LABEL,
56378 (void*)&&ZEND_NULL_LABEL,
56379 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56380 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56381 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56382 (void*)&&ZEND_NULL_LABEL,
56383 (void*)&&ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56384 (void*)&&ZEND_NULL_LABEL,
56385 (void*)&&ZEND_NULL_LABEL,
56386 (void*)&&ZEND_NULL_LABEL,
56387 (void*)&&ZEND_NULL_LABEL,
56388 (void*)&&ZEND_NULL_LABEL,
56389 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56390 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56391 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56392 (void*)&&ZEND_NULL_LABEL,
56393 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56394 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56395 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56396 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56397 (void*)&&ZEND_NULL_LABEL,
56398 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56399 (void*)&&ZEND_NULL_LABEL,
56400 (void*)&&ZEND_NULL_LABEL,
56401 (void*)&&ZEND_NULL_LABEL,
56402 (void*)&&ZEND_NULL_LABEL,
56403 (void*)&&ZEND_NULL_LABEL,
56404 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56405 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56406 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56407 (void*)&&ZEND_NULL_LABEL,
56408 (void*)&&ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_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_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56425 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56426 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56427 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56428 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56429 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56430 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56431 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56432 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56433 (void*)&&ZEND_NULL_LABEL,
56434 (void*)&&ZEND_NULL_LABEL,
56435 (void*)&&ZEND_NULL_LABEL,
56436 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56437 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56438 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56439 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56440 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56441 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56442 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56443 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56444 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56445 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56446 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56447 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56448 (void*)&&ZEND_NULL_LABEL,
56449 (void*)&&ZEND_NULL_LABEL,
56450 (void*)&&ZEND_NULL_LABEL,
56451 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56452 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56453 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56454 (void*)&&ZEND_NULL_LABEL,
56455 (void*)&&ZEND_NULL_LABEL,
56456 (void*)&&ZEND_NULL_LABEL,
56457 (void*)&&ZEND_NULL_LABEL,
56458 (void*)&&ZEND_NULL_LABEL,
56459 (void*)&&ZEND_NULL_LABEL,
56460 (void*)&&ZEND_NULL_LABEL,
56461 (void*)&&ZEND_NULL_LABEL,
56462 (void*)&&ZEND_NULL_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_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56470 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56471 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56472 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56473 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56474 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56475 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56476 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56477 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56478 (void*)&&ZEND_NULL_LABEL,
56479 (void*)&&ZEND_NULL_LABEL,
56480 (void*)&&ZEND_NULL_LABEL,
56481 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56482 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56483 (void*)&&ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56484 (void*)&&ZEND_NULL_LABEL,
56485 (void*)&&ZEND_NULL_LABEL,
56486 (void*)&&ZEND_NULL_LABEL,
56487 (void*)&&ZEND_NULL_LABEL,
56488 (void*)&&ZEND_NULL_LABEL,
56489 (void*)&&ZEND_NULL_LABEL,
56490 (void*)&&ZEND_NULL_LABEL,
56491 (void*)&&ZEND_NULL_LABEL,
56492 (void*)&&ZEND_NULL_LABEL,
56493 (void*)&&ZEND_NULL_LABEL,
56494 (void*)&&ZEND_NULL_LABEL,
56495 (void*)&&ZEND_NULL_LABEL,
56496 (void*)&&ZEND_NULL_LABEL,
56497 (void*)&&ZEND_NULL_LABEL,
56498 (void*)&&ZEND_NULL_LABEL,
56499 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56500 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56501 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56502 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56503 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56504 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56505 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56506 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56507 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56508 (void*)&&ZEND_NULL_LABEL,
56509 (void*)&&ZEND_NULL_LABEL,
56510 (void*)&&ZEND_NULL_LABEL,
56511 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56512 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56513 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56514 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56515 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56516 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56517 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56518 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56519 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56520 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56521 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56522 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56523 (void*)&&ZEND_NULL_LABEL,
56524 (void*)&&ZEND_NULL_LABEL,
56525 (void*)&&ZEND_NULL_LABEL,
56526 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56527 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56528 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56529 (void*)&&ZEND_NULL_LABEL,
56530 (void*)&&ZEND_NULL_LABEL,
56531 (void*)&&ZEND_NULL_LABEL,
56532 (void*)&&ZEND_NULL_LABEL,
56533 (void*)&&ZEND_NULL_LABEL,
56534 (void*)&&ZEND_NULL_LABEL,
56535 (void*)&&ZEND_NULL_LABEL,
56536 (void*)&&ZEND_NULL_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_NULL_LABEL,
56543 (void*)&&ZEND_NULL_LABEL,
56544 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56545 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56546 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56547 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56548 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56549 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56550 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56551 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56552 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56553 (void*)&&ZEND_NULL_LABEL,
56554 (void*)&&ZEND_NULL_LABEL,
56555 (void*)&&ZEND_NULL_LABEL,
56556 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56557 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56558 (void*)&&ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56559 (void*)&&ZEND_NULL_LABEL,
56560 (void*)&&ZEND_NULL_LABEL,
56561 (void*)&&ZEND_NULL_LABEL,
56562 (void*)&&ZEND_NULL_LABEL,
56563 (void*)&&ZEND_NULL_LABEL,
56564 (void*)&&ZEND_NULL_LABEL,
56565 (void*)&&ZEND_NULL_LABEL,
56566 (void*)&&ZEND_NULL_LABEL,
56567 (void*)&&ZEND_NULL_LABEL,
56568 (void*)&&ZEND_NULL_LABEL,
56569 (void*)&&ZEND_NULL_LABEL,
56570 (void*)&&ZEND_NULL_LABEL,
56571 (void*)&&ZEND_NULL_LABEL,
56572 (void*)&&ZEND_NULL_LABEL,
56573 (void*)&&ZEND_NULL_LABEL,
56574 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56575 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56576 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56577 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56578 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56579 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56580 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56581 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56582 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56583 (void*)&&ZEND_NULL_LABEL,
56584 (void*)&&ZEND_NULL_LABEL,
56585 (void*)&&ZEND_NULL_LABEL,
56586 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56587 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56588 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56589 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56590 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56591 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56592 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56593 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56594 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56595 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56596 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56597 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56598 (void*)&&ZEND_NULL_LABEL,
56599 (void*)&&ZEND_NULL_LABEL,
56600 (void*)&&ZEND_NULL_LABEL,
56601 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56602 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56603 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56604 (void*)&&ZEND_NULL_LABEL,
56605 (void*)&&ZEND_NULL_LABEL,
56606 (void*)&&ZEND_NULL_LABEL,
56607 (void*)&&ZEND_NULL_LABEL,
56608 (void*)&&ZEND_NULL_LABEL,
56609 (void*)&&ZEND_NULL_LABEL,
56610 (void*)&&ZEND_NULL_LABEL,
56611 (void*)&&ZEND_NULL_LABEL,
56612 (void*)&&ZEND_NULL_LABEL,
56613 (void*)&&ZEND_NULL_LABEL,
56614 (void*)&&ZEND_NULL_LABEL,
56615 (void*)&&ZEND_NULL_LABEL,
56616 (void*)&&ZEND_NULL_LABEL,
56617 (void*)&&ZEND_NULL_LABEL,
56618 (void*)&&ZEND_NULL_LABEL,
56619 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56620 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56621 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56622 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56623 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56624 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56625 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56626 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56627 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56628 (void*)&&ZEND_NULL_LABEL,
56629 (void*)&&ZEND_NULL_LABEL,
56630 (void*)&&ZEND_NULL_LABEL,
56631 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56632 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56633 (void*)&&ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56634 (void*)&&ZEND_NULL_LABEL,
56635 (void*)&&ZEND_NULL_LABEL,
56636 (void*)&&ZEND_NULL_LABEL,
56637 (void*)&&ZEND_NULL_LABEL,
56638 (void*)&&ZEND_NULL_LABEL,
56639 (void*)&&ZEND_NULL_LABEL,
56640 (void*)&&ZEND_NULL_LABEL,
56641 (void*)&&ZEND_NULL_LABEL,
56642 (void*)&&ZEND_NULL_LABEL,
56643 (void*)&&ZEND_NULL_LABEL,
56644 (void*)&&ZEND_NULL_LABEL,
56645 (void*)&&ZEND_NULL_LABEL,
56646 (void*)&&ZEND_NULL_LABEL,
56647 (void*)&&ZEND_NULL_LABEL,
56648 (void*)&&ZEND_NULL_LABEL,
56649 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56650 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56651 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56652 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56653 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56654 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56655 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56656 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56657 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56658 (void*)&&ZEND_NULL_LABEL,
56659 (void*)&&ZEND_NULL_LABEL,
56660 (void*)&&ZEND_NULL_LABEL,
56661 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56662 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56663 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56664 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56665 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56666 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56667 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56668 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56669 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56670 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56671 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56672 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56673 (void*)&&ZEND_NULL_LABEL,
56674 (void*)&&ZEND_NULL_LABEL,
56675 (void*)&&ZEND_NULL_LABEL,
56676 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56677 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56678 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_LABEL,
56689 (void*)&&ZEND_NULL_LABEL,
56690 (void*)&&ZEND_NULL_LABEL,
56691 (void*)&&ZEND_NULL_LABEL,
56692 (void*)&&ZEND_NULL_LABEL,
56693 (void*)&&ZEND_NULL_LABEL,
56694 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56695 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56696 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56697 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56698 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56699 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56700 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56701 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56702 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56703 (void*)&&ZEND_NULL_LABEL,
56704 (void*)&&ZEND_NULL_LABEL,
56705 (void*)&&ZEND_NULL_LABEL,
56706 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56707 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56708 (void*)&&ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56709 (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
56710 (void*)&&ZEND_NULL_LABEL,
56711 (void*)&&ZEND_NULL_LABEL,
56712 (void*)&&ZEND_NULL_LABEL,
56713 (void*)&&ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
56714 (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_LABEL,
56715 (void*)&&ZEND_NULL_LABEL,
56716 (void*)&&ZEND_NULL_LABEL,
56717 (void*)&&ZEND_NULL_LABEL,
56718 (void*)&&ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_LABEL,
56719 (void*)&&ZEND_NULL_LABEL,
56720 (void*)&&ZEND_NULL_LABEL,
56721 (void*)&&ZEND_NULL_LABEL,
56722 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
56723 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56724 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56725 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
56726 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56727 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56728 (void*)&&ZEND_NULL_LABEL,
56729 (void*)&&ZEND_NULL_LABEL,
56730 (void*)&&ZEND_NULL_LABEL,
56731 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_LABEL,
56732 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56733 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56734 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
56735 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56736 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56737 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56738 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56739 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56740 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56741 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56742 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56743 (void*)&&ZEND_NULL_LABEL,
56744 (void*)&&ZEND_NULL_LABEL,
56745 (void*)&&ZEND_NULL_LABEL,
56746 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56747 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56748 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56749 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
56750 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56751 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56752 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56753 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56754 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56755 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56756 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56757 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56758 (void*)&&ZEND_NULL_LABEL,
56759 (void*)&&ZEND_NULL_LABEL,
56760 (void*)&&ZEND_NULL_LABEL,
56761 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56762 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56763 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56764 (void*)&&ZEND_NULL_LABEL,
56765 (void*)&&ZEND_NULL_LABEL,
56766 (void*)&&ZEND_NULL_LABEL,
56767 (void*)&&ZEND_NULL_LABEL,
56768 (void*)&&ZEND_NULL_LABEL,
56769 (void*)&&ZEND_NULL_LABEL,
56770 (void*)&&ZEND_NULL_LABEL,
56771 (void*)&&ZEND_NULL_LABEL,
56772 (void*)&&ZEND_NULL_LABEL,
56773 (void*)&&ZEND_NULL_LABEL,
56774 (void*)&&ZEND_NULL_LABEL,
56775 (void*)&&ZEND_NULL_LABEL,
56776 (void*)&&ZEND_NULL_LABEL,
56777 (void*)&&ZEND_NULL_LABEL,
56778 (void*)&&ZEND_NULL_LABEL,
56779 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_LABEL,
56780 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56781 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56782 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56783 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56784 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56785 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56786 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56787 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56788 (void*)&&ZEND_NULL_LABEL,
56789 (void*)&&ZEND_NULL_LABEL,
56790 (void*)&&ZEND_NULL_LABEL,
56791 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56792 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56793 (void*)&&ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56794 (void*)&&ZEND_NULL_LABEL,
56795 (void*)&&ZEND_NULL_LABEL,
56796 (void*)&&ZEND_NULL_LABEL,
56797 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56798 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56799 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56800 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56801 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56802 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56803 (void*)&&ZEND_NULL_LABEL,
56804 (void*)&&ZEND_NULL_LABEL,
56805 (void*)&&ZEND_NULL_LABEL,
56806 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56807 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56808 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56809 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56810 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56811 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56812 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56813 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56814 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56815 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56816 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56817 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56818 (void*)&&ZEND_NULL_LABEL,
56819 (void*)&&ZEND_NULL_LABEL,
56820 (void*)&&ZEND_NULL_LABEL,
56821 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56822 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56823 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56824 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56825 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56826 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56827 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56828 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56829 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56830 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56831 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56832 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56833 (void*)&&ZEND_NULL_LABEL,
56834 (void*)&&ZEND_NULL_LABEL,
56835 (void*)&&ZEND_NULL_LABEL,
56836 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56837 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56838 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56839 (void*)&&ZEND_NULL_LABEL,
56840 (void*)&&ZEND_NULL_LABEL,
56841 (void*)&&ZEND_NULL_LABEL,
56842 (void*)&&ZEND_NULL_LABEL,
56843 (void*)&&ZEND_NULL_LABEL,
56844 (void*)&&ZEND_NULL_LABEL,
56845 (void*)&&ZEND_NULL_LABEL,
56846 (void*)&&ZEND_NULL_LABEL,
56847 (void*)&&ZEND_NULL_LABEL,
56848 (void*)&&ZEND_NULL_LABEL,
56849 (void*)&&ZEND_NULL_LABEL,
56850 (void*)&&ZEND_NULL_LABEL,
56851 (void*)&&ZEND_NULL_LABEL,
56852 (void*)&&ZEND_NULL_LABEL,
56853 (void*)&&ZEND_NULL_LABEL,
56854 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56855 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56856 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56857 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56858 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56859 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56860 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56861 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56862 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56863 (void*)&&ZEND_NULL_LABEL,
56864 (void*)&&ZEND_NULL_LABEL,
56865 (void*)&&ZEND_NULL_LABEL,
56866 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56867 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56868 (void*)&&ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56869 (void*)&&ZEND_NULL_LABEL,
56870 (void*)&&ZEND_NULL_LABEL,
56871 (void*)&&ZEND_NULL_LABEL,
56872 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
56873 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56874 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56875 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
56876 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56877 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56878 (void*)&&ZEND_NULL_LABEL,
56879 (void*)&&ZEND_NULL_LABEL,
56880 (void*)&&ZEND_NULL_LABEL,
56881 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_LABEL,
56882 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56883 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56884 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56885 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56886 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56887 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56888 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56889 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56890 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56891 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56892 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56893 (void*)&&ZEND_NULL_LABEL,
56894 (void*)&&ZEND_NULL_LABEL,
56895 (void*)&&ZEND_NULL_LABEL,
56896 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56897 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56898 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56899 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56900 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56901 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56902 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56903 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56904 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56905 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56906 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56907 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56908 (void*)&&ZEND_NULL_LABEL,
56909 (void*)&&ZEND_NULL_LABEL,
56910 (void*)&&ZEND_NULL_LABEL,
56911 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56912 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56913 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56914 (void*)&&ZEND_NULL_LABEL,
56915 (void*)&&ZEND_NULL_LABEL,
56916 (void*)&&ZEND_NULL_LABEL,
56917 (void*)&&ZEND_NULL_LABEL,
56918 (void*)&&ZEND_NULL_LABEL,
56919 (void*)&&ZEND_NULL_LABEL,
56920 (void*)&&ZEND_NULL_LABEL,
56921 (void*)&&ZEND_NULL_LABEL,
56922 (void*)&&ZEND_NULL_LABEL,
56923 (void*)&&ZEND_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_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_LABEL,
56930 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56931 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56932 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56933 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56934 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56935 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56936 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56937 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56938 (void*)&&ZEND_NULL_LABEL,
56939 (void*)&&ZEND_NULL_LABEL,
56940 (void*)&&ZEND_NULL_LABEL,
56941 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_LABEL,
56942 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56943 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56944 (void*)&&ZEND_NULL_LABEL,
56945 (void*)&&ZEND_NULL_LABEL,
56946 (void*)&&ZEND_NULL_LABEL,
56947 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56948 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56949 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56950 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56951 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56952 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56953 (void*)&&ZEND_NULL_LABEL,
56954 (void*)&&ZEND_NULL_LABEL,
56955 (void*)&&ZEND_NULL_LABEL,
56956 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_LABEL,
56957 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_LABEL,
56958 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_LABEL,
56959 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56960 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56961 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56962 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56963 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56964 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56965 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56966 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56967 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56968 (void*)&&ZEND_NULL_LABEL,
56969 (void*)&&ZEND_NULL_LABEL,
56970 (void*)&&ZEND_NULL_LABEL,
56971 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56972 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56973 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56974 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
56975 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
56976 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
56977 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56978 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56979 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56980 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56981 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56982 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56983 (void*)&&ZEND_NULL_LABEL,
56984 (void*)&&ZEND_NULL_LABEL,
56985 (void*)&&ZEND_NULL_LABEL,
56986 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
56987 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
56988 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
56989 (void*)&&ZEND_NULL_LABEL,
56990 (void*)&&ZEND_NULL_LABEL,
56991 (void*)&&ZEND_NULL_LABEL,
56992 (void*)&&ZEND_NULL_LABEL,
56993 (void*)&&ZEND_NULL_LABEL,
56994 (void*)&&ZEND_NULL_LABEL,
56995 (void*)&&ZEND_NULL_LABEL,
56996 (void*)&&ZEND_NULL_LABEL,
56997 (void*)&&ZEND_NULL_LABEL,
56998 (void*)&&ZEND_NULL_LABEL,
56999 (void*)&&ZEND_NULL_LABEL,
57000 (void*)&&ZEND_NULL_LABEL,
57001 (void*)&&ZEND_NULL_LABEL,
57002 (void*)&&ZEND_NULL_LABEL,
57003 (void*)&&ZEND_NULL_LABEL,
57004 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_LABEL,
57005 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_LABEL,
57006 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_LABEL,
57007 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57008 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57009 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57010 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57011 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57012 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57013 (void*)&&ZEND_NULL_LABEL,
57014 (void*)&&ZEND_NULL_LABEL,
57015 (void*)&&ZEND_NULL_LABEL,
57016 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
57017 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
57018 (void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
57019 (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
57020 (void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
57021 (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
57022 (void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_LABEL,
57023 (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
57024 (void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
57025 (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
57026 (void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_LABEL,
57027 (void*)&&ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
57028 (void*)&&ZEND_POST_INC_LONG_SPEC_CV_LABEL,
57029 (void*)&&ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
57030 (void*)&&ZEND_POST_DEC_LONG_SPEC_CV_LABEL,
57031 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_CONST_LABEL,
57032 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
57033 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
57034 (void*)&&ZEND_NULL_LABEL,
57035 (void*)&&ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_LABEL,
57036 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_LABEL,
57037 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
57038 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
57039 (void*)&&ZEND_NULL_LABEL,
57040 (void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
57041 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_CONST_LABEL,
57042 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
57043 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
57044 (void*)&&ZEND_NULL_LABEL,
57045 (void*)&&ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_LABEL,
57046 (void*)&&ZEND_NULL_LABEL,
57047 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
57048 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
57049 (void*)&&ZEND_NULL_LABEL,
57050 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_LABEL,
57051 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
57052 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57053 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57054 (void*)&&ZEND_NULL_LABEL,
57055 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57056 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_LABEL,
57057 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57058 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57059 (void*)&&ZEND_NULL_LABEL,
57060 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_LABEL,
57061 (void*)&&ZEND_NULL_LABEL,
57062 (void*)&&ZEND_NULL_LABEL,
57063 (void*)&&ZEND_NULL_LABEL,
57064 (void*)&&ZEND_NULL_LABEL,
57065 (void*)&&ZEND_NULL_LABEL,
57066 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_LABEL,
57067 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
57068 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
57069 (void*)&&ZEND_NULL_LABEL,
57070 (void*)&&ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_LABEL,
57071 (void*)&&ZEND_NULL_LABEL,
57072 (void*)&&ZEND_NULL_LABEL,
57073 (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_VAR_LABEL,
57074 (void*)&&ZEND_NULL_LABEL,
57075 (void*)&&ZEND_SEND_VAR_SIMPLE_SPEC_CV_LABEL,
57076 (void*)&&ZEND_NULL_LABEL,
57077 (void*)&&ZEND_NULL_LABEL,
57078 (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_LABEL,
57079 (void*)&&ZEND_NULL_LABEL,
57080 (void*)&&ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_LABEL,
57081 (void*)&&ZEND_SEND_VAL_SIMPLE_SPEC_CONST_LABEL,
57082 (void*)&&ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_LABEL,
57083 (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_LABEL,
57084 (void*)&&ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_LABEL,
57085 (void*)&&ZEND_NULL_LABEL
57086 };
57087 zend_opcode_handlers = (const void **) labels;
57088 zend_handlers_count = sizeof(labels) / sizeof(void*);
57089 memset(&hybrid_halt_op, 0, sizeof(hybrid_halt_op));
57090 hybrid_halt_op.handler = (void*)&&HYBRID_HALT_LABEL;
57091 #ifdef ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE
57092 memset(vm_stack_data.hybrid_jit_red_zone, 0, ZEND_VM_HYBRID_JIT_RED_ZONE_SIZE);
57093 #endif
57094 if (zend_touch_vm_stack_data) {
57095 zend_touch_vm_stack_data(&vm_stack_data);
57096 }
57097 goto HYBRID_HALT_LABEL;
57098 }
57099 #endif
57100
57101 LOAD_OPLINE();
57102 ZEND_VM_LOOP_INTERRUPT_CHECK();
57103
57104 #ifdef ZEND_CHECK_STACK_LIMIT
57105 if (UNEXPECTED(zend_call_stack_overflowed(EG(stack_limit)))) {
57106 zend_call_stack_size_error();
57107 /* No opline was executed before exception */
57108 EG(opline_before_exception) = NULL;
57109 LOAD_OPLINE();
57110 /* Fall through to handle exception below. */
57111 }
57112 #endif /* ZEND_CHECK_STACK_LIMIT */
57113
57114 while (1) {
57115 #if !defined(ZEND_VM_FP_GLOBAL_REG) || !defined(ZEND_VM_IP_GLOBAL_REG)
57116 int ret;
57117 #endif
57118 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
57119 HYBRID_SWITCH() {
57120 #else
57121 #if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
57122 ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57123 if (UNEXPECTED(!OPLINE)) {
57124 #else
57125 if (UNEXPECTED((ret = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)) != 0)) {
57126 #endif
57127 #endif
57128 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
57129 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC):
57130 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
57131 ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57132 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_OP_SPEC)
57133 HYBRID_BREAK();
57134 HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC):
57135 VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC)
57136 ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57137 VM_TRACE_OP_END(ZEND_PRE_INC_STATIC_PROP_SPEC)
57138 HYBRID_BREAK();
57139 HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC):
57140 VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC)
57141 ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57142 VM_TRACE_OP_END(ZEND_POST_INC_STATIC_PROP_SPEC)
57143 HYBRID_BREAK();
57144 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC):
57145 VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC)
57146 ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57147 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_R_SPEC)
57148 HYBRID_BREAK();
57149 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_W_SPEC):
57150 VM_TRACE(ZEND_FETCH_STATIC_PROP_W_SPEC)
57151 ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57152 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_W_SPEC)
57153 HYBRID_BREAK();
57154 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_RW_SPEC):
57155 VM_TRACE(ZEND_FETCH_STATIC_PROP_RW_SPEC)
57156 ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57157 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_RW_SPEC)
57158 HYBRID_BREAK();
57159 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC):
57160 VM_TRACE(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
57161 ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57162 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC)
57163 HYBRID_BREAK();
57164 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC):
57165 VM_TRACE(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
57166 ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57167 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_UNSET_SPEC)
57168 HYBRID_BREAK();
57169 HYBRID_CASE(ZEND_FETCH_STATIC_PROP_IS_SPEC):
57170 VM_TRACE(ZEND_FETCH_STATIC_PROP_IS_SPEC)
57171 ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57172 VM_TRACE_OP_END(ZEND_FETCH_STATIC_PROP_IS_SPEC)
57173 HYBRID_BREAK();
57174 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST):
57175 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
57176 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57177 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST)
57178 HYBRID_BREAK();
57179 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP):
57180 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
57181 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57182 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP)
57183 HYBRID_BREAK();
57184 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR):
57185 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
57186 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57187 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR)
57188 HYBRID_BREAK();
57189 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV):
57190 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
57191 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57192 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV)
57193 HYBRID_BREAK();
57194 HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC):
57195 VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
57196 ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57197 VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_REF_SPEC)
57198 HYBRID_BREAK();
57199 zend_leave_helper_SPEC_LABEL:
57200 {
57201 zend_execute_data *old_execute_data;
57202 uint32_t call_info = EX_CALL_INFO();
57203 SAVE_OPLINE();
57204
57205 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)) {
57206 EG(current_execute_data) = EX(prev_execute_data);
57207 i_free_compiled_variables(execute_data);
57208
57209 #ifdef ZEND_PREFER_RELOAD
57210 call_info = EX_CALL_INFO();
57211 #endif
57212 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
57213 OBJ_RELEASE(Z_OBJ(execute_data->This));
57214 } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
57215 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
57216 }
57217 EG(vm_stack_top) = (zval*)execute_data;
57218 execute_data = EX(prev_execute_data);
57219
57220 if (UNEXPECTED(EG(exception) != NULL)) {
57221 zend_rethrow_exception(execute_data);
57222 HANDLE_EXCEPTION_LEAVE();
57223 }
57224
57225 LOAD_NEXT_OPLINE();
57226 ZEND_VM_LEAVE();
57227 } else if (EXPECTED((call_info & (ZEND_CALL_CODE|ZEND_CALL_TOP)) == 0)) {
57228 EG(current_execute_data) = EX(prev_execute_data);
57229 i_free_compiled_variables(execute_data);
57230
57231 #ifdef ZEND_PREFER_RELOAD
57232 call_info = EX_CALL_INFO();
57233 #endif
57234 if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
57235 zend_clean_and_cache_symbol_table(EX(symbol_table));
57236 }
57237
57238 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
57239 zend_free_extra_named_params(EX(extra_named_params));
57240 }
57241
57242 /* Free extra args before releasing the closure,
57243 * as that may free the op_array. */
57244 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
57245
57246 if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
57247 OBJ_RELEASE(Z_OBJ(execute_data->This));
57248 } else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
57249 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
57250 }
57251
57252 old_execute_data = execute_data;
57253 execute_data = EX(prev_execute_data);
57254 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
57255
57256 if (UNEXPECTED(EG(exception) != NULL)) {
57257 zend_rethrow_exception(execute_data);
57258 HANDLE_EXCEPTION_LEAVE();
57259 }
57260
57261 LOAD_NEXT_OPLINE();
57262 ZEND_VM_LEAVE();
57263 } else if (EXPECTED((call_info & ZEND_CALL_TOP) == 0)) {
57264 if (EX(func)->op_array.last_var > 0) {
57265 zend_detach_symbol_table(execute_data);
57266 call_info |= ZEND_CALL_NEEDS_REATTACH;
57267 }
57268 zend_destroy_static_vars(&EX(func)->op_array);
57269 destroy_op_array(&EX(func)->op_array);
57270 efree_size(EX(func), sizeof(zend_op_array));
57271 old_execute_data = execute_data;
57272 execute_data = EG(current_execute_data) = EX(prev_execute_data);
57273 zend_vm_stack_free_call_frame_ex(call_info, old_execute_data);
57274
57275 if (call_info & ZEND_CALL_NEEDS_REATTACH) {
57276 if (EX(func)->op_array.last_var > 0) {
57277 zend_attach_symbol_table(execute_data);
57278 } else {
57279 ZEND_ADD_CALL_FLAG(execute_data, ZEND_CALL_NEEDS_REATTACH);
57280 }
57281 }
57282 if (UNEXPECTED(EG(exception) != NULL)) {
57283 zend_rethrow_exception(execute_data);
57284 HANDLE_EXCEPTION_LEAVE();
57285 }
57286
57287 LOAD_NEXT_OPLINE();
57288 ZEND_VM_LEAVE();
57289 } else {
57290 if (EXPECTED((call_info & ZEND_CALL_CODE) == 0)) {
57291 EG(current_execute_data) = EX(prev_execute_data);
57292 i_free_compiled_variables(execute_data);
57293 #ifdef ZEND_PREFER_RELOAD
57294 call_info = EX_CALL_INFO();
57295 #endif
57296 if (UNEXPECTED(call_info & (ZEND_CALL_HAS_SYMBOL_TABLE|ZEND_CALL_FREE_EXTRA_ARGS|ZEND_CALL_HAS_EXTRA_NAMED_PARAMS))) {
57297 if (UNEXPECTED(call_info & ZEND_CALL_HAS_SYMBOL_TABLE)) {
57298 zend_clean_and_cache_symbol_table(EX(symbol_table));
57299 }
57300 zend_vm_stack_free_extra_args_ex(call_info, execute_data);
57301 if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
57302 zend_free_extra_named_params(EX(extra_named_params));
57303 }
57304 }
57305 if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
57306 OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
57307 }
57308 ZEND_VM_RETURN();
57309 } else /* if (call_kind == ZEND_CALL_TOP_CODE) */ {
57310 zend_array *symbol_table = EX(symbol_table);
57311
57312 if (EX(func)->op_array.last_var > 0) {
57313 zend_detach_symbol_table(execute_data);
57314 call_info |= ZEND_CALL_NEEDS_REATTACH;
57315 }
57316 if (call_info & ZEND_CALL_NEEDS_REATTACH) {
57317 old_execute_data = EX(prev_execute_data);
57318 while (old_execute_data) {
57319 if (old_execute_data->func && (ZEND_CALL_INFO(old_execute_data) & ZEND_CALL_HAS_SYMBOL_TABLE)) {
57320 if (old_execute_data->symbol_table == symbol_table) {
57321 if (old_execute_data->func->op_array.last_var > 0) {
57322 zend_attach_symbol_table(old_execute_data);
57323 } else {
57324 ZEND_ADD_CALL_FLAG(old_execute_data, ZEND_CALL_NEEDS_REATTACH);
57325 }
57326 }
57327 break;
57328 }
57329 old_execute_data = old_execute_data->prev_execute_data;
57330 }
57331 }
57332 EG(current_execute_data) = EX(prev_execute_data);
57333 ZEND_VM_RETURN();
57334 }
57335 }
57336 }
57337
57338 HYBRID_CASE(ZEND_JMP_SPEC):
57339 VM_TRACE(ZEND_JMP_SPEC)
57340 ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57341 VM_TRACE_OP_END(ZEND_JMP_SPEC)
57342 HYBRID_BREAK();
57343 HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED):
57344 VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
57345 ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57346 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_UNUSED)
57347 HYBRID_BREAK();
57348 HYBRID_CASE(ZEND_DO_ICALL_SPEC_RETVAL_USED):
57349 VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_USED)
57350 ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57351 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_RETVAL_USED)
57352 HYBRID_BREAK();
57353 HYBRID_CASE(ZEND_DO_ICALL_SPEC_OBSERVER):
57354 VM_TRACE(ZEND_DO_ICALL_SPEC_OBSERVER)
57355 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57356 VM_TRACE_OP_END(ZEND_DO_ICALL_SPEC_OBSERVER)
57357 HYBRID_BREAK();
57358 HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED):
57359 VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
57360 ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57361 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
57362 HYBRID_BREAK();
57363 HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_USED):
57364 VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_USED)
57365 ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57366 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_RETVAL_USED)
57367 HYBRID_BREAK();
57368 HYBRID_CASE(ZEND_DO_UCALL_SPEC_OBSERVER):
57369 VM_TRACE(ZEND_DO_UCALL_SPEC_OBSERVER)
57370 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57371 VM_TRACE_OP_END(ZEND_DO_UCALL_SPEC_OBSERVER)
57372 HYBRID_BREAK();
57373 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED):
57374 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
57375 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57376 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
57377 HYBRID_BREAK();
57378 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED):
57379 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
57380 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57381 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
57382 HYBRID_BREAK();
57383 HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER):
57384 VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
57385 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57386 VM_TRACE_OP_END(ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER)
57387 HYBRID_BREAK();
57388 HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED):
57389 VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
57390 ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57391 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
57392 HYBRID_BREAK();
57393 HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_USED):
57394 VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_USED)
57395 ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57396 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_RETVAL_USED)
57397 HYBRID_BREAK();
57398 HYBRID_CASE(ZEND_DO_FCALL_SPEC_OBSERVER):
57399 VM_TRACE(ZEND_DO_FCALL_SPEC_OBSERVER)
57400 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57401 VM_TRACE_OP_END(ZEND_DO_FCALL_SPEC_OBSERVER)
57402 HYBRID_BREAK();
57403 HYBRID_CASE(ZEND_GENERATOR_CREATE_SPEC):
57404 VM_TRACE(ZEND_GENERATOR_CREATE_SPEC)
57405 ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57406 VM_TRACE_OP_END(ZEND_GENERATOR_CREATE_SPEC)
57407 HYBRID_BREAK();
57408 HYBRID_CASE(ZEND_SEND_UNPACK_SPEC):
57409 VM_TRACE(ZEND_SEND_UNPACK_SPEC)
57410 ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57411 VM_TRACE_OP_END(ZEND_SEND_UNPACK_SPEC)
57412 HYBRID_BREAK();
57413 HYBRID_CASE(ZEND_SEND_ARRAY_SPEC):
57414 VM_TRACE(ZEND_SEND_ARRAY_SPEC)
57415 ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57416 VM_TRACE_OP_END(ZEND_SEND_ARRAY_SPEC)
57417 HYBRID_BREAK();
57418 HYBRID_CASE(ZEND_RECV_NOTYPE_SPEC):
57419 VM_TRACE(ZEND_RECV_NOTYPE_SPEC)
57420 ZEND_RECV_NOTYPE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57421 VM_TRACE_OP_END(ZEND_RECV_NOTYPE_SPEC)
57422 HYBRID_BREAK();
57423 HYBRID_CASE(ZEND_ADD_ARRAY_UNPACK_SPEC):
57424 VM_TRACE(ZEND_ADD_ARRAY_UNPACK_SPEC)
57425 ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57426 VM_TRACE_OP_END(ZEND_ADD_ARRAY_UNPACK_SPEC)
57427 HYBRID_BREAK();
57428 HYBRID_CASE(ZEND_UNSET_STATIC_PROP_SPEC):
57429 VM_TRACE(ZEND_UNSET_STATIC_PROP_SPEC)
57430 ZEND_UNSET_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57431 VM_TRACE_OP_END(ZEND_UNSET_STATIC_PROP_SPEC)
57432 HYBRID_BREAK();
57433 HYBRID_CASE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC):
57434 VM_TRACE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
57435 ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57436 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC)
57437 HYBRID_BREAK();
57438 HYBRID_CASE(ZEND_EXIT_SPEC):
57439 VM_TRACE(ZEND_EXIT_SPEC)
57440 ZEND_EXIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57441 VM_TRACE_OP_END(ZEND_EXIT_SPEC)
57442 HYBRID_BREAK();
57443 HYBRID_CASE(ZEND_BEGIN_SILENCE_SPEC):
57444 VM_TRACE(ZEND_BEGIN_SILENCE_SPEC)
57445 ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57446 VM_TRACE_OP_END(ZEND_BEGIN_SILENCE_SPEC)
57447 HYBRID_BREAK();
57448 HYBRID_CASE(ZEND_EXT_STMT_SPEC):
57449 VM_TRACE(ZEND_EXT_STMT_SPEC)
57450 ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57451 VM_TRACE_OP_END(ZEND_EXT_STMT_SPEC)
57452 HYBRID_BREAK();
57453 HYBRID_CASE(ZEND_EXT_FCALL_BEGIN_SPEC):
57454 VM_TRACE(ZEND_EXT_FCALL_BEGIN_SPEC)
57455 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57456 VM_TRACE_OP_END(ZEND_EXT_FCALL_BEGIN_SPEC)
57457 HYBRID_BREAK();
57458 HYBRID_CASE(ZEND_EXT_FCALL_END_SPEC):
57459 VM_TRACE(ZEND_EXT_FCALL_END_SPEC)
57460 ZEND_EXT_FCALL_END_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57461 VM_TRACE_OP_END(ZEND_EXT_FCALL_END_SPEC)
57462 HYBRID_BREAK();
57463 HYBRID_CASE(ZEND_DECLARE_ANON_CLASS_SPEC):
57464 VM_TRACE(ZEND_DECLARE_ANON_CLASS_SPEC)
57465 ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57466 VM_TRACE_OP_END(ZEND_DECLARE_ANON_CLASS_SPEC)
57467 HYBRID_BREAK();
57468 HYBRID_CASE(ZEND_DECLARE_FUNCTION_SPEC):
57469 VM_TRACE(ZEND_DECLARE_FUNCTION_SPEC)
57470 ZEND_DECLARE_FUNCTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57471 VM_TRACE_OP_END(ZEND_DECLARE_FUNCTION_SPEC)
57472 HYBRID_BREAK();
57473 HYBRID_CASE(ZEND_TICKS_SPEC):
57474 VM_TRACE(ZEND_TICKS_SPEC)
57475 ZEND_TICKS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57476 VM_TRACE_OP_END(ZEND_TICKS_SPEC)
57477 HYBRID_BREAK();
57478 HYBRID_CASE(ZEND_EXT_NOP_SPEC):
57479 VM_TRACE(ZEND_EXT_NOP_SPEC)
57480 ZEND_EXT_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57481 VM_TRACE_OP_END(ZEND_EXT_NOP_SPEC)
57482 HYBRID_BREAK();
57483 HYBRID_CASE(ZEND_NOP_SPEC):
57484 VM_TRACE(ZEND_NOP_SPEC)
57485 ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57486 VM_TRACE_OP_END(ZEND_NOP_SPEC)
57487 HYBRID_BREAK();
57488 HYBRID_CASE(ZEND_HANDLE_EXCEPTION_SPEC):
57489 VM_TRACE(ZEND_HANDLE_EXCEPTION_SPEC)
57490 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57491 VM_TRACE_OP_END(ZEND_HANDLE_EXCEPTION_SPEC)
57492 HYBRID_BREAK();
57493 HYBRID_CASE(ZEND_USER_OPCODE_SPEC):
57494 VM_TRACE(ZEND_USER_OPCODE_SPEC)
57495 ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57496 VM_TRACE_OP_END(ZEND_USER_OPCODE_SPEC)
57497 HYBRID_BREAK();
57498 HYBRID_CASE(ZEND_DISCARD_EXCEPTION_SPEC):
57499 VM_TRACE(ZEND_DISCARD_EXCEPTION_SPEC)
57500 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57501 VM_TRACE_OP_END(ZEND_DISCARD_EXCEPTION_SPEC)
57502 HYBRID_BREAK();
57503 HYBRID_CASE(ZEND_FAST_CALL_SPEC):
57504 VM_TRACE(ZEND_FAST_CALL_SPEC)
57505 ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57506 VM_TRACE_OP_END(ZEND_FAST_CALL_SPEC)
57507 HYBRID_BREAK();
57508 HYBRID_CASE(ZEND_FAST_RET_SPEC):
57509 VM_TRACE(ZEND_FAST_RET_SPEC)
57510 ZEND_FAST_RET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57511 VM_TRACE_OP_END(ZEND_FAST_RET_SPEC)
57512 HYBRID_BREAK();
57513 HYBRID_CASE(ZEND_ASSERT_CHECK_SPEC):
57514 VM_TRACE(ZEND_ASSERT_CHECK_SPEC)
57515 ZEND_ASSERT_CHECK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57516 VM_TRACE_OP_END(ZEND_ASSERT_CHECK_SPEC)
57517 HYBRID_BREAK();
57518 HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC):
57519 VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC)
57520 ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57521 VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC)
57522 HYBRID_BREAK();
57523 HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER):
57524 VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
57525 ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57526 VM_TRACE_OP_END(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
57527 HYBRID_BREAK();
57528 HYBRID_CASE(ZEND_FRAMELESS_ICALL_2_SPEC):
57529 VM_TRACE(ZEND_FRAMELESS_ICALL_2_SPEC)
57530 ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57531 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_2_SPEC)
57532 HYBRID_BREAK();
57533 HYBRID_CASE(ZEND_FRAMELESS_ICALL_3_SPEC):
57534 VM_TRACE(ZEND_FRAMELESS_ICALL_3_SPEC)
57535 ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57536 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_3_SPEC)
57537 HYBRID_BREAK();
57538 HYBRID_CASE(ZEND_JMP_FORWARD_SPEC):
57539 VM_TRACE(ZEND_JMP_FORWARD_SPEC)
57540 ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57541 VM_TRACE_OP_END(ZEND_JMP_FORWARD_SPEC)
57542 HYBRID_BREAK();
57543 HYBRID_CASE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST):
57544 VM_TRACE(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
57545 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57546 VM_TRACE_OP_END(ZEND_INIT_FCALL_BY_NAME_SPEC_CONST)
57547 HYBRID_BREAK();
57548 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST):
57549 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
57550 ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57551 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CONST)
57552 HYBRID_BREAK();
57553 HYBRID_CASE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST):
57554 VM_TRACE(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
57555 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57556 VM_TRACE_OP_END(ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST)
57557 HYBRID_BREAK();
57558 HYBRID_CASE(ZEND_INIT_FCALL_SPEC_CONST):
57559 VM_TRACE(ZEND_INIT_FCALL_SPEC_CONST)
57560 ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57561 VM_TRACE_OP_END(ZEND_INIT_FCALL_SPEC_CONST)
57562 HYBRID_BREAK();
57563 HYBRID_CASE(ZEND_RECV_INIT_SPEC_CONST):
57564 VM_TRACE(ZEND_RECV_INIT_SPEC_CONST)
57565 ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57566 VM_TRACE_OP_END(ZEND_RECV_INIT_SPEC_CONST)
57567 HYBRID_BREAK();
57568 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR):
57569 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
57570 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57571 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
57572 HYBRID_BREAK();
57573 HYBRID_CASE(ZEND_RECV_SPEC_UNUSED):
57574 VM_TRACE(ZEND_RECV_SPEC_UNUSED)
57575 ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57576 VM_TRACE_OP_END(ZEND_RECV_SPEC_UNUSED)
57577 HYBRID_BREAK();
57578 HYBRID_CASE(ZEND_RECV_VARIADIC_SPEC_UNUSED):
57579 VM_TRACE(ZEND_RECV_VARIADIC_SPEC_UNUSED)
57580 ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57581 VM_TRACE_OP_END(ZEND_RECV_VARIADIC_SPEC_UNUSED)
57582 HYBRID_BREAK();
57583 HYBRID_CASE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED):
57584 VM_TRACE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
57585 ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57586 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
57587 HYBRID_BREAK();
57588 HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV):
57589 VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
57590 ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57591 VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_CV)
57592 HYBRID_BREAK();
57593 HYBRID_CASE(ZEND_BW_NOT_SPEC_CONST):
57594 VM_TRACE(ZEND_BW_NOT_SPEC_CONST)
57595 ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57596 VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_CONST)
57597 HYBRID_BREAK();
57598 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CONST):
57599 VM_TRACE(ZEND_BOOL_NOT_SPEC_CONST)
57600 ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57601 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CONST)
57602 HYBRID_BREAK();
57603 HYBRID_CASE(ZEND_ECHO_SPEC_CONST):
57604 VM_TRACE(ZEND_ECHO_SPEC_CONST)
57605 ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57606 VM_TRACE_OP_END(ZEND_ECHO_SPEC_CONST)
57607 HYBRID_BREAK();
57608 HYBRID_CASE(ZEND_JMPZ_SPEC_CONST):
57609 VM_TRACE(ZEND_JMPZ_SPEC_CONST)
57610 ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57611 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CONST)
57612 HYBRID_BREAK();
57613 HYBRID_CASE(ZEND_JMPNZ_SPEC_CONST):
57614 VM_TRACE(ZEND_JMPNZ_SPEC_CONST)
57615 ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57616 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CONST)
57617 HYBRID_BREAK();
57618 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CONST):
57619 VM_TRACE(ZEND_JMPZ_EX_SPEC_CONST)
57620 ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57621 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CONST)
57622 HYBRID_BREAK();
57623 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CONST):
57624 VM_TRACE(ZEND_JMPNZ_EX_SPEC_CONST)
57625 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57626 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CONST)
57627 HYBRID_BREAK();
57628 HYBRID_CASE(ZEND_RETURN_SPEC_CONST):
57629 VM_TRACE(ZEND_RETURN_SPEC_CONST)
57630 {
57631 USE_OPLINE
57632 zval *retval_ptr;
57633 zval *return_value;
57634
57635 retval_ptr = RT_CONSTANT(opline, opline->op1);
57636 return_value = EX(return_value);
57637
57638 if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
57639 SAVE_OPLINE();
57640 retval_ptr = ZVAL_UNDEFINED_OP1();
57641 if (return_value) {
57642 ZVAL_NULL(return_value);
57643 }
57644 } else if (!return_value) {
57645 if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
57646 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
57647 SAVE_OPLINE();
57648 rc_dtor_func(Z_COUNTED_P(retval_ptr));
57649 }
57650 }
57651 } else {
57652 if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
57653 ZVAL_COPY_VALUE(return_value, retval_ptr);
57654 if (IS_CONST == IS_CONST) {
57655 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
57656 Z_ADDREF_P(return_value);
57657 }
57658 }
57659 } else if (IS_CONST == IS_CV) {
57660 do {
57661 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57662 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
57663 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
57664 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
57665 ZVAL_COPY_VALUE(return_value, retval_ptr);
57666 if (GC_MAY_LEAK(ref)) {
57667 SAVE_OPLINE();
57668 gc_possible_root(ref);
57669 }
57670 ZVAL_NULL(retval_ptr);
57671 break;
57672 } else {
57673 Z_ADDREF_P(retval_ptr);
57674 }
57675 } else {
57676 retval_ptr = Z_REFVAL_P(retval_ptr);
57677 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57678 Z_ADDREF_P(retval_ptr);
57679 }
57680 }
57681 }
57682 ZVAL_COPY_VALUE(return_value, retval_ptr);
57683 } while (0);
57684 } else /* if (IS_CONST == IS_VAR) */ {
57685 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
57686 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
57687
57688 retval_ptr = Z_REFVAL_P(retval_ptr);
57689 ZVAL_COPY_VALUE(return_value, retval_ptr);
57690 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
57691 efree_size(ref, sizeof(zend_reference));
57692 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57693 Z_ADDREF_P(retval_ptr);
57694 }
57695 } else {
57696 ZVAL_COPY_VALUE(return_value, retval_ptr);
57697 }
57698 }
57699 }
57700
57701
57702
57703 goto zend_leave_helper_SPEC_LABEL;
57704 }
57705
57706 VM_TRACE_OP_END(ZEND_RETURN_SPEC_CONST)
57707 HYBRID_CASE(ZEND_RETURN_SPEC_OBSERVER):
57708 VM_TRACE(ZEND_RETURN_SPEC_OBSERVER)
57709 {
57710 USE_OPLINE
57711 zval *retval_ptr;
57712 zval *return_value;
57713 zval observer_retval;
57714
57715 retval_ptr = get_zval_ptr_undef(opline->op1_type, opline->op1, BP_VAR_R);
57716 return_value = EX(return_value);
57717 if (!return_value) { return_value = &observer_retval; };
57718 if (opline->op1_type == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
57719 SAVE_OPLINE();
57720 retval_ptr = ZVAL_UNDEFINED_OP1();
57721 if (return_value) {
57722 ZVAL_NULL(return_value);
57723 }
57724 } else if (!return_value) {
57725 if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
57726 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
57727 SAVE_OPLINE();
57728 rc_dtor_func(Z_COUNTED_P(retval_ptr));
57729 }
57730 }
57731 } else {
57732 if ((opline->op1_type & (IS_CONST|IS_TMP_VAR))) {
57733 ZVAL_COPY_VALUE(return_value, retval_ptr);
57734 if (opline->op1_type == IS_CONST) {
57735 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
57736 Z_ADDREF_P(return_value);
57737 }
57738 }
57739 } else if (opline->op1_type == IS_CV) {
57740 do {
57741 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57742 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
57743 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
57744 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
57745 ZVAL_COPY_VALUE(return_value, retval_ptr);
57746 if (GC_MAY_LEAK(ref)) {
57747 SAVE_OPLINE();
57748 gc_possible_root(ref);
57749 }
57750 ZVAL_NULL(retval_ptr);
57751 break;
57752 } else {
57753 Z_ADDREF_P(retval_ptr);
57754 }
57755 } else {
57756 retval_ptr = Z_REFVAL_P(retval_ptr);
57757 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57758 Z_ADDREF_P(retval_ptr);
57759 }
57760 }
57761 }
57762 ZVAL_COPY_VALUE(return_value, retval_ptr);
57763 } while (0);
57764 } else /* if (opline->op1_type == IS_VAR) */ {
57765 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
57766 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
57767
57768 retval_ptr = Z_REFVAL_P(retval_ptr);
57769 ZVAL_COPY_VALUE(return_value, retval_ptr);
57770 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
57771 efree_size(ref, sizeof(zend_reference));
57772 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
57773 Z_ADDREF_P(retval_ptr);
57774 }
57775 } else {
57776 ZVAL_COPY_VALUE(return_value, retval_ptr);
57777 }
57778 }
57779 }
57780 SAVE_OPLINE();
57781 zend_observer_fcall_end(execute_data, return_value);
57782 if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); };
57783 goto zend_leave_helper_SPEC_LABEL;
57784 }
57785
57786 VM_TRACE_OP_END(ZEND_RETURN_SPEC_OBSERVER)
57787 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CONST):
57788 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CONST)
57789 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57790 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CONST)
57791 HYBRID_BREAK();
57792 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_OBSERVER):
57793 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
57794 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57795 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_OBSERVER)
57796 HYBRID_BREAK();
57797 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CONST):
57798 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CONST)
57799 ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57800 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CONST)
57801 HYBRID_BREAK();
57802 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER):
57803 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
57804 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57805 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_OBSERVER)
57806 HYBRID_BREAK();
57807 HYBRID_CASE(ZEND_THROW_SPEC_CONST):
57808 VM_TRACE(ZEND_THROW_SPEC_CONST)
57809 ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57810 VM_TRACE_OP_END(ZEND_THROW_SPEC_CONST)
57811 HYBRID_BREAK();
57812 HYBRID_CASE(ZEND_CATCH_SPEC_CONST):
57813 VM_TRACE(ZEND_CATCH_SPEC_CONST)
57814 ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57815 VM_TRACE_OP_END(ZEND_CATCH_SPEC_CONST)
57816 HYBRID_BREAK();
57817 HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST):
57818 VM_TRACE(ZEND_SEND_USER_SPEC_CONST)
57819 ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57820 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST)
57821 HYBRID_BREAK();
57822 HYBRID_CASE(ZEND_BOOL_SPEC_CONST):
57823 VM_TRACE(ZEND_BOOL_SPEC_CONST)
57824 ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57825 VM_TRACE_OP_END(ZEND_BOOL_SPEC_CONST)
57826 HYBRID_BREAK();
57827 HYBRID_CASE(ZEND_CLONE_SPEC_CONST):
57828 VM_TRACE(ZEND_CLONE_SPEC_CONST)
57829 ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57830 VM_TRACE_OP_END(ZEND_CLONE_SPEC_CONST)
57831 HYBRID_BREAK();
57832 HYBRID_CASE(ZEND_CAST_SPEC_CONST):
57833 VM_TRACE(ZEND_CAST_SPEC_CONST)
57834 ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57835 VM_TRACE_OP_END(ZEND_CAST_SPEC_CONST)
57836 HYBRID_BREAK();
57837 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST):
57838 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
57839 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57840 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
57841 HYBRID_BREAK();
57842 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER):
57843 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
57844 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57845 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER)
57846 HYBRID_BREAK();
57847 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CONST):
57848 VM_TRACE(ZEND_FE_RESET_R_SPEC_CONST)
57849 ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57850 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CONST)
57851 HYBRID_BREAK();
57852 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CONST):
57853 VM_TRACE(ZEND_FE_RESET_RW_SPEC_CONST)
57854 ZEND_FE_RESET_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57855 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CONST)
57856 HYBRID_BREAK();
57857 HYBRID_CASE(ZEND_JMP_SET_SPEC_CONST):
57858 VM_TRACE(ZEND_JMP_SET_SPEC_CONST)
57859 ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57860 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CONST)
57861 HYBRID_BREAK();
57862 HYBRID_CASE(ZEND_COALESCE_SPEC_CONST):
57863 VM_TRACE(ZEND_COALESCE_SPEC_CONST)
57864 ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57865 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CONST)
57866 HYBRID_BREAK();
57867 HYBRID_CASE(ZEND_JMP_NULL_SPEC_CONST):
57868 VM_TRACE(ZEND_JMP_NULL_SPEC_CONST)
57869 ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57870 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CONST)
57871 HYBRID_BREAK();
57872 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CONST):
57873 VM_TRACE(ZEND_QM_ASSIGN_SPEC_CONST)
57874 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57875 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CONST)
57876 HYBRID_BREAK();
57877 HYBRID_CASE(ZEND_DECLARE_CLASS_SPEC_CONST):
57878 VM_TRACE(ZEND_DECLARE_CLASS_SPEC_CONST)
57879 ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57880 VM_TRACE_OP_END(ZEND_DECLARE_CLASS_SPEC_CONST)
57881 HYBRID_BREAK();
57882 HYBRID_CASE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST):
57883 VM_TRACE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
57884 ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57885 VM_TRACE_OP_END(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST)
57886 HYBRID_BREAK();
57887 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CONST):
57888 VM_TRACE(ZEND_YIELD_FROM_SPEC_CONST)
57889 ZEND_YIELD_FROM_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57890 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CONST)
57891 HYBRID_BREAK();
57892 HYBRID_CASE(ZEND_STRLEN_SPEC_CONST):
57893 VM_TRACE(ZEND_STRLEN_SPEC_CONST)
57894 ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57895 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CONST)
57896 HYBRID_BREAK();
57897 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CONST):
57898 VM_TRACE(ZEND_TYPE_CHECK_SPEC_CONST)
57899 ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57900 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CONST)
57901 HYBRID_BREAK();
57902 HYBRID_CASE(ZEND_DEFINED_SPEC_CONST):
57903 VM_TRACE(ZEND_DEFINED_SPEC_CONST)
57904 ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57905 VM_TRACE_OP_END(ZEND_DEFINED_SPEC_CONST)
57906 HYBRID_BREAK();
57907 HYBRID_CASE(ZEND_JMP_FRAMELESS_SPEC_CONST):
57908 VM_TRACE(ZEND_JMP_FRAMELESS_SPEC_CONST)
57909 ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57910 VM_TRACE_OP_END(ZEND_JMP_FRAMELESS_SPEC_CONST)
57911 HYBRID_BREAK();
57912 HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_CONST):
57913 VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
57914 ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57915 VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_CONST)
57916 HYBRID_BREAK();
57917 HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST):
57918 VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
57919 ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57920 VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST)
57921 HYBRID_BREAK();
57922 HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST):
57923 VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
57924 ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57925 VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_CONST)
57926 HYBRID_BREAK();
57927 HYBRID_CASE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST):
57928 VM_TRACE(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
57929 ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57930 VM_TRACE_OP_END(ZEND_SEND_VAL_SIMPLE_SPEC_CONST)
57931 HYBRID_BREAK();
57932 HYBRID_CASE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST):
57933 VM_TRACE(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
57934 ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57935 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST)
57936 HYBRID_BREAK();
57937 HYBRID_CASE(ZEND_ADD_SPEC_CONST_CONST):
57938 VM_TRACE(ZEND_ADD_SPEC_CONST_CONST)
57939 ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57940 VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_CONST)
57941 HYBRID_BREAK();
57942 HYBRID_CASE(ZEND_SUB_SPEC_CONST_CONST):
57943 VM_TRACE(ZEND_SUB_SPEC_CONST_CONST)
57944 ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57945 VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_CONST)
57946 HYBRID_BREAK();
57947 HYBRID_CASE(ZEND_MUL_SPEC_CONST_CONST):
57948 VM_TRACE(ZEND_MUL_SPEC_CONST_CONST)
57949 ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57950 VM_TRACE_OP_END(ZEND_MUL_SPEC_CONST_CONST)
57951 HYBRID_BREAK();
57952 HYBRID_CASE(ZEND_DIV_SPEC_CONST_CONST):
57953 VM_TRACE(ZEND_DIV_SPEC_CONST_CONST)
57954 ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57955 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CONST)
57956 HYBRID_BREAK();
57957 HYBRID_CASE(ZEND_MOD_SPEC_CONST_CONST):
57958 VM_TRACE(ZEND_MOD_SPEC_CONST_CONST)
57959 ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57960 VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_CONST)
57961 HYBRID_BREAK();
57962 HYBRID_CASE(ZEND_SL_SPEC_CONST_CONST):
57963 VM_TRACE(ZEND_SL_SPEC_CONST_CONST)
57964 ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57965 VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_CONST)
57966 HYBRID_BREAK();
57967 HYBRID_CASE(ZEND_SR_SPEC_CONST_CONST):
57968 VM_TRACE(ZEND_SR_SPEC_CONST_CONST)
57969 ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57970 VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_CONST)
57971 HYBRID_BREAK();
57972 HYBRID_CASE(ZEND_POW_SPEC_CONST_CONST):
57973 VM_TRACE(ZEND_POW_SPEC_CONST_CONST)
57974 ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57975 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CONST)
57976 HYBRID_BREAK();
57977 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST):
57978 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
57979 ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57980 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CONST_CONST)
57981 HYBRID_BREAK();
57982 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST):
57983 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
57984 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57985 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST)
57986 HYBRID_BREAK();
57987 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CONST_CONST):
57988 VM_TRACE(ZEND_IS_EQUAL_SPEC_CONST_CONST)
57989 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57990 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CONST_CONST)
57991 HYBRID_BREAK();
57992 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST):
57993 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
57994 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
57995 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST)
57996 HYBRID_BREAK();
57997 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_CONST):
57998 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_CONST)
57999 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58000 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_CONST)
58001 HYBRID_BREAK();
58002 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST):
58003 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
58004 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58005 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST)
58006 HYBRID_BREAK();
58007 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CONST):
58008 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CONST)
58009 ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58010 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CONST)
58011 HYBRID_BREAK();
58012 HYBRID_CASE(ZEND_BW_OR_SPEC_CONST_CONST):
58013 VM_TRACE(ZEND_BW_OR_SPEC_CONST_CONST)
58014 ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58015 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_CONST_CONST)
58016 HYBRID_BREAK();
58017 HYBRID_CASE(ZEND_BW_AND_SPEC_CONST_CONST):
58018 VM_TRACE(ZEND_BW_AND_SPEC_CONST_CONST)
58019 ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58020 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_CONST_CONST)
58021 HYBRID_BREAK();
58022 HYBRID_CASE(ZEND_BW_XOR_SPEC_CONST_CONST):
58023 VM_TRACE(ZEND_BW_XOR_SPEC_CONST_CONST)
58024 ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58025 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_CONST_CONST)
58026 HYBRID_BREAK();
58027 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CONST_CONST):
58028 VM_TRACE(ZEND_BOOL_XOR_SPEC_CONST_CONST)
58029 ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58030 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CONST_CONST)
58031 HYBRID_BREAK();
58032 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST):
58033 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
58034 ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58035 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
58036 HYBRID_BREAK();
58037 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST):
58038 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
58039 ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58040 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CONST)
58041 HYBRID_BREAK();
58042 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST):
58043 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
58044 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58045 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST)
58046 HYBRID_BREAK();
58047 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST):
58048 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
58049 ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58050 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST)
58051 HYBRID_BREAK();
58052 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST):
58053 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
58054 ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58055 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST)
58056 HYBRID_BREAK();
58057 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST):
58058 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
58059 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58060 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST)
58061 HYBRID_BREAK();
58062 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST):
58063 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
58064 ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58065 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
58066 HYBRID_BREAK();
58067 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CONST):
58068 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
58069 ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58070 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
58071 HYBRID_BREAK();
58072 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST):
58073 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
58074 ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58075 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST)
58076 HYBRID_BREAK();
58077 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST):
58078 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
58079 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58080 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST)
58081 HYBRID_BREAK();
58082 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST):
58083 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
58084 ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58085 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CONST)
58086 HYBRID_BREAK();
58087 HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_CONST):
58088 VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_CONST)
58089 ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58090 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_CONST)
58091 HYBRID_BREAK();
58092 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST):
58093 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
58094 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58095 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_CONST)
58096 HYBRID_BREAK();
58097 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST):
58098 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
58099 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58100 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST)
58101 HYBRID_BREAK();
58102 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST):
58103 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
58104 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58105 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST)
58106 HYBRID_BREAK();
58107 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CONST):
58108 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
58109 ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58110 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CONST)
58111 HYBRID_BREAK();
58112 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST):
58113 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
58114 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58115 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST)
58116 HYBRID_BREAK();
58117 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST):
58118 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
58119 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58120 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
58121 HYBRID_BREAK();
58122 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST):
58123 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
58124 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58125 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
58126 HYBRID_BREAK();
58127 HYBRID_CASE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST):
58128 VM_TRACE(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
58129 ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58130 VM_TRACE_OP_END(ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST)
58131 HYBRID_BREAK();
58132 HYBRID_CASE(ZEND_DECLARE_CONST_SPEC_CONST_CONST):
58133 VM_TRACE(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
58134 ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58135 VM_TRACE_OP_END(ZEND_DECLARE_CONST_SPEC_CONST_CONST)
58136 HYBRID_BREAK();
58137 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CONST):
58138 VM_TRACE(ZEND_YIELD_SPEC_CONST_CONST)
58139 ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58140 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CONST)
58141 HYBRID_BREAK();
58142 HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_CONST_CONST):
58143 VM_TRACE(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
58144 ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58145 VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_CONST_CONST)
58146 HYBRID_BREAK();
58147 HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_CONST_CONST):
58148 VM_TRACE(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
58149 ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58150 VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_CONST_CONST)
58151 HYBRID_BREAK();
58152 HYBRID_CASE(ZEND_MATCH_SPEC_CONST_CONST):
58153 VM_TRACE(ZEND_MATCH_SPEC_CONST_CONST)
58154 ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58155 VM_TRACE_OP_END(ZEND_MATCH_SPEC_CONST_CONST)
58156 HYBRID_BREAK();
58157 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CONST_CONST):
58158 VM_TRACE(ZEND_IN_ARRAY_SPEC_CONST_CONST)
58159 ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58160 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CONST_CONST)
58161 HYBRID_BREAK();
58162 HYBRID_CASE(ZEND_ADD_SPEC_CONST_TMPVARCV):
58163 VM_TRACE(ZEND_ADD_SPEC_CONST_TMPVARCV)
58164 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58165 VM_TRACE_OP_END(ZEND_ADD_SPEC_CONST_TMPVARCV)
58166 HYBRID_BREAK();
58167 HYBRID_CASE(ZEND_SUB_SPEC_CONST_TMPVARCV):
58168 VM_TRACE(ZEND_SUB_SPEC_CONST_TMPVARCV)
58169 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58170 VM_TRACE_OP_END(ZEND_SUB_SPEC_CONST_TMPVARCV)
58171 HYBRID_BREAK();
58172 HYBRID_CASE(ZEND_MOD_SPEC_CONST_TMPVARCV):
58173 VM_TRACE(ZEND_MOD_SPEC_CONST_TMPVARCV)
58174 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58175 VM_TRACE_OP_END(ZEND_MOD_SPEC_CONST_TMPVARCV)
58176 HYBRID_BREAK();
58177 HYBRID_CASE(ZEND_SL_SPEC_CONST_TMPVARCV):
58178 VM_TRACE(ZEND_SL_SPEC_CONST_TMPVARCV)
58179 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58180 VM_TRACE_OP_END(ZEND_SL_SPEC_CONST_TMPVARCV)
58181 HYBRID_BREAK();
58182 HYBRID_CASE(ZEND_SR_SPEC_CONST_TMPVARCV):
58183 VM_TRACE(ZEND_SR_SPEC_CONST_TMPVARCV)
58184 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58185 VM_TRACE_OP_END(ZEND_SR_SPEC_CONST_TMPVARCV)
58186 HYBRID_BREAK();
58187 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV):
58188 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
58189 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58190 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV)
58191 HYBRID_BREAK();
58192 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ):
58193 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
58194 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58195 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ)
58196 HYBRID_BREAK();
58197 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ):
58198 VM_TRACE(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
58199 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58200 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ)
58201 HYBRID_BREAK();
58202 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV):
58203 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
58204 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58205 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV)
58206 HYBRID_BREAK();
58207 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ):
58208 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
58209 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58210 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ)
58211 HYBRID_BREAK();
58212 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ):
58213 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
58214 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58215 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ)
58216 HYBRID_BREAK();
58217 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV):
58218 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
58219 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58220 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV)
58221 HYBRID_BREAK();
58222 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV):
58223 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
58224 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58225 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV)
58226 HYBRID_BREAK();
58227 HYBRID_CASE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV):
58228 VM_TRACE(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
58229 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58230 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_CONST_TMPVARCV)
58231 HYBRID_BREAK();
58232 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV):
58233 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
58234 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58235 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV)
58236 HYBRID_BREAK();
58237 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV):
58238 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
58239 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58240 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV)
58241 HYBRID_BREAK();
58242 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ):
58243 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
58244 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58245 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ)
58246 HYBRID_BREAK();
58247 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
58248 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
58249 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58250 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
58251 HYBRID_BREAK();
58252 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV):
58253 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
58254 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58255 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV)
58256 HYBRID_BREAK();
58257 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
58258 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
58259 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58260 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
58261 HYBRID_BREAK();
58262 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
58263 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
58264 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58265 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
58266 HYBRID_BREAK();
58267 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV):
58268 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
58269 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58270 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV)
58271 HYBRID_BREAK();
58272 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ):
58273 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
58274 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58275 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ)
58276 HYBRID_BREAK();
58277 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ):
58278 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
58279 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58280 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ)
58281 HYBRID_BREAK();
58282 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV):
58283 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
58284 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58285 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV)
58286 HYBRID_BREAK();
58287 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ):
58288 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
58289 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58290 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ)
58291 HYBRID_BREAK();
58292 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ):
58293 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
58294 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58295 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ)
58296 HYBRID_BREAK();
58297 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV):
58298 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
58299 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58300 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV)
58301 HYBRID_BREAK();
58302 HYBRID_CASE(ZEND_DIV_SPEC_CONST_TMPVAR):
58303 VM_TRACE(ZEND_DIV_SPEC_CONST_TMPVAR)
58304 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58305 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_TMPVAR)
58306 HYBRID_BREAK();
58307 HYBRID_CASE(ZEND_POW_SPEC_CONST_TMPVAR):
58308 VM_TRACE(ZEND_POW_SPEC_CONST_TMPVAR)
58309 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58310 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_TMPVAR)
58311 HYBRID_BREAK();
58312 HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_TMPVAR):
58313 VM_TRACE(ZEND_CONCAT_SPEC_CONST_TMPVAR)
58314 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58315 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_TMPVAR)
58316 HYBRID_BREAK();
58317 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR):
58318 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
58319 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58320 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
58321 HYBRID_BREAK();
58322 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR):
58323 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
58324 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58325 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
58326 HYBRID_BREAK();
58327 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR):
58328 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
58329 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58330 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR)
58331 HYBRID_BREAK();
58332 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR):
58333 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
58334 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58335 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR)
58336 HYBRID_BREAK();
58337 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR):
58338 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
58339 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58340 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR)
58341 HYBRID_BREAK();
58342 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR):
58343 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
58344 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58345 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR)
58346 HYBRID_BREAK();
58347 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR):
58348 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
58349 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58350 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR)
58351 HYBRID_BREAK();
58352 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR):
58353 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
58354 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58355 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR)
58356 HYBRID_BREAK();
58357 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR):
58358 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
58359 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58360 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR)
58361 HYBRID_BREAK();
58362 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR):
58363 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
58364 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58365 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR)
58366 HYBRID_BREAK();
58367 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR):
58368 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
58369 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58370 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR)
58371 HYBRID_BREAK();
58372 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR):
58373 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
58374 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58375 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR)
58376 HYBRID_BREAK();
58377 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR):
58378 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
58379 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58380 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR)
58381 HYBRID_BREAK();
58382 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR):
58383 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
58384 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58385 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR)
58386 HYBRID_BREAK();
58387 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR):
58388 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
58389 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58390 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR)
58391 HYBRID_BREAK();
58392 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR):
58393 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
58394 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58395 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
58396 HYBRID_BREAK();
58397 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR):
58398 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
58399 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58400 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
58401 HYBRID_BREAK();
58402 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_TMPVAR):
58403 VM_TRACE(ZEND_YIELD_SPEC_CONST_TMPVAR)
58404 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58405 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_TMPVAR)
58406 HYBRID_BREAK();
58407 HYBRID_CASE(ZEND_FETCH_R_SPEC_CONST_UNUSED):
58408 VM_TRACE(ZEND_FETCH_R_SPEC_CONST_UNUSED)
58409 ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58410 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CONST_UNUSED)
58411 HYBRID_BREAK();
58412 HYBRID_CASE(ZEND_FETCH_W_SPEC_CONST_UNUSED):
58413 VM_TRACE(ZEND_FETCH_W_SPEC_CONST_UNUSED)
58414 ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58415 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CONST_UNUSED)
58416 HYBRID_BREAK();
58417 HYBRID_CASE(ZEND_FETCH_RW_SPEC_CONST_UNUSED):
58418 VM_TRACE(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
58419 ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58420 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CONST_UNUSED)
58421 HYBRID_BREAK();
58422 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED):
58423 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
58424 ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58425 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED)
58426 HYBRID_BREAK();
58427 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED):
58428 VM_TRACE(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
58429 ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58430 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CONST_UNUSED)
58431 HYBRID_BREAK();
58432 HYBRID_CASE(ZEND_FETCH_IS_SPEC_CONST_UNUSED):
58433 VM_TRACE(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
58434 ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58435 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CONST_UNUSED)
58436 HYBRID_BREAK();
58437 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED):
58438 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
58439 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58440 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
58441 HYBRID_BREAK();
58442 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED):
58443 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
58444 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58445 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
58446 HYBRID_BREAK();
58447 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED):
58448 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
58449 ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58450 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED)
58451 HYBRID_BREAK();
58452 HYBRID_CASE(ZEND_SEND_VAL_SPEC_CONST_UNUSED):
58453 VM_TRACE(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
58454 ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58455 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_CONST_UNUSED)
58456 HYBRID_BREAK();
58457 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED):
58458 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
58459 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58460 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED)
58461 HYBRID_BREAK();
58462 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK):
58463 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
58464 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58465 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK)
58466 HYBRID_BREAK();
58467 HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED):
58468 VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED)
58469 ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58470 VM_TRACE_OP_END(ZEND_NEW_SPEC_CONST_UNUSED)
58471 HYBRID_BREAK();
58472 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED):
58473 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
58474 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58475 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED)
58476 HYBRID_BREAK();
58477 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED):
58478 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
58479 ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58480 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_UNUSED)
58481 HYBRID_BREAK();
58482 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED):
58483 VM_TRACE(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
58484 ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58485 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CONST_UNUSED)
58486 HYBRID_BREAK();
58487 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED):
58488 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
58489 ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58490 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED)
58491 HYBRID_BREAK();
58492 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_UNUSED):
58493 VM_TRACE(ZEND_YIELD_SPEC_CONST_UNUSED)
58494 ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58495 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_UNUSED)
58496 HYBRID_BREAK();
58497 HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED):
58498 VM_TRACE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
58499 ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58500 VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED)
58501 HYBRID_BREAK();
58502 HYBRID_CASE(ZEND_COUNT_SPEC_CONST_UNUSED):
58503 VM_TRACE(ZEND_COUNT_SPEC_CONST_UNUSED)
58504 ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58505 VM_TRACE_OP_END(ZEND_COUNT_SPEC_CONST_UNUSED)
58506 HYBRID_BREAK();
58507 HYBRID_CASE(ZEND_GET_CLASS_SPEC_CONST_UNUSED):
58508 VM_TRACE(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
58509 ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58510 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CONST_UNUSED)
58511 HYBRID_BREAK();
58512 HYBRID_CASE(ZEND_GET_TYPE_SPEC_CONST_UNUSED):
58513 VM_TRACE(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
58514 ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58515 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CONST_UNUSED)
58516 HYBRID_BREAK();
58517 HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED):
58518 VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
58519 ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58520 VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED)
58521 HYBRID_BREAK();
58522 HYBRID_CASE(ZEND_DIV_SPEC_CONST_CV):
58523 VM_TRACE(ZEND_DIV_SPEC_CONST_CV)
58524 ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58525 VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_CV)
58526 HYBRID_BREAK();
58527 HYBRID_CASE(ZEND_POW_SPEC_CONST_CV):
58528 VM_TRACE(ZEND_POW_SPEC_CONST_CV)
58529 ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58530 VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_CV)
58531 HYBRID_BREAK();
58532 HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_CV):
58533 VM_TRACE(ZEND_CONCAT_SPEC_CONST_CV)
58534 ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58535 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_CV)
58536 HYBRID_BREAK();
58537 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_CV):
58538 VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_CV)
58539 ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58540 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_CV)
58541 HYBRID_BREAK();
58542 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CV):
58543 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
58544 ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58545 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_CV)
58546 HYBRID_BREAK();
58547 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV):
58548 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
58549 ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58550 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_CV)
58551 HYBRID_BREAK();
58552 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV):
58553 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
58554 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58555 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV)
58556 HYBRID_BREAK();
58557 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV):
58558 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
58559 ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58560 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_CV)
58561 HYBRID_BREAK();
58562 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV):
58563 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
58564 ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58565 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_CV)
58566 HYBRID_BREAK();
58567 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV):
58568 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
58569 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58570 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV)
58571 HYBRID_BREAK();
58572 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_CV):
58573 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
58574 ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58575 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_CV)
58576 HYBRID_BREAK();
58577 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CV):
58578 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CV)
58579 ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58580 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_CV)
58581 HYBRID_BREAK();
58582 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV):
58583 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
58584 ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58585 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_CV)
58586 HYBRID_BREAK();
58587 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV):
58588 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
58589 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58590 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV)
58591 HYBRID_BREAK();
58592 HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_CV):
58593 VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
58594 ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58595 VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_CV)
58596 HYBRID_BREAK();
58597 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV):
58598 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
58599 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58600 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV)
58601 HYBRID_BREAK();
58602 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_CV):
58603 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_CV)
58604 ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58605 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_CV)
58606 HYBRID_BREAK();
58607 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV):
58608 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
58609 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58610 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV)
58611 HYBRID_BREAK();
58612 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV):
58613 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
58614 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58615 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
58616 HYBRID_BREAK();
58617 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV):
58618 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
58619 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58620 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
58621 HYBRID_BREAK();
58622 HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CV):
58623 VM_TRACE(ZEND_YIELD_SPEC_CONST_CV)
58624 ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58625 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_CV)
58626 HYBRID_BREAK();
58627 HYBRID_CASE(ZEND_BW_NOT_SPEC_TMPVARCV):
58628 VM_TRACE(ZEND_BW_NOT_SPEC_TMPVARCV)
58629 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58630 VM_TRACE_OP_END(ZEND_BW_NOT_SPEC_TMPVARCV)
58631 HYBRID_BREAK();
58632 HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV):
58633 VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
58634 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58635 VM_TRACE_OP_END(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV)
58636 HYBRID_BREAK();
58637 HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV):
58638 VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
58639 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58640 VM_TRACE_OP_END(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
58641 HYBRID_BREAK();
58642 HYBRID_CASE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV):
58643 VM_TRACE(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
58644 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58645 VM_TRACE_OP_END(ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV)
58646 HYBRID_BREAK();
58647 HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_CONST):
58648 VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_CONST)
58649 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58650 VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_CONST)
58651 HYBRID_BREAK();
58652 HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_CONST):
58653 VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_CONST)
58654 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58655 VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_CONST)
58656 HYBRID_BREAK();
58657 HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_CONST):
58658 VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_CONST)
58659 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58660 VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_CONST)
58661 HYBRID_BREAK();
58662 HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_CONST):
58663 VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_CONST)
58664 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58665 VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_CONST)
58666 HYBRID_BREAK();
58667 HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_CONST):
58668 VM_TRACE(ZEND_SL_SPEC_TMPVARCV_CONST)
58669 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58670 VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_CONST)
58671 HYBRID_BREAK();
58672 HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_CONST):
58673 VM_TRACE(ZEND_SR_SPEC_TMPVARCV_CONST)
58674 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58675 VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_CONST)
58676 HYBRID_BREAK();
58677 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST):
58678 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
58679 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58680 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST)
58681 HYBRID_BREAK();
58682 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ):
58683 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
58684 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58685 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ)
58686 HYBRID_BREAK();
58687 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ):
58688 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
58689 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58690 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ)
58691 HYBRID_BREAK();
58692 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST):
58693 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
58694 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58695 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST)
58696 HYBRID_BREAK();
58697 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ):
58698 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
58699 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58700 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ)
58701 HYBRID_BREAK();
58702 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ):
58703 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
58704 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58705 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ)
58706 HYBRID_BREAK();
58707 HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_CONST):
58708 VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
58709 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58710 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_CONST)
58711 HYBRID_BREAK();
58712 HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_CONST):
58713 VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
58714 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58715 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_CONST)
58716 HYBRID_BREAK();
58717 HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST):
58718 VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
58719 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58720 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_CONST)
58721 HYBRID_BREAK();
58722 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST):
58723 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
58724 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58725 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST)
58726 HYBRID_BREAK();
58727 HYBRID_CASE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST):
58728 VM_TRACE(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
58729 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58730 VM_TRACE_OP_END(ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST)
58731 HYBRID_BREAK();
58732 HYBRID_CASE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST):
58733 VM_TRACE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
58734 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58735 VM_TRACE_OP_END(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST)
58736 HYBRID_BREAK();
58737 HYBRID_CASE(ZEND_MATCH_SPEC_TMPVARCV_CONST):
58738 VM_TRACE(ZEND_MATCH_SPEC_TMPVARCV_CONST)
58739 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58740 VM_TRACE_OP_END(ZEND_MATCH_SPEC_TMPVARCV_CONST)
58741 HYBRID_BREAK();
58742 HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
58743 VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58744 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58745 VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58746 HYBRID_BREAK();
58747 HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST):
58748 VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
58749 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58750 VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_CONST)
58751 HYBRID_BREAK();
58752 HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST):
58753 VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
58754 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58755 VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST)
58756 HYBRID_BREAK();
58757 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
58758 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58759 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58760 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58761 HYBRID_BREAK();
58762 HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST):
58763 VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
58764 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58765 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_CONST)
58766 HYBRID_BREAK();
58767 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST):
58768 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
58769 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58770 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST)
58771 HYBRID_BREAK();
58772 HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST):
58773 VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58774 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58775 VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST)
58776 HYBRID_BREAK();
58777 HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST):
58778 VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
58779 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58780 VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_CONST)
58781 HYBRID_BREAK();
58782 HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST):
58783 VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
58784 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58785 VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST)
58786 HYBRID_BREAK();
58787 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST):
58788 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58789 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58790 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58791 HYBRID_BREAK();
58792 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
58793 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58794 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58795 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58796 HYBRID_BREAK();
58797 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
58798 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58799 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58800 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58801 HYBRID_BREAK();
58802 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
58803 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58804 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58805 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58806 HYBRID_BREAK();
58807 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
58808 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58809 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58810 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58811 HYBRID_BREAK();
58812 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
58813 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58814 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58815 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58816 HYBRID_BREAK();
58817 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST):
58818 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58819 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58820 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58821 HYBRID_BREAK();
58822 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
58823 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58824 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58825 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58826 HYBRID_BREAK();
58827 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
58828 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58829 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58830 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58831 HYBRID_BREAK();
58832 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
58833 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58834 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58835 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58836 HYBRID_BREAK();
58837 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
58838 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58839 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58840 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58841 HYBRID_BREAK();
58842 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
58843 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58844 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58845 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58846 HYBRID_BREAK();
58847 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST):
58848 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
58849 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58850 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST)
58851 HYBRID_BREAK();
58852 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ):
58853 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58854 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58855 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58856 HYBRID_BREAK();
58857 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
58858 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58859 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58860 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58861 HYBRID_BREAK();
58862 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST):
58863 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
58864 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58865 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST)
58866 HYBRID_BREAK();
58867 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
58868 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58869 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58870 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58871 HYBRID_BREAK();
58872 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
58873 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58874 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58875 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58876 HYBRID_BREAK();
58877 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST):
58878 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58879 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58880 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST)
58881 HYBRID_BREAK();
58882 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ):
58883 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58884 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58885 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ)
58886 HYBRID_BREAK();
58887 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ):
58888 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58889 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58890 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ)
58891 HYBRID_BREAK();
58892 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST):
58893 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58894 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58895 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST)
58896 HYBRID_BREAK();
58897 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ):
58898 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58899 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58900 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ)
58901 HYBRID_BREAK();
58902 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ):
58903 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58904 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58905 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ)
58906 HYBRID_BREAK();
58907 HYBRID_CASE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV):
58908 VM_TRACE(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
58909 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58910 VM_TRACE_OP_END(ZEND_ADD_SPEC_TMPVARCV_TMPVARCV)
58911 HYBRID_BREAK();
58912 HYBRID_CASE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV):
58913 VM_TRACE(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
58914 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58915 VM_TRACE_OP_END(ZEND_SUB_SPEC_TMPVARCV_TMPVARCV)
58916 HYBRID_BREAK();
58917 HYBRID_CASE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV):
58918 VM_TRACE(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
58919 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58920 VM_TRACE_OP_END(ZEND_MUL_SPEC_TMPVARCV_TMPVARCV)
58921 HYBRID_BREAK();
58922 HYBRID_CASE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV):
58923 VM_TRACE(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
58924 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58925 VM_TRACE_OP_END(ZEND_MOD_SPEC_TMPVARCV_TMPVARCV)
58926 HYBRID_BREAK();
58927 HYBRID_CASE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV):
58928 VM_TRACE(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
58929 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58930 VM_TRACE_OP_END(ZEND_SL_SPEC_TMPVARCV_TMPVARCV)
58931 HYBRID_BREAK();
58932 HYBRID_CASE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV):
58933 VM_TRACE(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
58934 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58935 VM_TRACE_OP_END(ZEND_SR_SPEC_TMPVARCV_TMPVARCV)
58936 HYBRID_BREAK();
58937 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV):
58938 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
58939 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58940 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV)
58941 HYBRID_BREAK();
58942 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ):
58943 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
58944 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58945 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ)
58946 HYBRID_BREAK();
58947 HYBRID_CASE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
58948 VM_TRACE(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
58949 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58950 VM_TRACE_OP_END(ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
58951 HYBRID_BREAK();
58952 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV):
58953 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
58954 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58955 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV)
58956 HYBRID_BREAK();
58957 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ):
58958 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
58959 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58960 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ)
58961 HYBRID_BREAK();
58962 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
58963 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
58964 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58965 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
58966 HYBRID_BREAK();
58967 HYBRID_CASE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV):
58968 VM_TRACE(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
58969 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58970 VM_TRACE_OP_END(ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV)
58971 HYBRID_BREAK();
58972 HYBRID_CASE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV):
58973 VM_TRACE(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
58974 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58975 VM_TRACE_OP_END(ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV)
58976 HYBRID_BREAK();
58977 HYBRID_CASE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV):
58978 VM_TRACE(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
58979 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58980 VM_TRACE_OP_END(ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV)
58981 HYBRID_BREAK();
58982 HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
58983 VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
58984 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58985 VM_TRACE_OP_END(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
58986 HYBRID_BREAK();
58987 HYBRID_CASE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV):
58988 VM_TRACE(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
58989 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58990 VM_TRACE_OP_END(ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV)
58991 HYBRID_BREAK();
58992 HYBRID_CASE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
58993 VM_TRACE(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
58994 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
58995 VM_TRACE_OP_END(ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
58996 HYBRID_BREAK();
58997 HYBRID_CASE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
58998 VM_TRACE(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
58999 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59000 VM_TRACE_OP_END(ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
59001 HYBRID_BREAK();
59002 HYBRID_CASE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV):
59003 VM_TRACE(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
59004 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59005 VM_TRACE_OP_END(ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV)
59006 HYBRID_BREAK();
59007 HYBRID_CASE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59008 VM_TRACE(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59009 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59010 VM_TRACE_OP_END(ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59011 HYBRID_BREAK();
59012 HYBRID_CASE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV):
59013 VM_TRACE(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
59014 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59015 VM_TRACE_OP_END(ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV)
59016 HYBRID_BREAK();
59017 HYBRID_CASE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV):
59018 VM_TRACE(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
59019 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59020 VM_TRACE_OP_END(ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV)
59021 HYBRID_BREAK();
59022 HYBRID_CASE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59023 VM_TRACE(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59024 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59025 VM_TRACE_OP_END(ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59026 HYBRID_BREAK();
59027 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
59028 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59029 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59030 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59031 HYBRID_BREAK();
59032 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59033 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59034 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59035 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59036 HYBRID_BREAK();
59037 HYBRID_CASE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59038 VM_TRACE(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59039 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59040 VM_TRACE_OP_END(ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59041 HYBRID_BREAK();
59042 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59043 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59044 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59045 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59046 HYBRID_BREAK();
59047 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59048 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59049 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59050 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59051 HYBRID_BREAK();
59052 HYBRID_CASE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59053 VM_TRACE(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59054 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59055 VM_TRACE_OP_END(ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59056 HYBRID_BREAK();
59057 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
59058 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59059 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59060 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59061 HYBRID_BREAK();
59062 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59063 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59064 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59065 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59066 HYBRID_BREAK();
59067 HYBRID_CASE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59068 VM_TRACE(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59069 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59070 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59071 HYBRID_BREAK();
59072 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59073 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59074 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59075 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59076 HYBRID_BREAK();
59077 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59078 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59079 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59080 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59081 HYBRID_BREAK();
59082 HYBRID_CASE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59083 VM_TRACE(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59084 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59085 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59086 HYBRID_BREAK();
59087 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV):
59088 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
59089 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59090 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV)
59091 HYBRID_BREAK();
59092 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59093 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59094 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59095 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59096 HYBRID_BREAK();
59097 HYBRID_CASE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59098 VM_TRACE(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59099 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59100 VM_TRACE_OP_END(ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59101 HYBRID_BREAK();
59102 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59103 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59104 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59105 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59106 HYBRID_BREAK();
59107 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59108 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59109 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59110 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59111 HYBRID_BREAK();
59112 HYBRID_CASE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59113 VM_TRACE(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59114 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59115 VM_TRACE_OP_END(ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59116 HYBRID_BREAK();
59117 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV):
59118 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59119 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59120 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV)
59121 HYBRID_BREAK();
59122 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59123 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59124 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59125 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59126 HYBRID_BREAK();
59127 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59128 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59129 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59130 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59131 HYBRID_BREAK();
59132 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV):
59133 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59134 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59135 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV)
59136 HYBRID_BREAK();
59137 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ):
59138 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59139 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59140 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ)
59141 HYBRID_BREAK();
59142 HYBRID_CASE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ):
59143 VM_TRACE(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59144 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59145 VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ)
59146 HYBRID_BREAK();
59147 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR):
59148 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
59149 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59150 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR)
59151 HYBRID_BREAK();
59152 HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED):
59153 VM_TRACE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
59154 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59155 VM_TRACE_OP_END(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED)
59156 HYBRID_BREAK();
59157 HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV):
59158 VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
59159 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59160 VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV)
59161 HYBRID_BREAK();
59162 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_TMPVAR):
59163 VM_TRACE(ZEND_BOOL_NOT_SPEC_TMPVAR)
59164 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59165 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_TMPVAR)
59166 HYBRID_BREAK();
59167 HYBRID_CASE(ZEND_ECHO_SPEC_TMPVAR):
59168 VM_TRACE(ZEND_ECHO_SPEC_TMPVAR)
59169 ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59170 VM_TRACE_OP_END(ZEND_ECHO_SPEC_TMPVAR)
59171 HYBRID_BREAK();
59172 HYBRID_CASE(ZEND_JMPZ_SPEC_TMPVAR):
59173 VM_TRACE(ZEND_JMPZ_SPEC_TMPVAR)
59174 ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59175 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_TMPVAR)
59176 HYBRID_BREAK();
59177 HYBRID_CASE(ZEND_JMPNZ_SPEC_TMPVAR):
59178 VM_TRACE(ZEND_JMPNZ_SPEC_TMPVAR)
59179 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59180 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_TMPVAR)
59181 HYBRID_BREAK();
59182 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_TMPVAR):
59183 VM_TRACE(ZEND_JMPZ_EX_SPEC_TMPVAR)
59184 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59185 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_TMPVAR)
59186 HYBRID_BREAK();
59187 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_TMPVAR):
59188 VM_TRACE(ZEND_JMPNZ_EX_SPEC_TMPVAR)
59189 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59190 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_TMPVAR)
59191 HYBRID_BREAK();
59192 HYBRID_CASE(ZEND_FREE_SPEC_TMPVAR):
59193 VM_TRACE(ZEND_FREE_SPEC_TMPVAR)
59194 ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59195 VM_TRACE_OP_END(ZEND_FREE_SPEC_TMPVAR)
59196 HYBRID_BREAK();
59197 HYBRID_CASE(ZEND_FE_FREE_SPEC_TMPVAR):
59198 VM_TRACE(ZEND_FE_FREE_SPEC_TMPVAR)
59199 ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59200 VM_TRACE_OP_END(ZEND_FE_FREE_SPEC_TMPVAR)
59201 HYBRID_BREAK();
59202 HYBRID_CASE(ZEND_THROW_SPEC_TMPVAR):
59203 VM_TRACE(ZEND_THROW_SPEC_TMPVAR)
59204 ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59205 VM_TRACE_OP_END(ZEND_THROW_SPEC_TMPVAR)
59206 HYBRID_BREAK();
59207 HYBRID_CASE(ZEND_BOOL_SPEC_TMPVAR):
59208 VM_TRACE(ZEND_BOOL_SPEC_TMPVAR)
59209 ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59210 VM_TRACE_OP_END(ZEND_BOOL_SPEC_TMPVAR)
59211 HYBRID_BREAK();
59212 HYBRID_CASE(ZEND_CLONE_SPEC_TMPVAR):
59213 VM_TRACE(ZEND_CLONE_SPEC_TMPVAR)
59214 ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59215 VM_TRACE_OP_END(ZEND_CLONE_SPEC_TMPVAR)
59216 HYBRID_BREAK();
59217 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR):
59218 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
59219 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59220 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
59221 HYBRID_BREAK();
59222 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_TMPVAR):
59223 VM_TRACE(ZEND_YIELD_FROM_SPEC_TMPVAR)
59224 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59225 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_TMPVAR)
59226 HYBRID_BREAK();
59227 HYBRID_CASE(ZEND_STRLEN_SPEC_TMPVAR):
59228 VM_TRACE(ZEND_STRLEN_SPEC_TMPVAR)
59229 ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59230 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_TMPVAR)
59231 HYBRID_BREAK();
59232 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_TMPVAR):
59233 VM_TRACE(ZEND_TYPE_CHECK_SPEC_TMPVAR)
59234 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59235 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_TMPVAR)
59236 HYBRID_BREAK();
59237 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR):
59238 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
59239 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59240 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR)
59241 HYBRID_BREAK();
59242 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CONST):
59243 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CONST)
59244 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59245 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CONST)
59246 HYBRID_BREAK();
59247 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CONST):
59248 VM_TRACE(ZEND_POW_SPEC_TMPVAR_CONST)
59249 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59250 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CONST)
59251 HYBRID_BREAK();
59252 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CONST):
59253 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CONST)
59254 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59255 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CONST)
59256 HYBRID_BREAK();
59257 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST):
59258 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
59259 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59260 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST)
59261 HYBRID_BREAK();
59262 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
59263 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
59264 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59265 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
59266 HYBRID_BREAK();
59267 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
59268 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
59269 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59270 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
59271 HYBRID_BREAK();
59272 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST):
59273 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
59274 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59275 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST)
59276 HYBRID_BREAK();
59277 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ):
59278 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
59279 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59280 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ)
59281 HYBRID_BREAK();
59282 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ):
59283 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
59284 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59285 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ)
59286 HYBRID_BREAK();
59287 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST):
59288 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
59289 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59290 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CONST)
59291 HYBRID_BREAK();
59292 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST):
59293 VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
59294 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59295 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
59296 HYBRID_BREAK();
59297 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST):
59298 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
59299 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59300 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
59301 HYBRID_BREAK();
59302 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST):
59303 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
59304 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59305 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST)
59306 HYBRID_BREAK();
59307 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST):
59308 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
59309 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59310 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST)
59311 HYBRID_BREAK();
59312 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST):
59313 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
59314 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59315 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
59316 HYBRID_BREAK();
59317 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST):
59318 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
59319 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59320 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
59321 HYBRID_BREAK();
59322 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST):
59323 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
59324 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59325 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST)
59326 HYBRID_BREAK();
59327 HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST):
59328 VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
59329 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59330 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_CONST)
59331 HYBRID_BREAK();
59332 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CONST):
59333 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CONST)
59334 ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59335 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CONST)
59336 HYBRID_BREAK();
59337 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST):
59338 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
59339 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59340 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST)
59341 HYBRID_BREAK();
59342 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST):
59343 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
59344 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59345 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
59346 HYBRID_BREAK();
59347 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST):
59348 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
59349 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59350 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
59351 HYBRID_BREAK();
59352 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST):
59353 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
59354 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59355 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
59356 HYBRID_BREAK();
59357 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST):
59358 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
59359 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59360 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST)
59361 HYBRID_BREAK();
59362 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV):
59363 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
59364 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59365 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV)
59366 HYBRID_BREAK();
59367 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_TMPVAR):
59368 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
59369 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59370 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_TMPVAR)
59371 HYBRID_BREAK();
59372 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_TMPVAR):
59373 VM_TRACE(ZEND_POW_SPEC_TMPVAR_TMPVAR)
59374 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59375 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_TMPVAR)
59376 HYBRID_BREAK();
59377 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR):
59378 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
59379 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59380 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR)
59381 HYBRID_BREAK();
59382 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR):
59383 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
59384 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59385 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR)
59386 HYBRID_BREAK();
59387 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
59388 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
59389 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59390 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
59391 HYBRID_BREAK();
59392 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
59393 VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
59394 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59395 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
59396 HYBRID_BREAK();
59397 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR):
59398 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
59399 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59400 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR)
59401 HYBRID_BREAK();
59402 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ):
59403 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
59404 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59405 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ)
59406 HYBRID_BREAK();
59407 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ):
59408 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
59409 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59410 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ)
59411 HYBRID_BREAK();
59412 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR):
59413 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
59414 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59415 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR)
59416 HYBRID_BREAK();
59417 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR):
59418 VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
59419 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59420 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR)
59421 HYBRID_BREAK();
59422 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR):
59423 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
59424 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59425 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR)
59426 HYBRID_BREAK();
59427 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR):
59428 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
59429 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59430 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR)
59431 HYBRID_BREAK();
59432 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR):
59433 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
59434 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59435 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR)
59436 HYBRID_BREAK();
59437 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR):
59438 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
59439 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59440 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR)
59441 HYBRID_BREAK();
59442 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR):
59443 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
59444 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59445 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR)
59446 HYBRID_BREAK();
59447 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR):
59448 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
59449 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59450 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR)
59451 HYBRID_BREAK();
59452 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_TMPVAR):
59453 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
59454 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59455 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_TMPVAR)
59456 HYBRID_BREAK();
59457 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR):
59458 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
59459 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59460 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR)
59461 HYBRID_BREAK();
59462 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR):
59463 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
59464 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59465 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
59466 HYBRID_BREAK();
59467 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR):
59468 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
59469 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59470 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
59471 HYBRID_BREAK();
59472 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR):
59473 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
59474 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59475 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
59476 HYBRID_BREAK();
59477 HYBRID_CASE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED):
59478 VM_TRACE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
59479 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59480 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
59481 HYBRID_BREAK();
59482 HYBRID_CASE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED):
59483 VM_TRACE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
59484 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59485 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED)
59486 HYBRID_BREAK();
59487 HYBRID_CASE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED):
59488 VM_TRACE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
59489 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59490 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED)
59491 HYBRID_BREAK();
59492 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED):
59493 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
59494 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59495 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED)
59496 HYBRID_BREAK();
59497 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED):
59498 VM_TRACE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
59499 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59500 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED)
59501 HYBRID_BREAK();
59502 HYBRID_CASE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED):
59503 VM_TRACE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
59504 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59505 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED)
59506 HYBRID_BREAK();
59507 HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED):
59508 VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
59509 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59510 VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED)
59511 HYBRID_BREAK();
59512 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED):
59513 VM_TRACE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
59514 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59515 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
59516 HYBRID_BREAK();
59517 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED):
59518 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
59519 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59520 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED)
59521 HYBRID_BREAK();
59522 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED):
59523 VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
59524 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59525 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED)
59526 HYBRID_BREAK();
59527 HYBRID_CASE(ZEND_COUNT_SPEC_TMPVAR_UNUSED):
59528 VM_TRACE(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
59529 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59530 VM_TRACE_OP_END(ZEND_COUNT_SPEC_TMPVAR_UNUSED)
59531 HYBRID_BREAK();
59532 HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED):
59533 VM_TRACE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
59534 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59535 VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED)
59536 HYBRID_BREAK();
59537 HYBRID_CASE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED):
59538 VM_TRACE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
59539 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59540 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED)
59541 HYBRID_BREAK();
59542 HYBRID_CASE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED):
59543 VM_TRACE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
59544 ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59545 VM_TRACE_OP_END(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED)
59546 HYBRID_BREAK();
59547 HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CV):
59548 VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CV)
59549 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59550 VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CV)
59551 HYBRID_BREAK();
59552 HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CV):
59553 VM_TRACE(ZEND_POW_SPEC_TMPVAR_CV)
59554 ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59555 VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CV)
59556 HYBRID_BREAK();
59557 HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CV):
59558 VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CV)
59559 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59560 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CV)
59561 HYBRID_BREAK();
59562 HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CV):
59563 VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
59564 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59565 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CV)
59566 HYBRID_BREAK();
59567 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV):
59568 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
59569 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59570 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV)
59571 HYBRID_BREAK();
59572 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV):
59573 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
59574 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59575 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV)
59576 HYBRID_BREAK();
59577 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV):
59578 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
59579 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59580 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV)
59581 HYBRID_BREAK();
59582 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV):
59583 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
59584 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59585 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV)
59586 HYBRID_BREAK();
59587 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV):
59588 VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
59589 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59590 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV)
59591 HYBRID_BREAK();
59592 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV):
59593 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
59594 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59595 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV)
59596 HYBRID_BREAK();
59597 HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CV):
59598 VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CV)
59599 ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59600 VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CV)
59601 HYBRID_BREAK();
59602 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV):
59603 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
59604 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59605 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV)
59606 HYBRID_BREAK();
59607 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV):
59608 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
59609 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59610 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
59611 HYBRID_BREAK();
59612 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV):
59613 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
59614 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59615 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
59616 HYBRID_BREAK();
59617 HYBRID_CASE(ZEND_RETURN_SPEC_TMP):
59618 VM_TRACE(ZEND_RETURN_SPEC_TMP)
59619 {
59620 USE_OPLINE
59621 zval *retval_ptr;
59622 zval *return_value;
59623
59624 retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
59625 return_value = EX(return_value);
59626
59627 if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
59628 SAVE_OPLINE();
59629 retval_ptr = ZVAL_UNDEFINED_OP1();
59630 if (return_value) {
59631 ZVAL_NULL(return_value);
59632 }
59633 } else if (!return_value) {
59634 if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
59635 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
59636 SAVE_OPLINE();
59637 rc_dtor_func(Z_COUNTED_P(retval_ptr));
59638 }
59639 }
59640 } else {
59641 if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
59642 ZVAL_COPY_VALUE(return_value, retval_ptr);
59643 if (IS_TMP_VAR == IS_CONST) {
59644 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
59645 Z_ADDREF_P(return_value);
59646 }
59647 }
59648 } else if (IS_TMP_VAR == IS_CV) {
59649 do {
59650 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59651 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
59652 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
59653 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59654 ZVAL_COPY_VALUE(return_value, retval_ptr);
59655 if (GC_MAY_LEAK(ref)) {
59656 SAVE_OPLINE();
59657 gc_possible_root(ref);
59658 }
59659 ZVAL_NULL(retval_ptr);
59660 break;
59661 } else {
59662 Z_ADDREF_P(retval_ptr);
59663 }
59664 } else {
59665 retval_ptr = Z_REFVAL_P(retval_ptr);
59666 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59667 Z_ADDREF_P(retval_ptr);
59668 }
59669 }
59670 }
59671 ZVAL_COPY_VALUE(return_value, retval_ptr);
59672 } while (0);
59673 } else /* if (IS_TMP_VAR == IS_VAR) */ {
59674 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
59675 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
59676
59677 retval_ptr = Z_REFVAL_P(retval_ptr);
59678 ZVAL_COPY_VALUE(return_value, retval_ptr);
59679 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
59680 efree_size(ref, sizeof(zend_reference));
59681 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
59682 Z_ADDREF_P(retval_ptr);
59683 }
59684 } else {
59685 ZVAL_COPY_VALUE(return_value, retval_ptr);
59686 }
59687 }
59688 }
59689
59690
59691
59692 goto zend_leave_helper_SPEC_LABEL;
59693 }
59694
59695 VM_TRACE_OP_END(ZEND_RETURN_SPEC_TMP)
59696 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_TMP):
59697 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_TMP)
59698 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59699 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_TMP)
59700 HYBRID_BREAK();
59701 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_TMP):
59702 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_TMP)
59703 ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59704 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_TMP)
59705 HYBRID_BREAK();
59706 HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP):
59707 VM_TRACE(ZEND_SEND_USER_SPEC_TMP)
59708 ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59709 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP)
59710 HYBRID_BREAK();
59711 HYBRID_CASE(ZEND_CAST_SPEC_TMP):
59712 VM_TRACE(ZEND_CAST_SPEC_TMP)
59713 ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59714 VM_TRACE_OP_END(ZEND_CAST_SPEC_TMP)
59715 HYBRID_BREAK();
59716 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_TMP):
59717 VM_TRACE(ZEND_FE_RESET_R_SPEC_TMP)
59718 ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59719 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_TMP)
59720 HYBRID_BREAK();
59721 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_TMP):
59722 VM_TRACE(ZEND_FE_RESET_RW_SPEC_TMP)
59723 ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59724 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_TMP)
59725 HYBRID_BREAK();
59726 HYBRID_CASE(ZEND_END_SILENCE_SPEC_TMP):
59727 VM_TRACE(ZEND_END_SILENCE_SPEC_TMP)
59728 ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59729 VM_TRACE_OP_END(ZEND_END_SILENCE_SPEC_TMP)
59730 HYBRID_BREAK();
59731 HYBRID_CASE(ZEND_JMP_SET_SPEC_TMP):
59732 VM_TRACE(ZEND_JMP_SET_SPEC_TMP)
59733 ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59734 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_TMP)
59735 HYBRID_BREAK();
59736 HYBRID_CASE(ZEND_COALESCE_SPEC_TMP):
59737 VM_TRACE(ZEND_COALESCE_SPEC_TMP)
59738 ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59739 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_TMP)
59740 HYBRID_BREAK();
59741 HYBRID_CASE(ZEND_JMP_NULL_SPEC_TMP):
59742 VM_TRACE(ZEND_JMP_NULL_SPEC_TMP)
59743 ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59744 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_TMP)
59745 HYBRID_BREAK();
59746 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_TMP):
59747 VM_TRACE(ZEND_QM_ASSIGN_SPEC_TMP)
59748 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59749 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_TMP)
59750 HYBRID_BREAK();
59751 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST):
59752 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
59753 ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59754 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_CONST)
59755 HYBRID_BREAK();
59756 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CONST):
59757 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CONST)
59758 ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59759 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CONST)
59760 HYBRID_BREAK();
59761 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST):
59762 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
59763 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59764 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
59765 HYBRID_BREAK();
59766 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST):
59767 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
59768 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59769 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
59770 HYBRID_BREAK();
59771 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST):
59772 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
59773 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59774 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST)
59775 HYBRID_BREAK();
59776 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CONST):
59777 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CONST)
59778 ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59779 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CONST)
59780 HYBRID_BREAK();
59781 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CONST):
59782 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CONST)
59783 ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59784 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CONST)
59785 HYBRID_BREAK();
59786 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST):
59787 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
59788 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59789 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_CONST)
59790 HYBRID_BREAK();
59791 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST):
59792 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
59793 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59794 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST)
59795 HYBRID_BREAK();
59796 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CONST):
59797 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
59798 ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59799 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CONST)
59800 HYBRID_BREAK();
59801 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CONST):
59802 VM_TRACE(ZEND_YIELD_SPEC_TMP_CONST)
59803 ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59804 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CONST)
59805 HYBRID_BREAK();
59806 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_TMP_CONST):
59807 VM_TRACE(ZEND_IN_ARRAY_SPEC_TMP_CONST)
59808 ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59809 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_TMP_CONST)
59810 HYBRID_BREAK();
59811 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR):
59812 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
59813 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59814 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
59815 HYBRID_BREAK();
59816 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR):
59817 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
59818 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59819 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR)
59820 HYBRID_BREAK();
59821 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR):
59822 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
59823 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59824 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR)
59825 HYBRID_BREAK();
59826 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_TMPVAR):
59827 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
59828 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59829 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_TMPVAR)
59830 HYBRID_BREAK();
59831 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR):
59832 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
59833 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59834 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR)
59835 HYBRID_BREAK();
59836 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR):
59837 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
59838 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59839 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR)
59840 HYBRID_BREAK();
59841 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_TMPVAR):
59842 VM_TRACE(ZEND_YIELD_SPEC_TMP_TMPVAR)
59843 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59844 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_TMPVAR)
59845 HYBRID_BREAK();
59846 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP):
59847 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
59848 ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59849 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_TMP_TMP)
59850 HYBRID_BREAK();
59851 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_TMP):
59852 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_TMP)
59853 ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59854 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_TMP)
59855 HYBRID_BREAK();
59856 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP):
59857 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
59858 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59859 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP)
59860 HYBRID_BREAK();
59861 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_VAR):
59862 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_VAR)
59863 ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59864 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_VAR)
59865 HYBRID_BREAK();
59866 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED):
59867 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
59868 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59869 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
59870 HYBRID_BREAK();
59871 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED):
59872 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
59873 ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59874 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED)
59875 HYBRID_BREAK();
59876 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED):
59877 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
59878 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59879 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED)
59880 HYBRID_BREAK();
59881 HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK):
59882 VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
59883 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59884 VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK)
59885 HYBRID_BREAK();
59886 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED):
59887 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
59888 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59889 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED)
59890 HYBRID_BREAK();
59891 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED):
59892 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
59893 ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59894 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED)
59895 HYBRID_BREAK();
59896 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_UNUSED):
59897 VM_TRACE(ZEND_YIELD_SPEC_TMP_UNUSED)
59898 ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59899 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_UNUSED)
59900 HYBRID_BREAK();
59901 HYBRID_CASE(ZEND_GET_TYPE_SPEC_TMP_UNUSED):
59902 VM_TRACE(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
59903 ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59904 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
59905 HYBRID_BREAK();
59906 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CV):
59907 VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CV)
59908 ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59909 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CV)
59910 HYBRID_BREAK();
59911 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV):
59912 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
59913 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59914 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV)
59915 HYBRID_BREAK();
59916 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV):
59917 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
59918 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59919 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV)
59920 HYBRID_BREAK();
59921 HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CV):
59922 VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CV)
59923 ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59924 VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_CV)
59925 HYBRID_BREAK();
59926 HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_CV):
59927 VM_TRACE(ZEND_ROPE_END_SPEC_TMP_CV)
59928 ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59929 VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CV)
59930 HYBRID_BREAK();
59931 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV):
59932 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
59933 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59934 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV)
59935 HYBRID_BREAK();
59936 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_CV):
59937 VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_CV)
59938 ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59939 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CV)
59940 HYBRID_BREAK();
59941 HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CV):
59942 VM_TRACE(ZEND_YIELD_SPEC_TMP_CV)
59943 ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59944 VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_CV)
59945 HYBRID_BREAK();
59946 HYBRID_CASE(ZEND_BIND_LEXICAL_SPEC_TMP_CV):
59947 VM_TRACE(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
59948 ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59949 VM_TRACE_OP_END(ZEND_BIND_LEXICAL_SPEC_TMP_CV)
59950 HYBRID_BREAK();
59951 HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED):
59952 VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
59953 ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59954 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED)
59955 HYBRID_BREAK();
59956 HYBRID_CASE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED):
59957 VM_TRACE(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
59958 ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59959 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_VAR_RETVAL_USED)
59960 HYBRID_BREAK();
59961 HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED):
59962 VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
59963 ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59964 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED)
59965 HYBRID_BREAK();
59966 HYBRID_CASE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED):
59967 VM_TRACE(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
59968 ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59969 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED)
59970 HYBRID_BREAK();
59971 HYBRID_CASE(ZEND_POST_INC_SPEC_VAR):
59972 VM_TRACE(ZEND_POST_INC_SPEC_VAR)
59973 ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59974 VM_TRACE_OP_END(ZEND_POST_INC_SPEC_VAR)
59975 HYBRID_BREAK();
59976 HYBRID_CASE(ZEND_POST_DEC_SPEC_VAR):
59977 VM_TRACE(ZEND_POST_DEC_SPEC_VAR)
59978 ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
59979 VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_VAR)
59980 HYBRID_BREAK();
59981 HYBRID_CASE(ZEND_RETURN_SPEC_VAR):
59982 VM_TRACE(ZEND_RETURN_SPEC_VAR)
59983 {
59984 USE_OPLINE
59985 zval *retval_ptr;
59986 zval *return_value;
59987
59988 retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
59989 return_value = EX(return_value);
59990
59991 if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
59992 SAVE_OPLINE();
59993 retval_ptr = ZVAL_UNDEFINED_OP1();
59994 if (return_value) {
59995 ZVAL_NULL(return_value);
59996 }
59997 } else if (!return_value) {
59998 if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
59999 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
60000 SAVE_OPLINE();
60001 rc_dtor_func(Z_COUNTED_P(retval_ptr));
60002 }
60003 }
60004 } else {
60005 if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
60006 ZVAL_COPY_VALUE(return_value, retval_ptr);
60007 if (IS_VAR == IS_CONST) {
60008 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
60009 Z_ADDREF_P(return_value);
60010 }
60011 }
60012 } else if (IS_VAR == IS_CV) {
60013 do {
60014 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
60015 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
60016 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
60017 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
60018 ZVAL_COPY_VALUE(return_value, retval_ptr);
60019 if (GC_MAY_LEAK(ref)) {
60020 SAVE_OPLINE();
60021 gc_possible_root(ref);
60022 }
60023 ZVAL_NULL(retval_ptr);
60024 break;
60025 } else {
60026 Z_ADDREF_P(retval_ptr);
60027 }
60028 } else {
60029 retval_ptr = Z_REFVAL_P(retval_ptr);
60030 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
60031 Z_ADDREF_P(retval_ptr);
60032 }
60033 }
60034 }
60035 ZVAL_COPY_VALUE(return_value, retval_ptr);
60036 } while (0);
60037 } else /* if (IS_VAR == IS_VAR) */ {
60038 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
60039 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
60040
60041 retval_ptr = Z_REFVAL_P(retval_ptr);
60042 ZVAL_COPY_VALUE(return_value, retval_ptr);
60043 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
60044 efree_size(ref, sizeof(zend_reference));
60045 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
60046 Z_ADDREF_P(retval_ptr);
60047 }
60048 } else {
60049 ZVAL_COPY_VALUE(return_value, retval_ptr);
60050 }
60051 }
60052 }
60053
60054
60055
60056 goto zend_leave_helper_SPEC_LABEL;
60057 }
60058
60059 VM_TRACE_OP_END(ZEND_RETURN_SPEC_VAR)
60060 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_VAR):
60061 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_VAR)
60062 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60063 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_VAR)
60064 HYBRID_BREAK();
60065 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_VAR):
60066 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_VAR)
60067 ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60068 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_VAR)
60069 HYBRID_BREAK();
60070 HYBRID_CASE(ZEND_SEND_USER_SPEC_VAR):
60071 VM_TRACE(ZEND_SEND_USER_SPEC_VAR)
60072 ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60073 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_VAR)
60074 HYBRID_BREAK();
60075 HYBRID_CASE(ZEND_CAST_SPEC_VAR):
60076 VM_TRACE(ZEND_CAST_SPEC_VAR)
60077 ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60078 VM_TRACE_OP_END(ZEND_CAST_SPEC_VAR)
60079 HYBRID_BREAK();
60080 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_VAR):
60081 VM_TRACE(ZEND_FE_RESET_R_SPEC_VAR)
60082 ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60083 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_VAR)
60084 HYBRID_BREAK();
60085 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_VAR):
60086 VM_TRACE(ZEND_FE_RESET_RW_SPEC_VAR)
60087 ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60088 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_VAR)
60089 HYBRID_BREAK();
60090 HYBRID_CASE(ZEND_FE_FETCH_R_SPEC_VAR):
60091 VM_TRACE(ZEND_FE_FETCH_R_SPEC_VAR)
60092 ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60093 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SPEC_VAR)
60094 HYBRID_BREAK();
60095 HYBRID_CASE(ZEND_FE_FETCH_RW_SPEC_VAR):
60096 VM_TRACE(ZEND_FE_FETCH_RW_SPEC_VAR)
60097 ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60098 VM_TRACE_OP_END(ZEND_FE_FETCH_RW_SPEC_VAR)
60099 HYBRID_BREAK();
60100 HYBRID_CASE(ZEND_JMP_SET_SPEC_VAR):
60101 VM_TRACE(ZEND_JMP_SET_SPEC_VAR)
60102 ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60103 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_VAR)
60104 HYBRID_BREAK();
60105 HYBRID_CASE(ZEND_COALESCE_SPEC_VAR):
60106 VM_TRACE(ZEND_COALESCE_SPEC_VAR)
60107 ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60108 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_VAR)
60109 HYBRID_BREAK();
60110 HYBRID_CASE(ZEND_JMP_NULL_SPEC_VAR):
60111 VM_TRACE(ZEND_JMP_NULL_SPEC_VAR)
60112 ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60113 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_VAR)
60114 HYBRID_BREAK();
60115 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_VAR):
60116 VM_TRACE(ZEND_QM_ASSIGN_SPEC_VAR)
60117 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60118 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_VAR)
60119 HYBRID_BREAK();
60120 HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR):
60121 VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
60122 ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60123 VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_VAR)
60124 HYBRID_BREAK();
60125 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST):
60126 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
60127 ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60128 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_CONST)
60129 HYBRID_BREAK();
60130 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CONST):
60131 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CONST)
60132 ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60133 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CONST)
60134 HYBRID_BREAK();
60135 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST):
60136 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
60137 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60138 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST)
60139 HYBRID_BREAK();
60140 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST):
60141 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
60142 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60143 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST)
60144 HYBRID_BREAK();
60145 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST):
60146 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
60147 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60148 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST)
60149 HYBRID_BREAK();
60150 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CONST):
60151 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
60152 ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60153 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CONST)
60154 HYBRID_BREAK();
60155 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST):
60156 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
60157 ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60158 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
60159 HYBRID_BREAK();
60160 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST):
60161 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
60162 ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60163 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CONST)
60164 HYBRID_BREAK();
60165 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST):
60166 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
60167 ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60168 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CONST)
60169 HYBRID_BREAK();
60170 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST):
60171 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
60172 ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60173 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CONST)
60174 HYBRID_BREAK();
60175 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST):
60176 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
60177 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60178 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST)
60179 HYBRID_BREAK();
60180 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST):
60181 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
60182 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60183 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST)
60184 HYBRID_BREAK();
60185 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST):
60186 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
60187 ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60188 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST)
60189 HYBRID_BREAK();
60190 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST):
60191 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
60192 ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60193 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST)
60194 HYBRID_BREAK();
60195 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST):
60196 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
60197 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60198 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST)
60199 HYBRID_BREAK();
60200 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST):
60201 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
60202 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60203 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST)
60204 HYBRID_BREAK();
60205 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST):
60206 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
60207 ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60208 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CONST)
60209 HYBRID_BREAK();
60210 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST):
60211 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
60212 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60213 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST)
60214 HYBRID_BREAK();
60215 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP):
60216 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
60217 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60218 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP)
60219 HYBRID_BREAK();
60220 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR):
60221 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
60222 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60223 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR)
60224 HYBRID_BREAK();
60225 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV):
60226 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
60227 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60228 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV)
60229 HYBRID_BREAK();
60230 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST):
60231 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
60232 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60233 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST)
60234 HYBRID_BREAK();
60235 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP):
60236 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
60237 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60238 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP)
60239 HYBRID_BREAK();
60240 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR):
60241 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
60242 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60243 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR)
60244 HYBRID_BREAK();
60245 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV):
60246 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
60247 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60248 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV)
60249 HYBRID_BREAK();
60250 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED):
60251 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
60252 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60253 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED)
60254 HYBRID_BREAK();
60255 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED):
60256 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
60257 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60258 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
60259 HYBRID_BREAK();
60260 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR):
60261 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
60262 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60263 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
60264 HYBRID_BREAK();
60265 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV):
60266 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
60267 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60268 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
60269 HYBRID_BREAK();
60270 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST):
60271 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
60272 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60273 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
60274 HYBRID_BREAK();
60275 HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_CONST):
60276 VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_CONST)
60277 ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60278 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_CONST)
60279 HYBRID_BREAK();
60280 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST):
60281 VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
60282 ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60283 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST)
60284 HYBRID_BREAK();
60285 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST):
60286 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
60287 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60288 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST)
60289 HYBRID_BREAK();
60290 HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_CONST):
60291 VM_TRACE(ZEND_SEND_REF_SPEC_VAR_CONST)
60292 ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60293 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_CONST)
60294 HYBRID_BREAK();
60295 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST):
60296 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
60297 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60298 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_CONST)
60299 HYBRID_BREAK();
60300 HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST):
60301 VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
60302 ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60303 VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST)
60304 HYBRID_BREAK();
60305 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST):
60306 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
60307 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60308 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST)
60309 HYBRID_BREAK();
60310 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST):
60311 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
60312 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60313 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST)
60314 HYBRID_BREAK();
60315 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CONST):
60316 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
60317 ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60318 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CONST)
60319 HYBRID_BREAK();
60320 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CONST):
60321 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CONST)
60322 ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60323 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CONST)
60324 HYBRID_BREAK();
60325 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CONST):
60326 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
60327 ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60328 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CONST)
60329 HYBRID_BREAK();
60330 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CONST):
60331 VM_TRACE(ZEND_YIELD_SPEC_VAR_CONST)
60332 ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60333 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CONST)
60334 HYBRID_BREAK();
60335 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_VAR_CONST):
60336 VM_TRACE(ZEND_IN_ARRAY_SPEC_VAR_CONST)
60337 ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60338 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_VAR_CONST)
60339 HYBRID_BREAK();
60340 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV):
60341 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
60342 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60343 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV)
60344 HYBRID_BREAK();
60345 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR):
60346 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
60347 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60348 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR)
60349 HYBRID_BREAK();
60350 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR):
60351 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
60352 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60353 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR)
60354 HYBRID_BREAK();
60355 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR):
60356 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
60357 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60358 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR)
60359 HYBRID_BREAK();
60360 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR):
60361 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
60362 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60363 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
60364 HYBRID_BREAK();
60365 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR):
60366 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
60367 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60368 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR)
60369 HYBRID_BREAK();
60370 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR):
60371 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
60372 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60373 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR)
60374 HYBRID_BREAK();
60375 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR):
60376 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
60377 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60378 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR)
60379 HYBRID_BREAK();
60380 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR):
60381 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
60382 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60383 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR)
60384 HYBRID_BREAK();
60385 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR):
60386 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
60387 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60388 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR)
60389 HYBRID_BREAK();
60390 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR):
60391 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
60392 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60393 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR)
60394 HYBRID_BREAK();
60395 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR):
60396 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
60397 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60398 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR)
60399 HYBRID_BREAK();
60400 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR):
60401 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
60402 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60403 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR)
60404 HYBRID_BREAK();
60405 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR):
60406 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
60407 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60408 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR)
60409 HYBRID_BREAK();
60410 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR):
60411 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
60412 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60413 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR)
60414 HYBRID_BREAK();
60415 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST):
60416 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
60417 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60418 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST)
60419 HYBRID_BREAK();
60420 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP):
60421 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
60422 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60423 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP)
60424 HYBRID_BREAK();
60425 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR):
60426 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60427 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60428 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60429 HYBRID_BREAK();
60430 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV):
60431 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
60432 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60433 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV)
60434 HYBRID_BREAK();
60435 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST):
60436 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
60437 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60438 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST)
60439 HYBRID_BREAK();
60440 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP):
60441 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
60442 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60443 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP)
60444 HYBRID_BREAK();
60445 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR):
60446 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60447 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60448 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60449 HYBRID_BREAK();
60450 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV):
60451 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
60452 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60453 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
60454 HYBRID_BREAK();
60455 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR):
60456 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60457 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60458 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
60459 HYBRID_BREAK();
60460 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV):
60461 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
60462 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60463 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
60464 HYBRID_BREAK();
60465 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR):
60466 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
60467 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60468 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
60469 HYBRID_BREAK();
60470 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR):
60471 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
60472 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60473 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR)
60474 HYBRID_BREAK();
60475 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR):
60476 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
60477 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60478 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR)
60479 HYBRID_BREAK();
60480 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR):
60481 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
60482 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60483 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR)
60484 HYBRID_BREAK();
60485 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR):
60486 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
60487 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60488 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR)
60489 HYBRID_BREAK();
60490 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_TMPVAR):
60491 VM_TRACE(ZEND_YIELD_SPEC_VAR_TMPVAR)
60492 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60493 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_TMPVAR)
60494 HYBRID_BREAK();
60495 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP):
60496 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
60497 ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60498 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_TMP)
60499 HYBRID_BREAK();
60500 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_TMP):
60501 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_TMP)
60502 ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60503 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_TMP)
60504 HYBRID_BREAK();
60505 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP):
60506 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
60507 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60508 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP)
60509 HYBRID_BREAK();
60510 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED):
60511 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
60512 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60513 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED)
60514 HYBRID_BREAK();
60515 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED):
60516 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
60517 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60518 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED)
60519 HYBRID_BREAK();
60520 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR):
60521 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
60522 ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60523 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_VAR)
60524 HYBRID_BREAK();
60525 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_VAR):
60526 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_VAR)
60527 ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60528 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_VAR)
60529 HYBRID_BREAK();
60530 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR):
60531 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
60532 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60533 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR)
60534 HYBRID_BREAK();
60535 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED):
60536 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
60537 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60538 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED)
60539 HYBRID_BREAK();
60540 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED):
60541 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
60542 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60543 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED)
60544 HYBRID_BREAK();
60545 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_VAR):
60546 VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
60547 ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60548 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_VAR)
60549 HYBRID_BREAK();
60550 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED):
60551 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
60552 ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60553 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED)
60554 HYBRID_BREAK();
60555 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED):
60556 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
60557 ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60558 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
60559 HYBRID_BREAK();
60560 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED):
60561 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
60562 ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60563 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED)
60564 HYBRID_BREAK();
60565 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED):
60566 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
60567 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60568 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED)
60569 HYBRID_BREAK();
60570 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST):
60571 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
60572 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60573 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST)
60574 HYBRID_BREAK();
60575 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP):
60576 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
60577 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60578 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP)
60579 HYBRID_BREAK();
60580 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR):
60581 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
60582 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60583 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR)
60584 HYBRID_BREAK();
60585 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV):
60586 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
60587 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60588 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV)
60589 HYBRID_BREAK();
60590 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED):
60591 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
60592 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60593 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED)
60594 HYBRID_BREAK();
60595 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED):
60596 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
60597 ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60598 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED)
60599 HYBRID_BREAK();
60600 HYBRID_CASE(ZEND_SEND_VAR_SPEC_VAR_UNUSED):
60601 VM_TRACE(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
60602 ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60603 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_VAR_UNUSED)
60604 HYBRID_BREAK();
60605 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED):
60606 VM_TRACE(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
60607 ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60608 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED)
60609 HYBRID_BREAK();
60610 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED):
60611 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
60612 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60613 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED)
60614 HYBRID_BREAK();
60615 HYBRID_CASE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK):
60616 VM_TRACE(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
60617 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60618 VM_TRACE_OP_END(ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK)
60619 HYBRID_BREAK();
60620 HYBRID_CASE(ZEND_SEND_REF_SPEC_VAR_UNUSED):
60621 VM_TRACE(ZEND_SEND_REF_SPEC_VAR_UNUSED)
60622 ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60623 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_VAR_UNUSED)
60624 HYBRID_BREAK();
60625 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED):
60626 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
60627 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60628 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED)
60629 HYBRID_BREAK();
60630 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK):
60631 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
60632 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60633 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK)
60634 HYBRID_BREAK();
60635 HYBRID_CASE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED):
60636 VM_TRACE(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
60637 ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60638 VM_TRACE_OP_END(ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED)
60639 HYBRID_BREAK();
60640 HYBRID_CASE(ZEND_NEW_SPEC_VAR_UNUSED):
60641 VM_TRACE(ZEND_NEW_SPEC_VAR_UNUSED)
60642 ZEND_NEW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60643 VM_TRACE_OP_END(ZEND_NEW_SPEC_VAR_UNUSED)
60644 HYBRID_BREAK();
60645 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED):
60646 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
60647 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60648 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED)
60649 HYBRID_BREAK();
60650 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED):
60651 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
60652 ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60653 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_UNUSED)
60654 HYBRID_BREAK();
60655 HYBRID_CASE(ZEND_SEPARATE_SPEC_VAR_UNUSED):
60656 VM_TRACE(ZEND_SEPARATE_SPEC_VAR_UNUSED)
60657 ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60658 VM_TRACE_OP_END(ZEND_SEPARATE_SPEC_VAR_UNUSED)
60659 HYBRID_BREAK();
60660 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_UNUSED):
60661 VM_TRACE(ZEND_YIELD_SPEC_VAR_UNUSED)
60662 ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60663 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_UNUSED)
60664 HYBRID_BREAK();
60665 HYBRID_CASE(ZEND_MAKE_REF_SPEC_VAR_UNUSED):
60666 VM_TRACE(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
60667 ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60668 VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_VAR_UNUSED)
60669 HYBRID_BREAK();
60670 HYBRID_CASE(ZEND_GET_TYPE_SPEC_VAR_UNUSED):
60671 VM_TRACE(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
60672 ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60673 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
60674 HYBRID_BREAK();
60675 HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED):
60676 VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
60677 ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60678 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
60679 HYBRID_BREAK();
60680 HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CV):
60681 VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CV)
60682 ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60683 VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CV)
60684 HYBRID_BREAK();
60685 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV):
60686 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
60687 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60688 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV)
60689 HYBRID_BREAK();
60690 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV):
60691 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
60692 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60693 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV)
60694 HYBRID_BREAK();
60695 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_CV):
60696 VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_CV)
60697 ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60698 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_CV)
60699 HYBRID_BREAK();
60700 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV):
60701 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
60702 ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60703 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_CV)
60704 HYBRID_BREAK();
60705 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_CV):
60706 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
60707 ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60708 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_CV)
60709 HYBRID_BREAK();
60710 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_CV):
60711 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
60712 ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60713 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_CV)
60714 HYBRID_BREAK();
60715 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV):
60716 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
60717 ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60718 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_CV)
60719 HYBRID_BREAK();
60720 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV):
60721 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
60722 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60723 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV)
60724 HYBRID_BREAK();
60725 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV):
60726 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
60727 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60728 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV)
60729 HYBRID_BREAK();
60730 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV):
60731 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
60732 ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60733 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_CV)
60734 HYBRID_BREAK();
60735 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV):
60736 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
60737 ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60738 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_CV)
60739 HYBRID_BREAK();
60740 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV):
60741 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
60742 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60743 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV)
60744 HYBRID_BREAK();
60745 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV):
60746 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
60747 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60748 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV)
60749 HYBRID_BREAK();
60750 HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_CV):
60751 VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
60752 ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60753 VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_CV)
60754 HYBRID_BREAK();
60755 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST):
60756 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
60757 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60758 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST)
60759 HYBRID_BREAK();
60760 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP):
60761 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
60762 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60763 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP)
60764 HYBRID_BREAK();
60765 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR):
60766 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
60767 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60768 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR)
60769 HYBRID_BREAK();
60770 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV):
60771 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
60772 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60773 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV)
60774 HYBRID_BREAK();
60775 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST):
60776 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
60777 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60778 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST)
60779 HYBRID_BREAK();
60780 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP):
60781 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
60782 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60783 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP)
60784 HYBRID_BREAK();
60785 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR):
60786 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
60787 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60788 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR)
60789 HYBRID_BREAK();
60790 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV):
60791 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
60792 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60793 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV)
60794 HYBRID_BREAK();
60795 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED):
60796 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
60797 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60798 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED)
60799 HYBRID_BREAK();
60800 HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED):
60801 VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
60802 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60803 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED)
60804 HYBRID_BREAK();
60805 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_CV):
60806 VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_CV)
60807 ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60808 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_VAR_CV)
60809 HYBRID_BREAK();
60810 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR):
60811 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
60812 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60813 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
60814 HYBRID_BREAK();
60815 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV):
60816 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
60817 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60818 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
60819 HYBRID_BREAK();
60820 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV):
60821 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
60822 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60823 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
60824 HYBRID_BREAK();
60825 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV):
60826 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
60827 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60828 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV)
60829 HYBRID_BREAK();
60830 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_CV):
60831 VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_CV)
60832 ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60833 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_CV)
60834 HYBRID_BREAK();
60835 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_CV):
60836 VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_CV)
60837 ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60838 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_CV)
60839 HYBRID_BREAK();
60840 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_CV):
60841 VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_CV)
60842 ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60843 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_CV)
60844 HYBRID_BREAK();
60845 HYBRID_CASE(ZEND_YIELD_SPEC_VAR_CV):
60846 VM_TRACE(ZEND_YIELD_SPEC_VAR_CV)
60847 ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60848 VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CV)
60849 HYBRID_BREAK();
60850 HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED):
60851 VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
60852 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60853 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED)
60854 HYBRID_BREAK();
60855 HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED):
60856 VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
60857 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60858 VM_TRACE_OP_END(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED)
60859 HYBRID_BREAK();
60860 HYBRID_CASE(ZEND_CLONE_SPEC_UNUSED):
60861 VM_TRACE(ZEND_CLONE_SPEC_UNUSED)
60862 ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60863 VM_TRACE_OP_END(ZEND_CLONE_SPEC_UNUSED)
60864 HYBRID_BREAK();
60865 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED):
60866 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
60867 ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60868 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_UNUSED)
60869 HYBRID_BREAK();
60870 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST):
60871 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
60872 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60873 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST)
60874 HYBRID_BREAK();
60875 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST):
60876 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
60877 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60878 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST)
60879 HYBRID_BREAK();
60880 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST):
60881 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
60882 ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60883 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
60884 HYBRID_BREAK();
60885 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST):
60886 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
60887 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60888 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
60889 HYBRID_BREAK();
60890 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST):
60891 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
60892 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60893 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST)
60894 HYBRID_BREAK();
60895 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST):
60896 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
60897 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60898 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST)
60899 HYBRID_BREAK();
60900 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST):
60901 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
60902 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60903 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST)
60904 HYBRID_BREAK();
60905 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST):
60906 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
60907 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60908 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST)
60909 HYBRID_BREAK();
60910 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST):
60911 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
60912 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60913 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST)
60914 HYBRID_BREAK();
60915 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST):
60916 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
60917 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60918 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST)
60919 HYBRID_BREAK();
60920 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP):
60921 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
60922 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60923 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP)
60924 HYBRID_BREAK();
60925 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR):
60926 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
60927 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60928 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR)
60929 HYBRID_BREAK();
60930 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV):
60931 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
60932 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60933 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
60934 HYBRID_BREAK();
60935 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR):
60936 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
60937 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60938 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
60939 HYBRID_BREAK();
60940 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV):
60941 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
60942 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60943 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
60944 HYBRID_BREAK();
60945 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST):
60946 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
60947 ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60948 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
60949 HYBRID_BREAK();
60950 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST):
60951 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
60952 ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60953 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CONST)
60954 HYBRID_BREAK();
60955 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST):
60956 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
60957 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60958 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST)
60959 HYBRID_BREAK();
60960 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST):
60961 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
60962 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60963 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST)
60964 HYBRID_BREAK();
60965 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST):
60966 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
60967 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60968 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST)
60969 HYBRID_BREAK();
60970 HYBRID_CASE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST):
60971 VM_TRACE(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
60972 ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60973 VM_TRACE_OP_END(ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST)
60974 HYBRID_BREAK();
60975 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST):
60976 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
60977 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60978 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST)
60979 HYBRID_BREAK();
60980 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST):
60981 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
60982 ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60983 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CONST)
60984 HYBRID_BREAK();
60985 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST):
60986 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
60987 ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60988 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CONST)
60989 HYBRID_BREAK();
60990 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST):
60991 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
60992 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60993 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST)
60994 HYBRID_BREAK();
60995 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CONST):
60996 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CONST)
60997 ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
60998 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CONST)
60999 HYBRID_BREAK();
61000 HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV):
61001 VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
61002 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61003 VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
61004 HYBRID_BREAK();
61005 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR):
61006 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
61007 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61008 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR)
61009 HYBRID_BREAK();
61010 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR):
61011 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
61012 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61013 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR)
61014 HYBRID_BREAK();
61015 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR):
61016 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
61017 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61018 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR)
61019 HYBRID_BREAK();
61020 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR):
61021 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
61022 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61023 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR)
61024 HYBRID_BREAK();
61025 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR):
61026 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
61027 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61028 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR)
61029 HYBRID_BREAK();
61030 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR):
61031 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
61032 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61033 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR)
61034 HYBRID_BREAK();
61035 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR):
61036 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
61037 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61038 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR)
61039 HYBRID_BREAK();
61040 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR):
61041 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
61042 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61043 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR)
61044 HYBRID_BREAK();
61045 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR):
61046 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
61047 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61048 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR)
61049 HYBRID_BREAK();
61050 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST):
61051 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
61052 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61053 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST)
61054 HYBRID_BREAK();
61055 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP):
61056 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
61057 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61058 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP)
61059 HYBRID_BREAK();
61060 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
61061 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
61062 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61063 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
61064 HYBRID_BREAK();
61065 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
61066 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
61067 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61068 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
61069 HYBRID_BREAK();
61070 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
61071 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
61072 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61073 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
61074 HYBRID_BREAK();
61075 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
61076 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
61077 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61078 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
61079 HYBRID_BREAK();
61080 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR):
61081 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
61082 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61083 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
61084 HYBRID_BREAK();
61085 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR):
61086 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
61087 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61088 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR)
61089 HYBRID_BREAK();
61090 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR):
61091 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
61092 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61093 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR)
61094 HYBRID_BREAK();
61095 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR):
61096 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
61097 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61098 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR)
61099 HYBRID_BREAK();
61100 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR):
61101 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
61102 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61103 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR)
61104 HYBRID_BREAK();
61105 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR):
61106 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
61107 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61108 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR)
61109 HYBRID_BREAK();
61110 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR):
61111 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
61112 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61113 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR)
61114 HYBRID_BREAK();
61115 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_TMPVAR):
61116 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
61117 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61118 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_TMPVAR)
61119 HYBRID_BREAK();
61120 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED):
61121 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
61122 ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61123 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED)
61124 HYBRID_BREAK();
61125 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED):
61126 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
61127 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61128 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED)
61129 HYBRID_BREAK();
61130 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED):
61131 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
61132 ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61133 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED)
61134 HYBRID_BREAK();
61135 HYBRID_CASE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED):
61136 VM_TRACE(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
61137 ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61138 VM_TRACE_OP_END(ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED)
61139 HYBRID_BREAK();
61140 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED):
61141 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
61142 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61143 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED)
61144 HYBRID_BREAK();
61145 HYBRID_CASE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK):
61146 VM_TRACE(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
61147 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61148 VM_TRACE_OP_END(ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK)
61149 HYBRID_BREAK();
61150 HYBRID_CASE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED):
61151 VM_TRACE(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
61152 ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61153 VM_TRACE_OP_END(ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED)
61154 HYBRID_BREAK();
61155 HYBRID_CASE(ZEND_NEW_SPEC_UNUSED_UNUSED):
61156 VM_TRACE(ZEND_NEW_SPEC_UNUSED_UNUSED)
61157 ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61158 VM_TRACE_OP_END(ZEND_NEW_SPEC_UNUSED_UNUSED)
61159 HYBRID_BREAK();
61160 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED):
61161 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
61162 ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61163 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED)
61164 HYBRID_BREAK();
61165 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_UNUSED):
61166 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_UNUSED)
61167 ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61168 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_UNUSED)
61169 HYBRID_BREAK();
61170 HYBRID_CASE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED):
61171 VM_TRACE(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
61172 ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61173 VM_TRACE_OP_END(ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED)
61174 HYBRID_BREAK();
61175 HYBRID_CASE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED):
61176 VM_TRACE(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
61177 ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61178 VM_TRACE_OP_END(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
61179 HYBRID_BREAK();
61180 HYBRID_CASE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED):
61181 VM_TRACE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
61182 ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61183 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
61184 HYBRID_BREAK();
61185 HYBRID_CASE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED):
61186 VM_TRACE(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
61187 ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61188 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_UNUSED_UNUSED)
61189 HYBRID_BREAK();
61190 HYBRID_CASE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED):
61191 VM_TRACE(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
61192 ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61193 VM_TRACE_OP_END(ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED)
61194 HYBRID_BREAK();
61195 HYBRID_CASE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED):
61196 VM_TRACE(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
61197 ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61198 VM_TRACE_OP_END(ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED)
61199 HYBRID_BREAK();
61200 HYBRID_CASE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED):
61201 VM_TRACE(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
61202 ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61203 VM_TRACE_OP_END(ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED)
61204 HYBRID_BREAK();
61205 HYBRID_CASE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED):
61206 VM_TRACE(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
61207 ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61208 VM_TRACE_OP_END(ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED)
61209 HYBRID_BREAK();
61210 HYBRID_CASE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED):
61211 VM_TRACE(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
61212 ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61213 VM_TRACE_OP_END(ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED)
61214 HYBRID_BREAK();
61215 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV):
61216 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
61217 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61218 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV)
61219 HYBRID_BREAK();
61220 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV):
61221 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
61222 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61223 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV)
61224 HYBRID_BREAK();
61225 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV):
61226 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
61227 ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61228 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CV)
61229 HYBRID_BREAK();
61230 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV):
61231 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
61232 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61233 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV)
61234 HYBRID_BREAK();
61235 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV):
61236 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
61237 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61238 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV)
61239 HYBRID_BREAK();
61240 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV):
61241 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
61242 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61243 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV)
61244 HYBRID_BREAK();
61245 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV):
61246 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
61247 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61248 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV)
61249 HYBRID_BREAK();
61250 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV):
61251 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
61252 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61253 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV)
61254 HYBRID_BREAK();
61255 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV):
61256 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
61257 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61258 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV)
61259 HYBRID_BREAK();
61260 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST):
61261 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
61262 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61263 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST)
61264 HYBRID_BREAK();
61265 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP):
61266 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
61267 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61268 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP)
61269 HYBRID_BREAK();
61270 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR):
61271 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
61272 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61273 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR)
61274 HYBRID_BREAK();
61275 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV):
61276 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
61277 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61278 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
61279 HYBRID_BREAK();
61280 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR):
61281 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
61282 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61283 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
61284 HYBRID_BREAK();
61285 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV):
61286 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
61287 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61288 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
61289 HYBRID_BREAK();
61290 HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CV):
61291 VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
61292 ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61293 VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
61294 HYBRID_BREAK();
61295 HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV):
61296 VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
61297 ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61298 VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_CV)
61299 HYBRID_BREAK();
61300 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV):
61301 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
61302 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61303 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV)
61304 HYBRID_BREAK();
61305 HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV):
61306 VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
61307 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61308 VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV)
61309 HYBRID_BREAK();
61310 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV):
61311 VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
61312 ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61313 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_CV)
61314 HYBRID_BREAK();
61315 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV):
61316 VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
61317 ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61318 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_CV)
61319 HYBRID_BREAK();
61320 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV):
61321 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
61322 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61323 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV)
61324 HYBRID_BREAK();
61325 HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_CV):
61326 VM_TRACE(ZEND_YIELD_SPEC_UNUSED_CV)
61327 ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61328 VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CV)
61329 HYBRID_BREAK();
61330 HYBRID_CASE(ZEND_BOOL_NOT_SPEC_CV):
61331 VM_TRACE(ZEND_BOOL_NOT_SPEC_CV)
61332 ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61333 VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_CV)
61334 HYBRID_BREAK();
61335 HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED):
61336 VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
61337 ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61338 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED)
61339 HYBRID_BREAK();
61340 HYBRID_CASE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED):
61341 VM_TRACE(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
61342 ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61343 VM_TRACE_OP_END(ZEND_PRE_INC_SPEC_CV_RETVAL_USED)
61344 HYBRID_BREAK();
61345 HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED):
61346 VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
61347 ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61348 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED)
61349 HYBRID_BREAK();
61350 HYBRID_CASE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED):
61351 VM_TRACE(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
61352 ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61353 VM_TRACE_OP_END(ZEND_PRE_DEC_SPEC_CV_RETVAL_USED)
61354 HYBRID_BREAK();
61355 HYBRID_CASE(ZEND_POST_INC_SPEC_CV):
61356 VM_TRACE(ZEND_POST_INC_SPEC_CV)
61357 ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61358 VM_TRACE_OP_END(ZEND_POST_INC_SPEC_CV)
61359 HYBRID_BREAK();
61360 HYBRID_CASE(ZEND_POST_DEC_SPEC_CV):
61361 VM_TRACE(ZEND_POST_DEC_SPEC_CV)
61362 ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61363 VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_CV)
61364 HYBRID_BREAK();
61365 HYBRID_CASE(ZEND_ECHO_SPEC_CV):
61366 VM_TRACE(ZEND_ECHO_SPEC_CV)
61367 ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61368 VM_TRACE_OP_END(ZEND_ECHO_SPEC_CV)
61369 HYBRID_BREAK();
61370 HYBRID_CASE(ZEND_JMPZ_SPEC_CV):
61371 VM_TRACE(ZEND_JMPZ_SPEC_CV)
61372 ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61373 VM_TRACE_OP_END(ZEND_JMPZ_SPEC_CV)
61374 HYBRID_BREAK();
61375 HYBRID_CASE(ZEND_JMPNZ_SPEC_CV):
61376 VM_TRACE(ZEND_JMPNZ_SPEC_CV)
61377 ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61378 VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_CV)
61379 HYBRID_BREAK();
61380 HYBRID_CASE(ZEND_JMPZ_EX_SPEC_CV):
61381 VM_TRACE(ZEND_JMPZ_EX_SPEC_CV)
61382 ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61383 VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_CV)
61384 HYBRID_BREAK();
61385 HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_CV):
61386 VM_TRACE(ZEND_JMPNZ_EX_SPEC_CV)
61387 ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61388 VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_CV)
61389 HYBRID_BREAK();
61390 HYBRID_CASE(ZEND_RETURN_SPEC_CV):
61391 VM_TRACE(ZEND_RETURN_SPEC_CV)
61392 {
61393 USE_OPLINE
61394 zval *retval_ptr;
61395 zval *return_value;
61396
61397 retval_ptr = EX_VAR(opline->op1.var);
61398 return_value = EX(return_value);
61399
61400 if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
61401 SAVE_OPLINE();
61402 retval_ptr = ZVAL_UNDEFINED_OP1();
61403 if (return_value) {
61404 ZVAL_NULL(return_value);
61405 }
61406 } else if (!return_value) {
61407 if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
61408 if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
61409 SAVE_OPLINE();
61410 rc_dtor_func(Z_COUNTED_P(retval_ptr));
61411 }
61412 }
61413 } else {
61414 if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
61415 ZVAL_COPY_VALUE(return_value, retval_ptr);
61416 if (IS_CV == IS_CONST) {
61417 if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
61418 Z_ADDREF_P(return_value);
61419 }
61420 }
61421 } else if (IS_CV == IS_CV) {
61422 do {
61423 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61424 if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
61425 if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) {
61426 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61427 ZVAL_COPY_VALUE(return_value, retval_ptr);
61428 if (GC_MAY_LEAK(ref)) {
61429 SAVE_OPLINE();
61430 gc_possible_root(ref);
61431 }
61432 ZVAL_NULL(retval_ptr);
61433 break;
61434 } else {
61435 Z_ADDREF_P(retval_ptr);
61436 }
61437 } else {
61438 retval_ptr = Z_REFVAL_P(retval_ptr);
61439 if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61440 Z_ADDREF_P(retval_ptr);
61441 }
61442 }
61443 }
61444 ZVAL_COPY_VALUE(return_value, retval_ptr);
61445 } while (0);
61446 } else /* if (IS_CV == IS_VAR) */ {
61447 if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
61448 zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
61449
61450 retval_ptr = Z_REFVAL_P(retval_ptr);
61451 ZVAL_COPY_VALUE(return_value, retval_ptr);
61452 if (UNEXPECTED(GC_DELREF(ref) == 0)) {
61453 efree_size(ref, sizeof(zend_reference));
61454 } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
61455 Z_ADDREF_P(retval_ptr);
61456 }
61457 } else {
61458 ZVAL_COPY_VALUE(return_value, retval_ptr);
61459 }
61460 }
61461 }
61462
61463
61464
61465 goto zend_leave_helper_SPEC_LABEL;
61466 }
61467
61468 VM_TRACE_OP_END(ZEND_RETURN_SPEC_CV)
61469 HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CV):
61470 VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CV)
61471 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61472 VM_TRACE_OP_END(ZEND_RETURN_BY_REF_SPEC_CV)
61473 HYBRID_BREAK();
61474 HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CV):
61475 VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CV)
61476 ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61477 VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_CV)
61478 HYBRID_BREAK();
61479 HYBRID_CASE(ZEND_THROW_SPEC_CV):
61480 VM_TRACE(ZEND_THROW_SPEC_CV)
61481 ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61482 VM_TRACE_OP_END(ZEND_THROW_SPEC_CV)
61483 HYBRID_BREAK();
61484 HYBRID_CASE(ZEND_SEND_USER_SPEC_CV):
61485 VM_TRACE(ZEND_SEND_USER_SPEC_CV)
61486 ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61487 VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV)
61488 HYBRID_BREAK();
61489 HYBRID_CASE(ZEND_BOOL_SPEC_CV):
61490 VM_TRACE(ZEND_BOOL_SPEC_CV)
61491 ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61492 VM_TRACE_OP_END(ZEND_BOOL_SPEC_CV)
61493 HYBRID_BREAK();
61494 HYBRID_CASE(ZEND_CLONE_SPEC_CV):
61495 VM_TRACE(ZEND_CLONE_SPEC_CV)
61496 ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61497 VM_TRACE_OP_END(ZEND_CLONE_SPEC_CV)
61498 HYBRID_BREAK();
61499 HYBRID_CASE(ZEND_CAST_SPEC_CV):
61500 VM_TRACE(ZEND_CAST_SPEC_CV)
61501 ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61502 VM_TRACE_OP_END(ZEND_CAST_SPEC_CV)
61503 HYBRID_BREAK();
61504 HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CV):
61505 VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
61506 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61507 VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
61508 HYBRID_BREAK();
61509 HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CV):
61510 VM_TRACE(ZEND_FE_RESET_R_SPEC_CV)
61511 ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61512 VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_CV)
61513 HYBRID_BREAK();
61514 HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_CV):
61515 VM_TRACE(ZEND_FE_RESET_RW_SPEC_CV)
61516 ZEND_FE_RESET_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61517 VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_CV)
61518 HYBRID_BREAK();
61519 HYBRID_CASE(ZEND_JMP_SET_SPEC_CV):
61520 VM_TRACE(ZEND_JMP_SET_SPEC_CV)
61521 ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61522 VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_CV)
61523 HYBRID_BREAK();
61524 HYBRID_CASE(ZEND_COALESCE_SPEC_CV):
61525 VM_TRACE(ZEND_COALESCE_SPEC_CV)
61526 ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61527 VM_TRACE_OP_END(ZEND_COALESCE_SPEC_CV)
61528 HYBRID_BREAK();
61529 HYBRID_CASE(ZEND_JMP_NULL_SPEC_CV):
61530 VM_TRACE(ZEND_JMP_NULL_SPEC_CV)
61531 ZEND_JMP_NULL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61532 VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_CV)
61533 HYBRID_BREAK();
61534 HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CV):
61535 VM_TRACE(ZEND_QM_ASSIGN_SPEC_CV)
61536 ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61537 VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_CV)
61538 HYBRID_BREAK();
61539 HYBRID_CASE(ZEND_YIELD_FROM_SPEC_CV):
61540 VM_TRACE(ZEND_YIELD_FROM_SPEC_CV)
61541 ZEND_YIELD_FROM_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61542 VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_CV)
61543 HYBRID_BREAK();
61544 HYBRID_CASE(ZEND_STRLEN_SPEC_CV):
61545 VM_TRACE(ZEND_STRLEN_SPEC_CV)
61546 ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61547 VM_TRACE_OP_END(ZEND_STRLEN_SPEC_CV)
61548 HYBRID_BREAK();
61549 HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_CV):
61550 VM_TRACE(ZEND_TYPE_CHECK_SPEC_CV)
61551 ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61552 VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CV)
61553 HYBRID_BREAK();
61554 HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_CV):
61555 VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_CV)
61556 ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61557 VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_CV)
61558 HYBRID_BREAK();
61559 HYBRID_CASE(ZEND_BIND_STATIC_SPEC_CV):
61560 VM_TRACE(ZEND_BIND_STATIC_SPEC_CV)
61561 ZEND_BIND_STATIC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61562 VM_TRACE_OP_END(ZEND_BIND_STATIC_SPEC_CV)
61563 HYBRID_BREAK();
61564 HYBRID_CASE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV):
61565 VM_TRACE(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
61566 ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61567 VM_TRACE_OP_END(ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV)
61568 HYBRID_BREAK();
61569 HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
61570 VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
61571 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61572 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
61573 HYBRID_BREAK();
61574 HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
61575 VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
61576 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61577 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
61578 HYBRID_BREAK();
61579 HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED):
61580 VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
61581 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61582 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
61583 HYBRID_BREAK();
61584 HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED):
61585 VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
61586 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61587 VM_TRACE_OP_END(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
61588 HYBRID_BREAK();
61589 HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
61590 VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
61591 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61592 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
61593 HYBRID_BREAK();
61594 HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
61595 VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
61596 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61597 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
61598 HYBRID_BREAK();
61599 HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED):
61600 VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
61601 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61602 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
61603 HYBRID_BREAK();
61604 HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED):
61605 VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
61606 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61607 VM_TRACE_OP_END(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
61608 HYBRID_BREAK();
61609 HYBRID_CASE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV):
61610 VM_TRACE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
61611 ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61612 VM_TRACE_OP_END(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
61613 HYBRID_BREAK();
61614 HYBRID_CASE(ZEND_POST_INC_LONG_SPEC_CV):
61615 VM_TRACE(ZEND_POST_INC_LONG_SPEC_CV)
61616 ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61617 VM_TRACE_OP_END(ZEND_POST_INC_LONG_SPEC_CV)
61618 HYBRID_BREAK();
61619 HYBRID_CASE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV):
61620 VM_TRACE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
61621 ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61622 VM_TRACE_OP_END(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
61623 HYBRID_BREAK();
61624 HYBRID_CASE(ZEND_POST_DEC_LONG_SPEC_CV):
61625 VM_TRACE(ZEND_POST_DEC_LONG_SPEC_CV)
61626 ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61627 VM_TRACE_OP_END(ZEND_POST_DEC_LONG_SPEC_CV)
61628 HYBRID_BREAK();
61629 HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_CV):
61630 VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
61631 ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61632 VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
61633 HYBRID_BREAK();
61634 HYBRID_CASE(ZEND_DIV_SPEC_CV_CONST):
61635 VM_TRACE(ZEND_DIV_SPEC_CV_CONST)
61636 ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61637 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CONST)
61638 HYBRID_BREAK();
61639 HYBRID_CASE(ZEND_POW_SPEC_CV_CONST):
61640 VM_TRACE(ZEND_POW_SPEC_CV_CONST)
61641 ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61642 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CONST)
61643 HYBRID_BREAK();
61644 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CONST):
61645 VM_TRACE(ZEND_CONCAT_SPEC_CV_CONST)
61646 ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61647 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CONST)
61648 HYBRID_BREAK();
61649 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CONST):
61650 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
61651 ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61652 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CONST)
61653 HYBRID_BREAK();
61654 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST):
61655 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
61656 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61657 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST)
61658 HYBRID_BREAK();
61659 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST):
61660 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST)
61661 ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61662 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST)
61663 HYBRID_BREAK();
61664 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ):
61665 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
61666 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61667 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ)
61668 HYBRID_BREAK();
61669 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ):
61670 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
61671 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61672 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ)
61673 HYBRID_BREAK();
61674 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST):
61675 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
61676 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61677 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST)
61678 HYBRID_BREAK();
61679 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ):
61680 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
61681 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61682 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ)
61683 HYBRID_BREAK();
61684 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ):
61685 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
61686 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61687 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ)
61688 HYBRID_BREAK();
61689 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CONST):
61690 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CONST)
61691 ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61692 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CONST)
61693 HYBRID_BREAK();
61694 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CONST):
61695 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CONST)
61696 ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61697 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CONST)
61698 HYBRID_BREAK();
61699 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST):
61700 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
61701 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61702 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST)
61703 HYBRID_BREAK();
61704 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST):
61705 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
61706 ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61707 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST)
61708 HYBRID_BREAK();
61709 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CONST):
61710 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CONST)
61711 ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61712 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CONST)
61713 HYBRID_BREAK();
61714 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST):
61715 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
61716 ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61717 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
61718 HYBRID_BREAK();
61719 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CONST):
61720 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
61721 ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61722 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CONST)
61723 HYBRID_BREAK();
61724 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CONST):
61725 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
61726 ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61727 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CONST)
61728 HYBRID_BREAK();
61729 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CONST):
61730 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
61731 ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61732 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CONST)
61733 HYBRID_BREAK();
61734 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST):
61735 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
61736 ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61737 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CONST)
61738 HYBRID_BREAK();
61739 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST):
61740 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
61741 ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61742 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CONST)
61743 HYBRID_BREAK();
61744 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST):
61745 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
61746 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61747 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST)
61748 HYBRID_BREAK();
61749 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST):
61750 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
61751 ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61752 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST)
61753 HYBRID_BREAK();
61754 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST):
61755 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
61756 ZEND_FETCH_OBJ_R_SPEC_CV_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61757 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CONST)
61758 HYBRID_BREAK();
61759 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST):
61760 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
61761 ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61762 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CONST)
61763 HYBRID_BREAK();
61764 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST):
61765 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
61766 ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61767 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CONST)
61768 HYBRID_BREAK();
61769 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST):
61770 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
61771 ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61772 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CONST)
61773 HYBRID_BREAK();
61774 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST):
61775 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
61776 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61777 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST)
61778 HYBRID_BREAK();
61779 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST):
61780 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
61781 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61782 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST)
61783 HYBRID_BREAK();
61784 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST):
61785 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
61786 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61787 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST)
61788 HYBRID_BREAK();
61789 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP):
61790 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
61791 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61792 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP)
61793 HYBRID_BREAK();
61794 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR):
61795 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
61796 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61797 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR)
61798 HYBRID_BREAK();
61799 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV):
61800 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
61801 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61802 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
61803 HYBRID_BREAK();
61804 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST):
61805 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
61806 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61807 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
61808 HYBRID_BREAK();
61809 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP):
61810 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
61811 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61812 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP)
61813 HYBRID_BREAK();
61814 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR):
61815 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
61816 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61817 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR)
61818 HYBRID_BREAK();
61819 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV):
61820 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
61821 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61822 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV)
61823 HYBRID_BREAK();
61824 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED):
61825 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
61826 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61827 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED)
61828 HYBRID_BREAK();
61829 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED):
61830 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
61831 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61832 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
61833 HYBRID_BREAK();
61834 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR):
61835 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
61836 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61837 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
61838 HYBRID_BREAK();
61839 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV):
61840 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
61841 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61842 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
61843 HYBRID_BREAK();
61844 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CONST):
61845 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CONST)
61846 ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61847 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CONST)
61848 HYBRID_BREAK();
61849 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST):
61850 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
61851 ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61852 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CONST)
61853 HYBRID_BREAK();
61854 HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_CONST):
61855 VM_TRACE(ZEND_SEND_VAR_SPEC_CV_CONST)
61856 ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61857 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_CONST)
61858 HYBRID_BREAK();
61859 HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_CONST):
61860 VM_TRACE(ZEND_SEND_REF_SPEC_CV_CONST)
61861 ZEND_SEND_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61862 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_CONST)
61863 HYBRID_BREAK();
61864 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_CONST):
61865 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
61866 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61867 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_CONST)
61868 HYBRID_BREAK();
61869 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST):
61870 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
61871 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61872 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST)
61873 HYBRID_BREAK();
61874 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CONST):
61875 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CONST)
61876 ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61877 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CONST)
61878 HYBRID_BREAK();
61879 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CONST):
61880 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CONST)
61881 ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61882 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CONST)
61883 HYBRID_BREAK();
61884 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CONST):
61885 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CONST)
61886 ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61887 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CONST)
61888 HYBRID_BREAK();
61889 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST):
61890 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
61891 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61892 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST)
61893 HYBRID_BREAK();
61894 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST):
61895 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
61896 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61897 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
61898 HYBRID_BREAK();
61899 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST):
61900 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
61901 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61902 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
61903 HYBRID_BREAK();
61904 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_CONST):
61905 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_CONST)
61906 ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61907 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_CONST)
61908 HYBRID_BREAK();
61909 HYBRID_CASE(ZEND_YIELD_SPEC_CV_CONST):
61910 VM_TRACE(ZEND_YIELD_SPEC_CV_CONST)
61911 ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61912 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CONST)
61913 HYBRID_BREAK();
61914 HYBRID_CASE(ZEND_BIND_GLOBAL_SPEC_CV_CONST):
61915 VM_TRACE(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
61916 ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61917 VM_TRACE_OP_END(ZEND_BIND_GLOBAL_SPEC_CV_CONST)
61918 HYBRID_BREAK();
61919 HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CV_CONST):
61920 VM_TRACE(ZEND_IN_ARRAY_SPEC_CV_CONST)
61921 ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61922 VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_CV_CONST)
61923 HYBRID_BREAK();
61924 HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST):
61925 VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
61926 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61927 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST)
61928 HYBRID_BREAK();
61929 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST):
61930 VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
61931 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61932 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST)
61933 HYBRID_BREAK();
61934 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST):
61935 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
61936 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61937 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST)
61938 HYBRID_BREAK();
61939 HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV):
61940 VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
61941 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61942 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV)
61943 HYBRID_BREAK();
61944 HYBRID_CASE(ZEND_DIV_SPEC_CV_TMPVAR):
61945 VM_TRACE(ZEND_DIV_SPEC_CV_TMPVAR)
61946 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61947 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_TMPVAR)
61948 HYBRID_BREAK();
61949 HYBRID_CASE(ZEND_POW_SPEC_CV_TMPVAR):
61950 VM_TRACE(ZEND_POW_SPEC_CV_TMPVAR)
61951 ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61952 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_TMPVAR)
61953 HYBRID_BREAK();
61954 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_TMPVAR):
61955 VM_TRACE(ZEND_CONCAT_SPEC_CV_TMPVAR)
61956 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61957 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_TMPVAR)
61958 HYBRID_BREAK();
61959 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR):
61960 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
61961 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61962 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR)
61963 HYBRID_BREAK();
61964 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ):
61965 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
61966 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61967 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ)
61968 HYBRID_BREAK();
61969 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
61970 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
61971 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61972 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
61973 HYBRID_BREAK();
61974 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR):
61975 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
61976 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61977 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR)
61978 HYBRID_BREAK();
61979 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ):
61980 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
61981 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61982 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ)
61983 HYBRID_BREAK();
61984 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ):
61985 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
61986 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61987 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ)
61988 HYBRID_BREAK();
61989 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_TMPVAR):
61990 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
61991 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61992 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_TMPVAR)
61993 HYBRID_BREAK();
61994 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR):
61995 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
61996 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
61997 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_TMPVAR)
61998 HYBRID_BREAK();
61999 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR):
62000 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
62001 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62002 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR)
62003 HYBRID_BREAK();
62004 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR):
62005 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
62006 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62007 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR)
62008 HYBRID_BREAK();
62009 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR):
62010 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
62011 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62012 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR)
62013 HYBRID_BREAK();
62014 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR):
62015 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
62016 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62017 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
62018 HYBRID_BREAK();
62019 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR):
62020 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
62021 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62022 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR)
62023 HYBRID_BREAK();
62024 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR):
62025 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
62026 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62027 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR)
62028 HYBRID_BREAK();
62029 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR):
62030 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
62031 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62032 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR)
62033 HYBRID_BREAK();
62034 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR):
62035 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
62036 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62037 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR)
62038 HYBRID_BREAK();
62039 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR):
62040 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
62041 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62042 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR)
62043 HYBRID_BREAK();
62044 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR):
62045 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
62046 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62047 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR)
62048 HYBRID_BREAK();
62049 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR):
62050 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
62051 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62052 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR)
62053 HYBRID_BREAK();
62054 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR):
62055 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
62056 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62057 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR)
62058 HYBRID_BREAK();
62059 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR):
62060 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
62061 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62062 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR)
62063 HYBRID_BREAK();
62064 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR):
62065 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
62066 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62067 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR)
62068 HYBRID_BREAK();
62069 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR):
62070 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
62071 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62072 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR)
62073 HYBRID_BREAK();
62074 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR):
62075 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
62076 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62077 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR)
62078 HYBRID_BREAK();
62079 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR):
62080 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
62081 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62082 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR)
62083 HYBRID_BREAK();
62084 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST):
62085 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
62086 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62087 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST)
62088 HYBRID_BREAK();
62089 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP):
62090 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
62091 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62092 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP)
62093 HYBRID_BREAK();
62094 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR):
62095 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
62096 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62097 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR)
62098 HYBRID_BREAK();
62099 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV):
62100 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
62101 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62102 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV)
62103 HYBRID_BREAK();
62104 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST):
62105 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
62106 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62107 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST)
62108 HYBRID_BREAK();
62109 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP):
62110 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
62111 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62112 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP)
62113 HYBRID_BREAK();
62114 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR):
62115 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
62116 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62117 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR)
62118 HYBRID_BREAK();
62119 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV):
62120 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
62121 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62122 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
62123 HYBRID_BREAK();
62124 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR):
62125 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
62126 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62127 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
62128 HYBRID_BREAK();
62129 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV):
62130 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
62131 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62132 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
62133 HYBRID_BREAK();
62134 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR):
62135 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
62136 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62137 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
62138 HYBRID_BREAK();
62139 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR):
62140 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
62141 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62142 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR)
62143 HYBRID_BREAK();
62144 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR):
62145 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
62146 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62147 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR)
62148 HYBRID_BREAK();
62149 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR):
62150 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
62151 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62152 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR)
62153 HYBRID_BREAK();
62154 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR):
62155 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
62156 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62157 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_TMPVAR)
62158 HYBRID_BREAK();
62159 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR):
62160 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
62161 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62162 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR)
62163 HYBRID_BREAK();
62164 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR):
62165 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
62166 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62167 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR)
62168 HYBRID_BREAK();
62169 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR):
62170 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
62171 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62172 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
62173 HYBRID_BREAK();
62174 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR):
62175 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
62176 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62177 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
62178 HYBRID_BREAK();
62179 HYBRID_CASE(ZEND_YIELD_SPEC_CV_TMPVAR):
62180 VM_TRACE(ZEND_YIELD_SPEC_CV_TMPVAR)
62181 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62182 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_TMPVAR)
62183 HYBRID_BREAK();
62184 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_TMP):
62185 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
62186 ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62187 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
62188 HYBRID_BREAK();
62189 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP):
62190 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
62191 ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62192 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP)
62193 HYBRID_BREAK();
62194 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED):
62195 VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
62196 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62197 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED)
62198 HYBRID_BREAK();
62199 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED):
62200 VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
62201 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62202 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED)
62203 HYBRID_BREAK();
62204 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_VAR):
62205 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
62206 ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62207 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_VAR)
62208 HYBRID_BREAK();
62209 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR):
62210 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
62211 ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62212 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
62213 HYBRID_BREAK();
62214 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED):
62215 VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
62216 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62217 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
62218 HYBRID_BREAK();
62219 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED):
62220 VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
62221 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62222 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED)
62223 HYBRID_BREAK();
62224 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_VAR):
62225 VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_VAR)
62226 ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62227 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_VAR)
62228 HYBRID_BREAK();
62229 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_VAR):
62230 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_VAR)
62231 ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62232 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_VAR)
62233 HYBRID_BREAK();
62234 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED):
62235 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
62236 ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62237 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED)
62238 HYBRID_BREAK();
62239 HYBRID_CASE(ZEND_FETCH_R_SPEC_CV_UNUSED):
62240 VM_TRACE(ZEND_FETCH_R_SPEC_CV_UNUSED)
62241 ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62242 VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_CV_UNUSED)
62243 HYBRID_BREAK();
62244 HYBRID_CASE(ZEND_FETCH_W_SPEC_CV_UNUSED):
62245 VM_TRACE(ZEND_FETCH_W_SPEC_CV_UNUSED)
62246 ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62247 VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_CV_UNUSED)
62248 HYBRID_BREAK();
62249 HYBRID_CASE(ZEND_FETCH_RW_SPEC_CV_UNUSED):
62250 VM_TRACE(ZEND_FETCH_RW_SPEC_CV_UNUSED)
62251 ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62252 VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_CV_UNUSED)
62253 HYBRID_BREAK();
62254 HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED):
62255 VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
62256 ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62257 VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED)
62258 HYBRID_BREAK();
62259 HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED):
62260 VM_TRACE(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
62261 ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62262 VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_CV_UNUSED)
62263 HYBRID_BREAK();
62264 HYBRID_CASE(ZEND_FETCH_IS_SPEC_CV_UNUSED):
62265 VM_TRACE(ZEND_FETCH_IS_SPEC_CV_UNUSED)
62266 ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62267 VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_CV_UNUSED)
62268 HYBRID_BREAK();
62269 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED):
62270 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
62271 ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62272 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED)
62273 HYBRID_BREAK();
62274 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED):
62275 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
62276 ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62277 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED)
62278 HYBRID_BREAK();
62279 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED):
62280 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
62281 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62282 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
62283 HYBRID_BREAK();
62284 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST):
62285 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
62286 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62287 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
62288 HYBRID_BREAK();
62289 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP):
62290 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
62291 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62292 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP)
62293 HYBRID_BREAK();
62294 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR):
62295 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
62296 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62297 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR)
62298 HYBRID_BREAK();
62299 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV):
62300 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
62301 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62302 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
62303 HYBRID_BREAK();
62304 HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED):
62305 VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
62306 ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62307 VM_TRACE_OP_END(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
62308 HYBRID_BREAK();
62309 HYBRID_CASE(ZEND_SEND_VAR_SPEC_CV_UNUSED):
62310 VM_TRACE(ZEND_SEND_VAR_SPEC_CV_UNUSED)
62311 ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62312 VM_TRACE_OP_END(ZEND_SEND_VAR_SPEC_CV_UNUSED)
62313 HYBRID_BREAK();
62314 HYBRID_CASE(ZEND_SEND_REF_SPEC_CV_UNUSED):
62315 VM_TRACE(ZEND_SEND_REF_SPEC_CV_UNUSED)
62316 ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62317 VM_TRACE_OP_END(ZEND_SEND_REF_SPEC_CV_UNUSED)
62318 HYBRID_BREAK();
62319 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED):
62320 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
62321 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62322 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED)
62323 HYBRID_BREAK();
62324 HYBRID_CASE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK):
62325 VM_TRACE(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
62326 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62327 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK)
62328 HYBRID_BREAK();
62329 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED):
62330 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
62331 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62332 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED)
62333 HYBRID_BREAK();
62334 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED):
62335 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
62336 ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62337 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_UNUSED)
62338 HYBRID_BREAK();
62339 HYBRID_CASE(ZEND_UNSET_CV_SPEC_CV_UNUSED):
62340 VM_TRACE(ZEND_UNSET_CV_SPEC_CV_UNUSED)
62341 ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62342 VM_TRACE_OP_END(ZEND_UNSET_CV_SPEC_CV_UNUSED)
62343 HYBRID_BREAK();
62344 HYBRID_CASE(ZEND_UNSET_VAR_SPEC_CV_UNUSED):
62345 VM_TRACE(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
62346 ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62347 VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_CV_UNUSED)
62348 HYBRID_BREAK();
62349 HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET):
62350 VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
62351 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62352 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET)
62353 HYBRID_BREAK();
62354 HYBRID_CASE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY):
62355 VM_TRACE(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
62356 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62357 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY)
62358 HYBRID_BREAK();
62359 HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED):
62360 VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
62361 ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62362 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED)
62363 HYBRID_BREAK();
62364 HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_UNUSED):
62365 VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
62366 ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62367 VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_CV_UNUSED)
62368 HYBRID_BREAK();
62369 HYBRID_CASE(ZEND_YIELD_SPEC_CV_UNUSED):
62370 VM_TRACE(ZEND_YIELD_SPEC_CV_UNUSED)
62371 ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62372 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_UNUSED)
62373 HYBRID_BREAK();
62374 HYBRID_CASE(ZEND_CHECK_VAR_SPEC_CV_UNUSED):
62375 VM_TRACE(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
62376 ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62377 VM_TRACE_OP_END(ZEND_CHECK_VAR_SPEC_CV_UNUSED)
62378 HYBRID_BREAK();
62379 HYBRID_CASE(ZEND_MAKE_REF_SPEC_CV_UNUSED):
62380 VM_TRACE(ZEND_MAKE_REF_SPEC_CV_UNUSED)
62381 ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62382 VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_CV_UNUSED)
62383 HYBRID_BREAK();
62384 HYBRID_CASE(ZEND_COUNT_SPEC_CV_UNUSED):
62385 VM_TRACE(ZEND_COUNT_SPEC_CV_UNUSED)
62386 ZEND_COUNT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62387 VM_TRACE_OP_END(ZEND_COUNT_SPEC_CV_UNUSED)
62388 HYBRID_BREAK();
62389 HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED):
62390 VM_TRACE(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
62391 ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62392 VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_CV_UNUSED)
62393 HYBRID_BREAK();
62394 HYBRID_CASE(ZEND_GET_CLASS_SPEC_CV_UNUSED):
62395 VM_TRACE(ZEND_GET_CLASS_SPEC_CV_UNUSED)
62396 ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62397 VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_CV_UNUSED)
62398 HYBRID_BREAK();
62399 HYBRID_CASE(ZEND_GET_TYPE_SPEC_CV_UNUSED):
62400 VM_TRACE(ZEND_GET_TYPE_SPEC_CV_UNUSED)
62401 ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62402 VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CV_UNUSED)
62403 HYBRID_BREAK();
62404 HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED):
62405 VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
62406 ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62407 VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
62408 HYBRID_BREAK();
62409 HYBRID_CASE(ZEND_DIV_SPEC_CV_CV):
62410 VM_TRACE(ZEND_DIV_SPEC_CV_CV)
62411 ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62412 VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_CV)
62413 HYBRID_BREAK();
62414 HYBRID_CASE(ZEND_POW_SPEC_CV_CV):
62415 VM_TRACE(ZEND_POW_SPEC_CV_CV)
62416 ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62417 VM_TRACE_OP_END(ZEND_POW_SPEC_CV_CV)
62418 HYBRID_BREAK();
62419 HYBRID_CASE(ZEND_CONCAT_SPEC_CV_CV):
62420 VM_TRACE(ZEND_CONCAT_SPEC_CV_CV)
62421 ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62422 VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_CV)
62423 HYBRID_BREAK();
62424 HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_CV):
62425 VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_CV)
62426 ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62427 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_CV)
62428 HYBRID_BREAK();
62429 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV):
62430 VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
62431 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62432 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV)
62433 HYBRID_BREAK();
62434 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV):
62435 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV)
62436 ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62437 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV)
62438 HYBRID_BREAK();
62439 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ):
62440 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
62441 ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62442 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ)
62443 HYBRID_BREAK();
62444 HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ):
62445 VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
62446 ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62447 VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ)
62448 HYBRID_BREAK();
62449 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV):
62450 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
62451 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62452 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV)
62453 HYBRID_BREAK();
62454 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ):
62455 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
62456 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62457 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ)
62458 HYBRID_BREAK();
62459 HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ):
62460 VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
62461 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62462 VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ)
62463 HYBRID_BREAK();
62464 HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_CV):
62465 VM_TRACE(ZEND_SPACESHIP_SPEC_CV_CV)
62466 ZEND_SPACESHIP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62467 VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_CV)
62468 HYBRID_BREAK();
62469 HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_CV):
62470 VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_CV)
62471 ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62472 VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_CV)
62473 HYBRID_BREAK();
62474 HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV):
62475 VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
62476 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62477 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV)
62478 HYBRID_BREAK();
62479 HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV):
62480 VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
62481 ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62482 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_CV)
62483 HYBRID_BREAK();
62484 HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_CV):
62485 VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_CV)
62486 ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62487 VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_CV)
62488 HYBRID_BREAK();
62489 HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CV):
62490 VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
62491 ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62492 VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_CV)
62493 HYBRID_BREAK();
62494 HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_CV):
62495 VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_CV)
62496 ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62497 VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_CV)
62498 HYBRID_BREAK();
62499 HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_CV):
62500 VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_CV)
62501 ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62502 VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_CV)
62503 HYBRID_BREAK();
62504 HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_CV):
62505 VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_CV)
62506 ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62507 VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_CV)
62508 HYBRID_BREAK();
62509 HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_CV):
62510 VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
62511 ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62512 VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_CV)
62513 HYBRID_BREAK();
62514 HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_CV):
62515 VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
62516 ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62517 VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_CV)
62518 HYBRID_BREAK();
62519 HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV):
62520 VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
62521 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62522 VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV)
62523 HYBRID_BREAK();
62524 HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV):
62525 VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
62526 ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62527 VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_CV)
62528 HYBRID_BREAK();
62529 HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_CV):
62530 VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
62531 ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62532 VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_CV)
62533 HYBRID_BREAK();
62534 HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_CV):
62535 VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
62536 ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62537 VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_CV)
62538 HYBRID_BREAK();
62539 HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV):
62540 VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
62541 ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62542 VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_CV)
62543 HYBRID_BREAK();
62544 HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV):
62545 VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
62546 ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62547 VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_CV)
62548 HYBRID_BREAK();
62549 HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV):
62550 VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
62551 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62552 VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV)
62553 HYBRID_BREAK();
62554 HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV):
62555 VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
62556 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62557 VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV)
62558 HYBRID_BREAK();
62559 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST):
62560 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
62561 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62562 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST)
62563 HYBRID_BREAK();
62564 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP):
62565 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
62566 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62567 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP)
62568 HYBRID_BREAK();
62569 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR):
62570 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
62571 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62572 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR)
62573 HYBRID_BREAK();
62574 HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV):
62575 VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
62576 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62577 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV)
62578 HYBRID_BREAK();
62579 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST):
62580 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
62581 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62582 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST)
62583 HYBRID_BREAK();
62584 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP):
62585 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
62586 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62587 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP)
62588 HYBRID_BREAK();
62589 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR):
62590 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
62591 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62592 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR)
62593 HYBRID_BREAK();
62594 HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV):
62595 VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
62596 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62597 VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV)
62598 HYBRID_BREAK();
62599 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED):
62600 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
62601 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62602 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED)
62603 HYBRID_BREAK();
62604 HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED):
62605 VM_TRACE(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
62606 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62607 VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED)
62608 HYBRID_BREAK();
62609 HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_CV):
62610 VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_CV)
62611 ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62612 VM_TRACE_OP_END(ZEND_ASSIGN_REF_SPEC_CV_CV)
62613 HYBRID_BREAK();
62614 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR):
62615 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
62616 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62617 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
62618 HYBRID_BREAK();
62619 HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV):
62620 VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
62621 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62622 VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
62623 HYBRID_BREAK();
62624 HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CV):
62625 VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CV)
62626 ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62627 VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_CV)
62628 HYBRID_BREAK();
62629 HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV):
62630 VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
62631 ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62632 VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_CV)
62633 HYBRID_BREAK();
62634 HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV):
62635 VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
62636 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62637 VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV)
62638 HYBRID_BREAK();
62639 HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_CV):
62640 VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_CV)
62641 ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62642 VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_CV)
62643 HYBRID_BREAK();
62644 HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_CV):
62645 VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_CV)
62646 ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62647 VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_CV)
62648 HYBRID_BREAK();
62649 HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_CV):
62650 VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_CV)
62651 ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62652 VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_CV)
62653 HYBRID_BREAK();
62654 HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV):
62655 VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
62656 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62657 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV)
62658 HYBRID_BREAK();
62659 HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV):
62660 VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
62661 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62662 VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
62663 HYBRID_BREAK();
62664 HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV):
62665 VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
62666 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62667 VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
62668 HYBRID_BREAK();
62669 HYBRID_CASE(ZEND_YIELD_SPEC_CV_CV):
62670 VM_TRACE(ZEND_YIELD_SPEC_CV_CV)
62671 ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62672 VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_CV)
62673 HYBRID_BREAK();
62674 HYBRID_CASE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV):
62675 VM_TRACE(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
62676 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62677 VM_TRACE_OP_END(ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV)
62678 HYBRID_BREAK();
62679 HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV):
62680 VM_TRACE(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
62681 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62682 VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV)
62683 HYBRID_BREAK();
62684 HYBRID_CASE(HYBRID_HALT):
62685 #ifdef ZEND_VM_FP_GLOBAL_REG
62686 execute_data = vm_stack_data.orig_execute_data;
62687 #endif
62688 #ifdef ZEND_VM_IP_GLOBAL_REG
62689 opline = vm_stack_data.orig_opline;
62690 #endif
62691 return;
62692 HYBRID_DEFAULT:
62693 VM_TRACE(ZEND_NULL)
62694 ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
62695 VM_TRACE_OP_END(ZEND_NULL)
62696 HYBRID_BREAK(); /* Never reached */
62697 #else
62698 #ifdef ZEND_VM_FP_GLOBAL_REG
62699 execute_data = vm_stack_data.orig_execute_data;
62700 # ifdef ZEND_VM_IP_GLOBAL_REG
62701 opline = vm_stack_data.orig_opline;
62702 # endif
62703 return;
62704 #else
62705 if (EXPECTED(ret > 0)) {
62706 execute_data = EG(current_execute_data);
62707 ZEND_VM_LOOP_INTERRUPT_CHECK();
62708 } else {
62709 # ifdef ZEND_VM_IP_GLOBAL_REG
62710 opline = vm_stack_data.orig_opline;
62711 # endif
62712 return;
62713 }
62714 #endif
62715 #endif
62716 }
62717
62718 }
62719 zend_error_noreturn(E_CORE_ERROR, "Arrived at end of main loop which shouldn't happen");
62720 }
62721 #if (ZEND_VM_KIND != ZEND_VM_KIND_CALL) && (ZEND_GCC_VERSION >= 4000) && !defined(__clang__)
62722 # pragma GCC pop_options
62723 #endif
62724
62725 ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value)
62726 {
62727 zend_execute_data *execute_data;
62728 void *object_or_called_scope;
62729 uint32_t call_info;
62730
62731 if (EG(exception) != NULL) {
62732 return;
62733 }
62734
62735 object_or_called_scope = zend_get_this_object(EG(current_execute_data));
62736 if (EXPECTED(!object_or_called_scope)) {
62737 object_or_called_scope = zend_get_called_scope(EG(current_execute_data));
62738 call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE;
62739 } else {
62740 call_info = ZEND_CALL_TOP_CODE | ZEND_CALL_HAS_SYMBOL_TABLE | ZEND_CALL_HAS_THIS;
62741 }
62742 execute_data = zend_vm_stack_push_call_frame(call_info,
62743 (zend_function*)op_array, 0, object_or_called_scope);
62744 if (EG(current_execute_data)) {
62745 execute_data->symbol_table = zend_rebuild_symbol_table();
62746 } else {
62747 execute_data->symbol_table = &EG(symbol_table);
62748 }
62749 EX(prev_execute_data) = EG(current_execute_data);
62750 i_init_code_execute_data(execute_data, op_array, return_value);
62751 ZEND_OBSERVER_FCALL_BEGIN(execute_data);
62752 zend_execute_ex(execute_data);
62753 /* Observer end handlers are called from ZEND_RETURN */
62754 zend_vm_stack_free_call_frame(execute_data);
62755 }
62756
62757
62758 void zend_vm_init(void)
62759 {
62760 static const void * const labels[] = {
62761 ZEND_NOP_SPEC_HANDLER,
62762 ZEND_ADD_SPEC_CONST_CONST_HANDLER,
62763 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
62764 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
62765 ZEND_NULL_HANDLER,
62766 ZEND_ADD_SPEC_CONST_TMPVARCV_HANDLER,
62767 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
62768 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62769 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62770 ZEND_NULL_HANDLER,
62771 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62772 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
62773 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62774 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62775 ZEND_NULL_HANDLER,
62776 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62777 ZEND_NULL_HANDLER,
62778 ZEND_NULL_HANDLER,
62779 ZEND_NULL_HANDLER,
62780 ZEND_NULL_HANDLER,
62781 ZEND_NULL_HANDLER,
62782 ZEND_ADD_SPEC_TMPVARCV_CONST_HANDLER,
62783 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62784 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62785 ZEND_NULL_HANDLER,
62786 ZEND_ADD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62787 ZEND_SUB_SPEC_CONST_CONST_HANDLER,
62788 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
62789 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
62790 ZEND_NULL_HANDLER,
62791 ZEND_SUB_SPEC_CONST_TMPVARCV_HANDLER,
62792 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
62793 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62794 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62795 ZEND_NULL_HANDLER,
62796 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62797 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
62798 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62799 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62800 ZEND_NULL_HANDLER,
62801 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62802 ZEND_NULL_HANDLER,
62803 ZEND_NULL_HANDLER,
62804 ZEND_NULL_HANDLER,
62805 ZEND_NULL_HANDLER,
62806 ZEND_NULL_HANDLER,
62807 ZEND_SUB_SPEC_TMPVARCV_CONST_HANDLER,
62808 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62809 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62810 ZEND_NULL_HANDLER,
62811 ZEND_SUB_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62812 ZEND_MUL_SPEC_CONST_CONST_HANDLER,
62813 ZEND_NULL_HANDLER,
62814 ZEND_NULL_HANDLER,
62815 ZEND_NULL_HANDLER,
62816 ZEND_NULL_HANDLER,
62817 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
62818 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62819 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62820 ZEND_NULL_HANDLER,
62821 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62822 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
62823 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62824 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62825 ZEND_NULL_HANDLER,
62826 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62827 ZEND_NULL_HANDLER,
62828 ZEND_NULL_HANDLER,
62829 ZEND_NULL_HANDLER,
62830 ZEND_NULL_HANDLER,
62831 ZEND_NULL_HANDLER,
62832 ZEND_MUL_SPEC_TMPVARCV_CONST_HANDLER,
62833 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62834 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62835 ZEND_NULL_HANDLER,
62836 ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62837 ZEND_DIV_SPEC_CONST_CONST_HANDLER,
62838 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
62839 ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER,
62840 ZEND_NULL_HANDLER,
62841 ZEND_DIV_SPEC_CONST_CV_HANDLER,
62842 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
62843 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
62844 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
62845 ZEND_NULL_HANDLER,
62846 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
62847 ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER,
62848 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
62849 ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER,
62850 ZEND_NULL_HANDLER,
62851 ZEND_DIV_SPEC_TMPVAR_CV_HANDLER,
62852 ZEND_NULL_HANDLER,
62853 ZEND_NULL_HANDLER,
62854 ZEND_NULL_HANDLER,
62855 ZEND_NULL_HANDLER,
62856 ZEND_NULL_HANDLER,
62857 ZEND_DIV_SPEC_CV_CONST_HANDLER,
62858 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
62859 ZEND_DIV_SPEC_CV_TMPVAR_HANDLER,
62860 ZEND_NULL_HANDLER,
62861 ZEND_DIV_SPEC_CV_CV_HANDLER,
62862 ZEND_MOD_SPEC_CONST_CONST_HANDLER,
62863 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
62864 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
62865 ZEND_NULL_HANDLER,
62866 ZEND_MOD_SPEC_CONST_TMPVARCV_HANDLER,
62867 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
62868 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62869 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62870 ZEND_NULL_HANDLER,
62871 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62872 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
62873 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62874 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62875 ZEND_NULL_HANDLER,
62876 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62877 ZEND_NULL_HANDLER,
62878 ZEND_NULL_HANDLER,
62879 ZEND_NULL_HANDLER,
62880 ZEND_NULL_HANDLER,
62881 ZEND_NULL_HANDLER,
62882 ZEND_MOD_SPEC_TMPVARCV_CONST_HANDLER,
62883 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62884 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62885 ZEND_NULL_HANDLER,
62886 ZEND_MOD_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62887 ZEND_SL_SPEC_CONST_CONST_HANDLER,
62888 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
62889 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
62890 ZEND_NULL_HANDLER,
62891 ZEND_SL_SPEC_CONST_TMPVARCV_HANDLER,
62892 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
62893 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62894 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62895 ZEND_NULL_HANDLER,
62896 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62897 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
62898 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62899 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62900 ZEND_NULL_HANDLER,
62901 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62902 ZEND_NULL_HANDLER,
62903 ZEND_NULL_HANDLER,
62904 ZEND_NULL_HANDLER,
62905 ZEND_NULL_HANDLER,
62906 ZEND_NULL_HANDLER,
62907 ZEND_SL_SPEC_TMPVARCV_CONST_HANDLER,
62908 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62909 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62910 ZEND_NULL_HANDLER,
62911 ZEND_SL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62912 ZEND_SR_SPEC_CONST_CONST_HANDLER,
62913 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
62914 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
62915 ZEND_NULL_HANDLER,
62916 ZEND_SR_SPEC_CONST_TMPVARCV_HANDLER,
62917 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
62918 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62919 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62920 ZEND_NULL_HANDLER,
62921 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62922 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
62923 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62924 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62925 ZEND_NULL_HANDLER,
62926 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62927 ZEND_NULL_HANDLER,
62928 ZEND_NULL_HANDLER,
62929 ZEND_NULL_HANDLER,
62930 ZEND_NULL_HANDLER,
62931 ZEND_NULL_HANDLER,
62932 ZEND_SR_SPEC_TMPVARCV_CONST_HANDLER,
62933 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62934 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62935 ZEND_NULL_HANDLER,
62936 ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62937 ZEND_NULL_HANDLER,
62938 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
62939 ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
62940 ZEND_NULL_HANDLER,
62941 ZEND_CONCAT_SPEC_CONST_CV_HANDLER,
62942 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
62943 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
62944 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
62945 ZEND_NULL_HANDLER,
62946 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
62947 ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
62948 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
62949 ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
62950 ZEND_NULL_HANDLER,
62951 ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER,
62952 ZEND_NULL_HANDLER,
62953 ZEND_NULL_HANDLER,
62954 ZEND_NULL_HANDLER,
62955 ZEND_NULL_HANDLER,
62956 ZEND_NULL_HANDLER,
62957 ZEND_CONCAT_SPEC_CV_CONST_HANDLER,
62958 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
62959 ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER,
62960 ZEND_NULL_HANDLER,
62961 ZEND_CONCAT_SPEC_CV_CV_HANDLER,
62962 ZEND_BW_OR_SPEC_CONST_CONST_HANDLER,
62963 ZEND_NULL_HANDLER,
62964 ZEND_NULL_HANDLER,
62965 ZEND_NULL_HANDLER,
62966 ZEND_NULL_HANDLER,
62967 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
62968 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62969 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62970 ZEND_NULL_HANDLER,
62971 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62972 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
62973 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62974 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62975 ZEND_NULL_HANDLER,
62976 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62977 ZEND_NULL_HANDLER,
62978 ZEND_NULL_HANDLER,
62979 ZEND_NULL_HANDLER,
62980 ZEND_NULL_HANDLER,
62981 ZEND_NULL_HANDLER,
62982 ZEND_BW_OR_SPEC_TMPVARCV_CONST_HANDLER,
62983 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62984 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62985 ZEND_NULL_HANDLER,
62986 ZEND_BW_OR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62987 ZEND_BW_AND_SPEC_CONST_CONST_HANDLER,
62988 ZEND_NULL_HANDLER,
62989 ZEND_NULL_HANDLER,
62990 ZEND_NULL_HANDLER,
62991 ZEND_NULL_HANDLER,
62992 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
62993 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62994 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62995 ZEND_NULL_HANDLER,
62996 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62997 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
62998 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
62999 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63000 ZEND_NULL_HANDLER,
63001 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63002 ZEND_NULL_HANDLER,
63003 ZEND_NULL_HANDLER,
63004 ZEND_NULL_HANDLER,
63005 ZEND_NULL_HANDLER,
63006 ZEND_NULL_HANDLER,
63007 ZEND_BW_AND_SPEC_TMPVARCV_CONST_HANDLER,
63008 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63009 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63010 ZEND_NULL_HANDLER,
63011 ZEND_BW_AND_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63012 ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER,
63013 ZEND_NULL_HANDLER,
63014 ZEND_NULL_HANDLER,
63015 ZEND_NULL_HANDLER,
63016 ZEND_NULL_HANDLER,
63017 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
63018 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63019 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63020 ZEND_NULL_HANDLER,
63021 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63022 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
63023 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63024 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63025 ZEND_NULL_HANDLER,
63026 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63027 ZEND_NULL_HANDLER,
63028 ZEND_NULL_HANDLER,
63029 ZEND_NULL_HANDLER,
63030 ZEND_NULL_HANDLER,
63031 ZEND_NULL_HANDLER,
63032 ZEND_BW_XOR_SPEC_TMPVARCV_CONST_HANDLER,
63033 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63034 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63035 ZEND_NULL_HANDLER,
63036 ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63037 ZEND_POW_SPEC_CONST_CONST_HANDLER,
63038 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
63039 ZEND_POW_SPEC_CONST_TMPVAR_HANDLER,
63040 ZEND_NULL_HANDLER,
63041 ZEND_POW_SPEC_CONST_CV_HANDLER,
63042 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
63043 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
63044 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
63045 ZEND_NULL_HANDLER,
63046 ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
63047 ZEND_POW_SPEC_TMPVAR_CONST_HANDLER,
63048 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
63049 ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER,
63050 ZEND_NULL_HANDLER,
63051 ZEND_POW_SPEC_TMPVAR_CV_HANDLER,
63052 ZEND_NULL_HANDLER,
63053 ZEND_NULL_HANDLER,
63054 ZEND_NULL_HANDLER,
63055 ZEND_NULL_HANDLER,
63056 ZEND_NULL_HANDLER,
63057 ZEND_POW_SPEC_CV_CONST_HANDLER,
63058 ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
63059 ZEND_POW_SPEC_CV_TMPVAR_HANDLER,
63060 ZEND_NULL_HANDLER,
63061 ZEND_POW_SPEC_CV_CV_HANDLER,
63062 ZEND_BW_NOT_SPEC_CONST_HANDLER,
63063 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
63064 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
63065 ZEND_NULL_HANDLER,
63066 ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER,
63067 ZEND_BOOL_NOT_SPEC_CONST_HANDLER,
63068 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
63069 ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER,
63070 ZEND_NULL_HANDLER,
63071 ZEND_BOOL_NOT_SPEC_CV_HANDLER,
63072 ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER,
63073 ZEND_NULL_HANDLER,
63074 ZEND_NULL_HANDLER,
63075 ZEND_NULL_HANDLER,
63076 ZEND_NULL_HANDLER,
63077 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
63078 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
63079 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
63080 ZEND_NULL_HANDLER,
63081 ZEND_NULL_HANDLER,
63082 ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER,
63083 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
63084 ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER,
63085 ZEND_NULL_HANDLER,
63086 ZEND_NULL_HANDLER,
63087 ZEND_NULL_HANDLER,
63088 ZEND_NULL_HANDLER,
63089 ZEND_NULL_HANDLER,
63090 ZEND_NULL_HANDLER,
63091 ZEND_NULL_HANDLER,
63092 ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER,
63093 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
63094 ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER,
63095 ZEND_NULL_HANDLER,
63096 ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER,
63097 ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER,
63098 ZEND_NULL_HANDLER,
63099 ZEND_NULL_HANDLER,
63100 ZEND_NULL_HANDLER,
63101 ZEND_NULL_HANDLER,
63102 ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER,
63103 ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER,
63104 ZEND_NULL_HANDLER,
63105 ZEND_NULL_HANDLER,
63106 ZEND_NULL_HANDLER,
63107 ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER,
63108 ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER,
63109 ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER,
63110 ZEND_NULL_HANDLER,
63111 ZEND_NULL_HANDLER,
63112 ZEND_NULL_HANDLER,
63113 ZEND_NULL_HANDLER,
63114 ZEND_NULL_HANDLER,
63115 ZEND_NULL_HANDLER,
63116 ZEND_NULL_HANDLER,
63117 ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER,
63118 ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER,
63119 ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER,
63120 ZEND_NULL_HANDLER,
63121 ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER,
63122 ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER,
63123 ZEND_NULL_HANDLER,
63124 ZEND_NULL_HANDLER,
63125 ZEND_NULL_HANDLER,
63126 ZEND_NULL_HANDLER,
63127 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER,
63128 ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER,
63129 ZEND_NULL_HANDLER,
63130 ZEND_NULL_HANDLER,
63131 ZEND_NULL_HANDLER,
63132 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER,
63133 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER,
63134 ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER,
63135 ZEND_NULL_HANDLER,
63136 ZEND_NULL_HANDLER,
63137 ZEND_NULL_HANDLER,
63138 ZEND_NULL_HANDLER,
63139 ZEND_NULL_HANDLER,
63140 ZEND_NULL_HANDLER,
63141 ZEND_NULL_HANDLER,
63142 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER,
63143 ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER,
63144 ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER,
63145 ZEND_NULL_HANDLER,
63146 ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER,
63147 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
63148 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
63149 ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER,
63150 ZEND_NULL_HANDLER,
63151 ZEND_NULL_HANDLER,
63152 ZEND_NULL_HANDLER,
63153 ZEND_NULL_HANDLER,
63154 ZEND_NULL_HANDLER,
63155 ZEND_NULL_HANDLER,
63156 ZEND_NULL_HANDLER,
63157 ZEND_NULL_HANDLER,
63158 ZEND_NULL_HANDLER,
63159 ZEND_NULL_HANDLER,
63160 ZEND_NULL_HANDLER,
63161 ZEND_NULL_HANDLER,
63162 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
63163 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
63164 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
63165 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63166 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63167 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63168 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63169 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63170 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63171 ZEND_NULL_HANDLER,
63172 ZEND_NULL_HANDLER,
63173 ZEND_NULL_HANDLER,
63174 ZEND_NULL_HANDLER,
63175 ZEND_NULL_HANDLER,
63176 ZEND_NULL_HANDLER,
63177 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
63178 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
63179 ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
63180 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63181 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63182 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63183 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63184 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63185 ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63186 ZEND_NULL_HANDLER,
63187 ZEND_NULL_HANDLER,
63188 ZEND_NULL_HANDLER,
63189 ZEND_NULL_HANDLER,
63190 ZEND_NULL_HANDLER,
63191 ZEND_NULL_HANDLER,
63192 ZEND_NULL_HANDLER,
63193 ZEND_NULL_HANDLER,
63194 ZEND_NULL_HANDLER,
63195 ZEND_NULL_HANDLER,
63196 ZEND_NULL_HANDLER,
63197 ZEND_NULL_HANDLER,
63198 ZEND_NULL_HANDLER,
63199 ZEND_NULL_HANDLER,
63200 ZEND_NULL_HANDLER,
63201 ZEND_NULL_HANDLER,
63202 ZEND_NULL_HANDLER,
63203 ZEND_NULL_HANDLER,
63204 ZEND_NULL_HANDLER,
63205 ZEND_NULL_HANDLER,
63206 ZEND_NULL_HANDLER,
63207 ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER,
63208 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
63209 ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
63210 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
63211 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
63212 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
63213 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER,
63214 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
63215 ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
63216 ZEND_NULL_HANDLER,
63217 ZEND_NULL_HANDLER,
63218 ZEND_NULL_HANDLER,
63219 ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER,
63220 ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
63221 ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
63222 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
63223 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
63224 ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER,
63225 ZEND_NULL_HANDLER,
63226 ZEND_NULL_HANDLER,
63227 ZEND_NULL_HANDLER,
63228 ZEND_NULL_HANDLER,
63229 ZEND_NULL_HANDLER,
63230 ZEND_NULL_HANDLER,
63231 ZEND_NULL_HANDLER,
63232 ZEND_NULL_HANDLER,
63233 ZEND_NULL_HANDLER,
63234 ZEND_NULL_HANDLER,
63235 ZEND_NULL_HANDLER,
63236 ZEND_NULL_HANDLER,
63237 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
63238 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
63239 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
63240 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63241 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63242 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63243 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63244 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63245 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63246 ZEND_NULL_HANDLER,
63247 ZEND_NULL_HANDLER,
63248 ZEND_NULL_HANDLER,
63249 ZEND_NULL_HANDLER,
63250 ZEND_NULL_HANDLER,
63251 ZEND_NULL_HANDLER,
63252 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER,
63253 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER,
63254 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER,
63255 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63256 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63257 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63258 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER,
63259 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER,
63260 ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER,
63261 ZEND_NULL_HANDLER,
63262 ZEND_NULL_HANDLER,
63263 ZEND_NULL_HANDLER,
63264 ZEND_NULL_HANDLER,
63265 ZEND_NULL_HANDLER,
63266 ZEND_NULL_HANDLER,
63267 ZEND_NULL_HANDLER,
63268 ZEND_NULL_HANDLER,
63269 ZEND_NULL_HANDLER,
63270 ZEND_NULL_HANDLER,
63271 ZEND_NULL_HANDLER,
63272 ZEND_NULL_HANDLER,
63273 ZEND_NULL_HANDLER,
63274 ZEND_NULL_HANDLER,
63275 ZEND_NULL_HANDLER,
63276 ZEND_NULL_HANDLER,
63277 ZEND_NULL_HANDLER,
63278 ZEND_NULL_HANDLER,
63279 ZEND_NULL_HANDLER,
63280 ZEND_NULL_HANDLER,
63281 ZEND_NULL_HANDLER,
63282 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER,
63283 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER,
63284 ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER,
63285 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
63286 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
63287 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
63288 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER,
63289 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER,
63290 ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER,
63291 ZEND_NULL_HANDLER,
63292 ZEND_NULL_HANDLER,
63293 ZEND_NULL_HANDLER,
63294 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER,
63295 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPZ_HANDLER,
63296 ZEND_IS_NOT_EQUAL_SPEC_CV_CV_JMPNZ_HANDLER,
63297 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
63298 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
63299 ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER,
63300 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
63301 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63302 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63303 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
63304 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63305 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63306 ZEND_NULL_HANDLER,
63307 ZEND_NULL_HANDLER,
63308 ZEND_NULL_HANDLER,
63309 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_HANDLER,
63310 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63311 ZEND_IS_SMALLER_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63312 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
63313 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63314 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
63315 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63316 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63317 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63318 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63319 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63320 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63321 ZEND_NULL_HANDLER,
63322 ZEND_NULL_HANDLER,
63323 ZEND_NULL_HANDLER,
63324 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63325 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63326 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63327 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
63328 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63329 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
63330 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63331 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63332 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63333 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63334 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63335 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63336 ZEND_NULL_HANDLER,
63337 ZEND_NULL_HANDLER,
63338 ZEND_NULL_HANDLER,
63339 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63340 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63341 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63342 ZEND_NULL_HANDLER,
63343 ZEND_NULL_HANDLER,
63344 ZEND_NULL_HANDLER,
63345 ZEND_NULL_HANDLER,
63346 ZEND_NULL_HANDLER,
63347 ZEND_NULL_HANDLER,
63348 ZEND_NULL_HANDLER,
63349 ZEND_NULL_HANDLER,
63350 ZEND_NULL_HANDLER,
63351 ZEND_NULL_HANDLER,
63352 ZEND_NULL_HANDLER,
63353 ZEND_NULL_HANDLER,
63354 ZEND_NULL_HANDLER,
63355 ZEND_NULL_HANDLER,
63356 ZEND_NULL_HANDLER,
63357 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_HANDLER,
63358 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63359 ZEND_IS_SMALLER_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
63360 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63361 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63362 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63363 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63364 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63365 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63366 ZEND_NULL_HANDLER,
63367 ZEND_NULL_HANDLER,
63368 ZEND_NULL_HANDLER,
63369 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63370 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63371 ZEND_IS_SMALLER_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63372 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
63373 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
63374 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER,
63375 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
63376 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63377 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63378 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
63379 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63380 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63381 ZEND_NULL_HANDLER,
63382 ZEND_NULL_HANDLER,
63383 ZEND_NULL_HANDLER,
63384 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_HANDLER,
63385 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
63386 ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
63387 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
63388 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63389 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
63390 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63391 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63392 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63393 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63394 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63395 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63396 ZEND_NULL_HANDLER,
63397 ZEND_NULL_HANDLER,
63398 ZEND_NULL_HANDLER,
63399 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63400 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63401 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63402 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
63403 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63404 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
63405 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63406 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63407 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63408 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63409 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63410 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63411 ZEND_NULL_HANDLER,
63412 ZEND_NULL_HANDLER,
63413 ZEND_NULL_HANDLER,
63414 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63415 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63416 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63417 ZEND_NULL_HANDLER,
63418 ZEND_NULL_HANDLER,
63419 ZEND_NULL_HANDLER,
63420 ZEND_NULL_HANDLER,
63421 ZEND_NULL_HANDLER,
63422 ZEND_NULL_HANDLER,
63423 ZEND_NULL_HANDLER,
63424 ZEND_NULL_HANDLER,
63425 ZEND_NULL_HANDLER,
63426 ZEND_NULL_HANDLER,
63427 ZEND_NULL_HANDLER,
63428 ZEND_NULL_HANDLER,
63429 ZEND_NULL_HANDLER,
63430 ZEND_NULL_HANDLER,
63431 ZEND_NULL_HANDLER,
63432 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_HANDLER,
63433 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
63434 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
63435 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63436 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63437 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63438 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63439 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63440 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63441 ZEND_NULL_HANDLER,
63442 ZEND_NULL_HANDLER,
63443 ZEND_NULL_HANDLER,
63444 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_HANDLER,
63445 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
63446 ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
63447 ZEND_NULL_HANDLER,
63448 ZEND_NULL_HANDLER,
63449 ZEND_NULL_HANDLER,
63450 ZEND_NULL_HANDLER,
63451 ZEND_NULL_HANDLER,
63452 ZEND_NULL_HANDLER,
63453 ZEND_NULL_HANDLER,
63454 ZEND_NULL_HANDLER,
63455 ZEND_NULL_HANDLER,
63456 ZEND_NULL_HANDLER,
63457 ZEND_NULL_HANDLER,
63458 ZEND_NULL_HANDLER,
63459 ZEND_NULL_HANDLER,
63460 ZEND_NULL_HANDLER,
63461 ZEND_NULL_HANDLER,
63462 ZEND_NULL_HANDLER,
63463 ZEND_NULL_HANDLER,
63464 ZEND_NULL_HANDLER,
63465 ZEND_NULL_HANDLER,
63466 ZEND_NULL_HANDLER,
63467 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED_HANDLER,
63468 ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER,
63469 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER,
63470 ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER,
63471 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER,
63472 ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER,
63473 ZEND_NULL_HANDLER,
63474 ZEND_NULL_HANDLER,
63475 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
63476 ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED_HANDLER,
63477 ZEND_NULL_HANDLER,
63478 ZEND_NULL_HANDLER,
63479 ZEND_NULL_HANDLER,
63480 ZEND_NULL_HANDLER,
63481 ZEND_NULL_HANDLER,
63482 ZEND_NULL_HANDLER,
63483 ZEND_NULL_HANDLER,
63484 ZEND_NULL_HANDLER,
63485 ZEND_NULL_HANDLER,
63486 ZEND_NULL_HANDLER,
63487 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED_HANDLER,
63488 ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER,
63489 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER,
63490 ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER,
63491 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER,
63492 ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER,
63493 ZEND_NULL_HANDLER,
63494 ZEND_NULL_HANDLER,
63495 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER,
63496 ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_HANDLER,
63497 ZEND_NULL_HANDLER,
63498 ZEND_NULL_HANDLER,
63499 ZEND_NULL_HANDLER,
63500 ZEND_NULL_HANDLER,
63501 ZEND_NULL_HANDLER,
63502 ZEND_NULL_HANDLER,
63503 ZEND_NULL_HANDLER,
63504 ZEND_NULL_HANDLER,
63505 ZEND_NULL_HANDLER,
63506 ZEND_NULL_HANDLER,
63507 ZEND_NULL_HANDLER,
63508 ZEND_NULL_HANDLER,
63509 ZEND_NULL_HANDLER,
63510 ZEND_NULL_HANDLER,
63511 ZEND_NULL_HANDLER,
63512 ZEND_NULL_HANDLER,
63513 ZEND_NULL_HANDLER,
63514 ZEND_NULL_HANDLER,
63515 ZEND_NULL_HANDLER,
63516 ZEND_NULL_HANDLER,
63517 ZEND_NULL_HANDLER,
63518 ZEND_NULL_HANDLER,
63519 ZEND_NULL_HANDLER,
63520 ZEND_NULL_HANDLER,
63521 ZEND_NULL_HANDLER,
63522 ZEND_NULL_HANDLER,
63523 ZEND_NULL_HANDLER,
63524 ZEND_NULL_HANDLER,
63525 ZEND_NULL_HANDLER,
63526 ZEND_NULL_HANDLER,
63527 ZEND_NULL_HANDLER,
63528 ZEND_NULL_HANDLER,
63529 ZEND_NULL_HANDLER,
63530 ZEND_NULL_HANDLER,
63531 ZEND_NULL_HANDLER,
63532 ZEND_NULL_HANDLER,
63533 ZEND_NULL_HANDLER,
63534 ZEND_NULL_HANDLER,
63535 ZEND_NULL_HANDLER,
63536 ZEND_NULL_HANDLER,
63537 ZEND_NULL_HANDLER,
63538 ZEND_NULL_HANDLER,
63539 ZEND_NULL_HANDLER,
63540 ZEND_NULL_HANDLER,
63541 ZEND_NULL_HANDLER,
63542 ZEND_NULL_HANDLER,
63543 ZEND_NULL_HANDLER,
63544 ZEND_NULL_HANDLER,
63545 ZEND_NULL_HANDLER,
63546 ZEND_NULL_HANDLER,
63547 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
63548 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
63549 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
63550 ZEND_NULL_HANDLER,
63551 ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
63552 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
63553 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
63554 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63555 ZEND_NULL_HANDLER,
63556 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63557 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
63558 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
63559 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63560 ZEND_NULL_HANDLER,
63561 ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63562 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER,
63563 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER,
63564 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER,
63565 ZEND_NULL_HANDLER,
63566 ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER,
63567 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
63568 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
63569 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
63570 ZEND_NULL_HANDLER,
63571 ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
63572 ZEND_NULL_HANDLER,
63573 ZEND_NULL_HANDLER,
63574 ZEND_NULL_HANDLER,
63575 ZEND_NULL_HANDLER,
63576 ZEND_NULL_HANDLER,
63577 ZEND_NULL_HANDLER,
63578 ZEND_NULL_HANDLER,
63579 ZEND_NULL_HANDLER,
63580 ZEND_NULL_HANDLER,
63581 ZEND_NULL_HANDLER,
63582 ZEND_NULL_HANDLER,
63583 ZEND_NULL_HANDLER,
63584 ZEND_NULL_HANDLER,
63585 ZEND_NULL_HANDLER,
63586 ZEND_NULL_HANDLER,
63587 ZEND_NULL_HANDLER,
63588 ZEND_NULL_HANDLER,
63589 ZEND_NULL_HANDLER,
63590 ZEND_NULL_HANDLER,
63591 ZEND_NULL_HANDLER,
63592 ZEND_NULL_HANDLER,
63593 ZEND_NULL_HANDLER,
63594 ZEND_NULL_HANDLER,
63595 ZEND_NULL_HANDLER,
63596 ZEND_NULL_HANDLER,
63597 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
63598 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
63599 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
63600 ZEND_NULL_HANDLER,
63601 ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
63602 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
63603 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
63604 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63605 ZEND_NULL_HANDLER,
63606 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63607 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
63608 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
63609 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63610 ZEND_NULL_HANDLER,
63611 ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63612 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER,
63613 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER,
63614 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER,
63615 ZEND_NULL_HANDLER,
63616 ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER,
63617 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
63618 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
63619 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
63620 ZEND_NULL_HANDLER,
63621 ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER,
63622 ZEND_NULL_HANDLER,
63623 ZEND_NULL_HANDLER,
63624 ZEND_NULL_HANDLER,
63625 ZEND_NULL_HANDLER,
63626 ZEND_NULL_HANDLER,
63627 ZEND_NULL_HANDLER,
63628 ZEND_NULL_HANDLER,
63629 ZEND_NULL_HANDLER,
63630 ZEND_NULL_HANDLER,
63631 ZEND_NULL_HANDLER,
63632 ZEND_NULL_HANDLER,
63633 ZEND_NULL_HANDLER,
63634 ZEND_NULL_HANDLER,
63635 ZEND_NULL_HANDLER,
63636 ZEND_NULL_HANDLER,
63637 ZEND_NULL_HANDLER,
63638 ZEND_NULL_HANDLER,
63639 ZEND_NULL_HANDLER,
63640 ZEND_NULL_HANDLER,
63641 ZEND_NULL_HANDLER,
63642 ZEND_NULL_HANDLER,
63643 ZEND_NULL_HANDLER,
63644 ZEND_NULL_HANDLER,
63645 ZEND_NULL_HANDLER,
63646 ZEND_NULL_HANDLER,
63647 ZEND_NULL_HANDLER,
63648 ZEND_NULL_HANDLER,
63649 ZEND_NULL_HANDLER,
63650 ZEND_NULL_HANDLER,
63651 ZEND_NULL_HANDLER,
63652 ZEND_NULL_HANDLER,
63653 ZEND_NULL_HANDLER,
63654 ZEND_NULL_HANDLER,
63655 ZEND_NULL_HANDLER,
63656 ZEND_NULL_HANDLER,
63657 ZEND_NULL_HANDLER,
63658 ZEND_NULL_HANDLER,
63659 ZEND_NULL_HANDLER,
63660 ZEND_NULL_HANDLER,
63661 ZEND_NULL_HANDLER,
63662 ZEND_NULL_HANDLER,
63663 ZEND_NULL_HANDLER,
63664 ZEND_NULL_HANDLER,
63665 ZEND_NULL_HANDLER,
63666 ZEND_NULL_HANDLER,
63667 ZEND_NULL_HANDLER,
63668 ZEND_NULL_HANDLER,
63669 ZEND_NULL_HANDLER,
63670 ZEND_NULL_HANDLER,
63671 ZEND_NULL_HANDLER,
63672 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER,
63673 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER,
63674 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
63675 ZEND_NULL_HANDLER,
63676 ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
63677 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
63678 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
63679 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63680 ZEND_NULL_HANDLER,
63681 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63682 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER,
63683 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER,
63684 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63685 ZEND_NULL_HANDLER,
63686 ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63687 ZEND_NULL_HANDLER,
63688 ZEND_NULL_HANDLER,
63689 ZEND_NULL_HANDLER,
63690 ZEND_NULL_HANDLER,
63691 ZEND_NULL_HANDLER,
63692 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER,
63693 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER,
63694 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
63695 ZEND_NULL_HANDLER,
63696 ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
63697 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER,
63698 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER,
63699 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
63700 ZEND_NULL_HANDLER,
63701 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
63702 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
63703 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
63704 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
63705 ZEND_NULL_HANDLER,
63706 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
63707 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER,
63708 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER,
63709 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
63710 ZEND_NULL_HANDLER,
63711 ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
63712 ZEND_NULL_HANDLER,
63713 ZEND_NULL_HANDLER,
63714 ZEND_NULL_HANDLER,
63715 ZEND_NULL_HANDLER,
63716 ZEND_NULL_HANDLER,
63717 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER,
63718 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER,
63719 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
63720 ZEND_NULL_HANDLER,
63721 ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
63722 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
63723 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
63724 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
63725 ZEND_NULL_HANDLER,
63726 ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
63727 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
63728 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
63729 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63730 ZEND_NULL_HANDLER,
63731 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63732 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER,
63733 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER,
63734 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63735 ZEND_NULL_HANDLER,
63736 ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63737 ZEND_NULL_HANDLER,
63738 ZEND_NULL_HANDLER,
63739 ZEND_NULL_HANDLER,
63740 ZEND_NULL_HANDLER,
63741 ZEND_NULL_HANDLER,
63742 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER,
63743 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER,
63744 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
63745 ZEND_NULL_HANDLER,
63746 ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER,
63747 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER,
63748 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER,
63749 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER,
63750 ZEND_NULL_HANDLER,
63751 ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER,
63752 ZEND_NULL_HANDLER,
63753 ZEND_NULL_HANDLER,
63754 ZEND_NULL_HANDLER,
63755 ZEND_NULL_HANDLER,
63756 ZEND_NULL_HANDLER,
63757 ZEND_NULL_HANDLER,
63758 ZEND_NULL_HANDLER,
63759 ZEND_NULL_HANDLER,
63760 ZEND_NULL_HANDLER,
63761 ZEND_NULL_HANDLER,
63762 ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER,
63763 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
63764 ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER,
63765 ZEND_NULL_HANDLER,
63766 ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER,
63767 ZEND_NULL_HANDLER,
63768 ZEND_NULL_HANDLER,
63769 ZEND_NULL_HANDLER,
63770 ZEND_NULL_HANDLER,
63771 ZEND_NULL_HANDLER,
63772 ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER,
63773 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
63774 ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER,
63775 ZEND_NULL_HANDLER,
63776 ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER,
63777 ZEND_NULL_HANDLER,
63778 ZEND_NULL_HANDLER,
63779 ZEND_NULL_HANDLER,
63780 ZEND_NULL_HANDLER,
63781 ZEND_NULL_HANDLER,
63782 ZEND_NULL_HANDLER,
63783 ZEND_NULL_HANDLER,
63784 ZEND_NULL_HANDLER,
63785 ZEND_NULL_HANDLER,
63786 ZEND_NULL_HANDLER,
63787 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER,
63788 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
63789 ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER,
63790 ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER,
63791 ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER,
63792 ZEND_NULL_HANDLER,
63793 ZEND_NULL_HANDLER,
63794 ZEND_NULL_HANDLER,
63795 ZEND_NULL_HANDLER,
63796 ZEND_NULL_HANDLER,
63797 ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER,
63798 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
63799 ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER,
63800 ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER,
63801 ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER,
63802 ZEND_NULL_HANDLER,
63803 ZEND_NULL_HANDLER,
63804 ZEND_NULL_HANDLER,
63805 ZEND_NULL_HANDLER,
63806 ZEND_NULL_HANDLER,
63807 ZEND_NULL_HANDLER,
63808 ZEND_NULL_HANDLER,
63809 ZEND_NULL_HANDLER,
63810 ZEND_NULL_HANDLER,
63811 ZEND_NULL_HANDLER,
63812 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER,
63813 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
63814 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER,
63815 ZEND_NULL_HANDLER,
63816 ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER,
63817 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER,
63818 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
63819 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER,
63820 ZEND_NULL_HANDLER,
63821 ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER,
63822 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER,
63823 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
63824 ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER,
63825 ZEND_NULL_HANDLER,
63826 ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER,
63827 ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER,
63828 ZEND_NULL_HANDLER,
63829 ZEND_NULL_HANDLER,
63830 ZEND_NULL_HANDLER,
63831 ZEND_NULL_HANDLER,
63832 ZEND_NULL_HANDLER,
63833 ZEND_NULL_HANDLER,
63834 ZEND_NULL_HANDLER,
63835 ZEND_NULL_HANDLER,
63836 ZEND_NULL_HANDLER,
63837 ZEND_NULL_HANDLER,
63838 ZEND_NULL_HANDLER,
63839 ZEND_NULL_HANDLER,
63840 ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER,
63841 ZEND_NULL_HANDLER,
63842 ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER,
63843 ZEND_NULL_HANDLER,
63844 ZEND_NULL_HANDLER,
63845 ZEND_NULL_HANDLER,
63846 ZEND_NULL_HANDLER,
63847 ZEND_NULL_HANDLER,
63848 ZEND_NULL_HANDLER,
63849 ZEND_NULL_HANDLER,
63850 ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER,
63851 ZEND_NULL_HANDLER,
63852 ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER,
63853 ZEND_QM_ASSIGN_SPEC_CONST_HANDLER,
63854 ZEND_QM_ASSIGN_SPEC_TMP_HANDLER,
63855 ZEND_QM_ASSIGN_SPEC_VAR_HANDLER,
63856 ZEND_NULL_HANDLER,
63857 ZEND_QM_ASSIGN_SPEC_CV_HANDLER,
63858 ZEND_NULL_HANDLER,
63859 ZEND_NULL_HANDLER,
63860 ZEND_NULL_HANDLER,
63861 ZEND_NULL_HANDLER,
63862 ZEND_NULL_HANDLER,
63863 ZEND_NULL_HANDLER,
63864 ZEND_NULL_HANDLER,
63865 ZEND_NULL_HANDLER,
63866 ZEND_NULL_HANDLER,
63867 ZEND_NULL_HANDLER,
63868 ZEND_NULL_HANDLER,
63869 ZEND_NULL_HANDLER,
63870 ZEND_NULL_HANDLER,
63871 ZEND_NULL_HANDLER,
63872 ZEND_NULL_HANDLER,
63873 ZEND_NULL_HANDLER,
63874 ZEND_NULL_HANDLER,
63875 ZEND_NULL_HANDLER,
63876 ZEND_NULL_HANDLER,
63877 ZEND_NULL_HANDLER,
63878 ZEND_NULL_HANDLER,
63879 ZEND_NULL_HANDLER,
63880 ZEND_NULL_HANDLER,
63881 ZEND_NULL_HANDLER,
63882 ZEND_NULL_HANDLER,
63883 ZEND_NULL_HANDLER,
63884 ZEND_NULL_HANDLER,
63885 ZEND_NULL_HANDLER,
63886 ZEND_NULL_HANDLER,
63887 ZEND_NULL_HANDLER,
63888 ZEND_NULL_HANDLER,
63889 ZEND_NULL_HANDLER,
63890 ZEND_NULL_HANDLER,
63891 ZEND_NULL_HANDLER,
63892 ZEND_NULL_HANDLER,
63893 ZEND_NULL_HANDLER,
63894 ZEND_NULL_HANDLER,
63895 ZEND_NULL_HANDLER,
63896 ZEND_NULL_HANDLER,
63897 ZEND_NULL_HANDLER,
63898 ZEND_NULL_HANDLER,
63899 ZEND_NULL_HANDLER,
63900 ZEND_NULL_HANDLER,
63901 ZEND_NULL_HANDLER,
63902 ZEND_NULL_HANDLER,
63903 ZEND_NULL_HANDLER,
63904 ZEND_NULL_HANDLER,
63905 ZEND_NULL_HANDLER,
63906 ZEND_NULL_HANDLER,
63907 ZEND_NULL_HANDLER,
63908 ZEND_NULL_HANDLER,
63909 ZEND_NULL_HANDLER,
63910 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
63911 ZEND_NULL_HANDLER,
63912 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
63913 ZEND_NULL_HANDLER,
63914 ZEND_NULL_HANDLER,
63915 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63916 ZEND_NULL_HANDLER,
63917 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63918 ZEND_NULL_HANDLER,
63919 ZEND_NULL_HANDLER,
63920 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
63921 ZEND_NULL_HANDLER,
63922 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
63923 ZEND_NULL_HANDLER,
63924 ZEND_NULL_HANDLER,
63925 ZEND_NULL_HANDLER,
63926 ZEND_NULL_HANDLER,
63927 ZEND_NULL_HANDLER,
63928 ZEND_NULL_HANDLER,
63929 ZEND_NULL_HANDLER,
63930 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
63931 ZEND_NULL_HANDLER,
63932 ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
63933 ZEND_NULL_HANDLER,
63934 ZEND_NULL_HANDLER,
63935 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
63936 ZEND_NULL_HANDLER,
63937 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
63938 ZEND_NULL_HANDLER,
63939 ZEND_NULL_HANDLER,
63940 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
63941 ZEND_NULL_HANDLER,
63942 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
63943 ZEND_NULL_HANDLER,
63944 ZEND_NULL_HANDLER,
63945 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
63946 ZEND_NULL_HANDLER,
63947 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
63948 ZEND_NULL_HANDLER,
63949 ZEND_NULL_HANDLER,
63950 ZEND_NULL_HANDLER,
63951 ZEND_NULL_HANDLER,
63952 ZEND_NULL_HANDLER,
63953 ZEND_NULL_HANDLER,
63954 ZEND_NULL_HANDLER,
63955 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
63956 ZEND_NULL_HANDLER,
63957 ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
63958 ZEND_NULL_HANDLER,
63959 ZEND_NULL_HANDLER,
63960 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
63961 ZEND_NULL_HANDLER,
63962 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
63963 ZEND_NULL_HANDLER,
63964 ZEND_NULL_HANDLER,
63965 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63966 ZEND_NULL_HANDLER,
63967 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63968 ZEND_NULL_HANDLER,
63969 ZEND_NULL_HANDLER,
63970 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
63971 ZEND_NULL_HANDLER,
63972 ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
63973 ZEND_NULL_HANDLER,
63974 ZEND_NULL_HANDLER,
63975 ZEND_NULL_HANDLER,
63976 ZEND_NULL_HANDLER,
63977 ZEND_NULL_HANDLER,
63978 ZEND_NULL_HANDLER,
63979 ZEND_NULL_HANDLER,
63980 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
63981 ZEND_NULL_HANDLER,
63982 ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER,
63983 ZEND_ASSIGN_STATIC_PROP_REF_SPEC_HANDLER,
63984 ZEND_NULL_HANDLER,
63985 ZEND_NULL_HANDLER,
63986 ZEND_NULL_HANDLER,
63987 ZEND_NULL_HANDLER,
63988 ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
63989 ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER,
63990 ZEND_NULL_HANDLER,
63991 ZEND_NULL_HANDLER,
63992 ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_HANDLER,
63993 ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HANDLER,
63994 ZEND_NULL_HANDLER,
63995 ZEND_NULL_HANDLER,
63996 ZEND_NULL_HANDLER,
63997 ZEND_NULL_HANDLER,
63998 ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
63999 ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_HANDLER,
64000 ZEND_NULL_HANDLER,
64001 ZEND_NULL_HANDLER,
64002 ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_HANDLER,
64003 ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HANDLER,
64004 ZEND_NULL_HANDLER,
64005 ZEND_NULL_HANDLER,
64006 ZEND_POST_INC_SPEC_VAR_HANDLER,
64007 ZEND_NULL_HANDLER,
64008 ZEND_POST_INC_SPEC_CV_HANDLER,
64009 ZEND_NULL_HANDLER,
64010 ZEND_NULL_HANDLER,
64011 ZEND_POST_DEC_SPEC_VAR_HANDLER,
64012 ZEND_NULL_HANDLER,
64013 ZEND_POST_DEC_SPEC_CV_HANDLER,
64014 ZEND_PRE_INC_STATIC_PROP_SPEC_HANDLER,
64015 ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER,
64016 ZEND_JMP_SPEC_HANDLER,
64017 ZEND_JMPZ_SPEC_CONST_HANDLER,
64018 ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
64019 ZEND_JMPZ_SPEC_TMPVAR_HANDLER,
64020 ZEND_NULL_HANDLER,
64021 ZEND_JMPZ_SPEC_CV_HANDLER,
64022 ZEND_JMPNZ_SPEC_CONST_HANDLER,
64023 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
64024 ZEND_JMPNZ_SPEC_TMPVAR_HANDLER,
64025 ZEND_NULL_HANDLER,
64026 ZEND_JMPNZ_SPEC_CV_HANDLER,
64027 ZEND_JMPZ_EX_SPEC_CONST_HANDLER,
64028 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
64029 ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER,
64030 ZEND_NULL_HANDLER,
64031 ZEND_JMPZ_EX_SPEC_CV_HANDLER,
64032 ZEND_JMPNZ_EX_SPEC_CONST_HANDLER,
64033 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
64034 ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER,
64035 ZEND_NULL_HANDLER,
64036 ZEND_JMPNZ_EX_SPEC_CV_HANDLER,
64037 ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER,
64038 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
64039 ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER,
64040 ZEND_NULL_HANDLER,
64041 ZEND_CASE_SPEC_TMPVAR_CV_HANDLER,
64042 ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER,
64043 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
64044 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER,
64045 ZEND_NULL_HANDLER,
64046 ZEND_NULL_HANDLER,
64047 ZEND_NULL_HANDLER,
64048 ZEND_NULL_HANDLER,
64049 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_HANDLER,
64050 ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_UNUSED_QUICK_HANDLER,
64051 ZEND_NULL_HANDLER,
64052 ZEND_NULL_HANDLER,
64053 ZEND_CAST_SPEC_CONST_HANDLER,
64054 ZEND_CAST_SPEC_TMP_HANDLER,
64055 ZEND_CAST_SPEC_VAR_HANDLER,
64056 ZEND_NULL_HANDLER,
64057 ZEND_CAST_SPEC_CV_HANDLER,
64058 ZEND_BOOL_SPEC_CONST_HANDLER,
64059 ZEND_BOOL_SPEC_TMPVAR_HANDLER,
64060 ZEND_BOOL_SPEC_TMPVAR_HANDLER,
64061 ZEND_NULL_HANDLER,
64062 ZEND_BOOL_SPEC_CV_HANDLER,
64063 ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER,
64064 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64065 ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER,
64066 ZEND_NULL_HANDLER,
64067 ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER,
64068 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64069 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64070 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64071 ZEND_NULL_HANDLER,
64072 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64073 ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER,
64074 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64075 ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER,
64076 ZEND_NULL_HANDLER,
64077 ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER,
64078 ZEND_NULL_HANDLER,
64079 ZEND_NULL_HANDLER,
64080 ZEND_NULL_HANDLER,
64081 ZEND_NULL_HANDLER,
64082 ZEND_NULL_HANDLER,
64083 ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER,
64084 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64085 ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER,
64086 ZEND_NULL_HANDLER,
64087 ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER,
64088 ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER,
64089 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
64090 ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER,
64091 ZEND_NULL_HANDLER,
64092 ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER,
64093 ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER,
64094 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
64095 ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER,
64096 ZEND_NULL_HANDLER,
64097 ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER,
64098 ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER,
64099 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
64100 ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER,
64101 ZEND_NULL_HANDLER,
64102 ZEND_ROPE_END_SPEC_TMP_CV_HANDLER,
64103 ZEND_BEGIN_SILENCE_SPEC_HANDLER,
64104 ZEND_END_SILENCE_SPEC_TMP_HANDLER,
64105 ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
64106 ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER,
64107 ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER,
64108 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
64109 ZEND_DO_FCALL_SPEC_OBSERVER_HANDLER,
64110 ZEND_INIT_FCALL_SPEC_CONST_HANDLER,
64111 ZEND_RETURN_SPEC_CONST_HANDLER,
64112 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
64113 ZEND_RETURN_SPEC_TMP_HANDLER,
64114 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
64115 ZEND_RETURN_SPEC_VAR_HANDLER,
64116 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
64117 ZEND_NULL_HANDLER,
64118 ZEND_NULL_HANDLER,
64119 ZEND_RETURN_SPEC_CV_HANDLER,
64120 ZEND_RETURN_SPEC_OBSERVER_HANDLER,
64121 ZEND_RECV_SPEC_UNUSED_HANDLER,
64122 ZEND_RECV_INIT_SPEC_CONST_HANDLER,
64123 ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER,
64124 ZEND_NULL_HANDLER,
64125 ZEND_NULL_HANDLER,
64126 ZEND_SEND_VAL_SPEC_CONST_UNUSED_HANDLER,
64127 ZEND_NULL_HANDLER,
64128 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
64129 ZEND_NULL_HANDLER,
64130 ZEND_NULL_HANDLER,
64131 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER,
64132 ZEND_NULL_HANDLER,
64133 ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER,
64134 ZEND_NULL_HANDLER,
64135 ZEND_NULL_HANDLER,
64136 ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER,
64137 ZEND_NULL_HANDLER,
64138 ZEND_NULL_HANDLER,
64139 ZEND_NULL_HANDLER,
64140 ZEND_NULL_HANDLER,
64141 ZEND_NULL_HANDLER,
64142 ZEND_NULL_HANDLER,
64143 ZEND_NULL_HANDLER,
64144 ZEND_NULL_HANDLER,
64145 ZEND_NULL_HANDLER,
64146 ZEND_NULL_HANDLER,
64147 ZEND_NULL_HANDLER,
64148 ZEND_NULL_HANDLER,
64149 ZEND_NULL_HANDLER,
64150 ZEND_NULL_HANDLER,
64151 ZEND_NULL_HANDLER,
64152 ZEND_NULL_HANDLER,
64153 ZEND_NULL_HANDLER,
64154 ZEND_NULL_HANDLER,
64155 ZEND_NULL_HANDLER,
64156 ZEND_NULL_HANDLER,
64157 ZEND_NULL_HANDLER,
64158 ZEND_NULL_HANDLER,
64159 ZEND_NULL_HANDLER,
64160 ZEND_NULL_HANDLER,
64161 ZEND_NULL_HANDLER,
64162 ZEND_NULL_HANDLER,
64163 ZEND_NULL_HANDLER,
64164 ZEND_NULL_HANDLER,
64165 ZEND_NULL_HANDLER,
64166 ZEND_NULL_HANDLER,
64167 ZEND_NULL_HANDLER,
64168 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
64169 ZEND_SEND_VAR_EX_SPEC_VAR_CONST_HANDLER,
64170 ZEND_NULL_HANDLER,
64171 ZEND_NULL_HANDLER,
64172 ZEND_NULL_HANDLER,
64173 ZEND_NULL_HANDLER,
64174 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_HANDLER,
64175 ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK_HANDLER,
64176 ZEND_NULL_HANDLER,
64177 ZEND_NULL_HANDLER,
64178 ZEND_NULL_HANDLER,
64179 ZEND_NULL_HANDLER,
64180 ZEND_NULL_HANDLER,
64181 ZEND_NULL_HANDLER,
64182 ZEND_NULL_HANDLER,
64183 ZEND_NULL_HANDLER,
64184 ZEND_NULL_HANDLER,
64185 ZEND_NULL_HANDLER,
64186 ZEND_NULL_HANDLER,
64187 ZEND_NULL_HANDLER,
64188 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
64189 ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER,
64190 ZEND_NULL_HANDLER,
64191 ZEND_NULL_HANDLER,
64192 ZEND_NULL_HANDLER,
64193 ZEND_NULL_HANDLER,
64194 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_HANDLER,
64195 ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER,
64196 ZEND_NULL_HANDLER,
64197 ZEND_NULL_HANDLER,
64198 ZEND_NULL_HANDLER,
64199 ZEND_NULL_HANDLER,
64200 ZEND_NULL_HANDLER,
64201 ZEND_NULL_HANDLER,
64202 ZEND_NULL_HANDLER,
64203 ZEND_NULL_HANDLER,
64204 ZEND_NULL_HANDLER,
64205 ZEND_NULL_HANDLER,
64206 ZEND_NULL_HANDLER,
64207 ZEND_NULL_HANDLER,
64208 ZEND_SEND_REF_SPEC_VAR_CONST_HANDLER,
64209 ZEND_NULL_HANDLER,
64210 ZEND_NULL_HANDLER,
64211 ZEND_SEND_REF_SPEC_VAR_UNUSED_HANDLER,
64212 ZEND_NULL_HANDLER,
64213 ZEND_NULL_HANDLER,
64214 ZEND_NULL_HANDLER,
64215 ZEND_NULL_HANDLER,
64216 ZEND_NULL_HANDLER,
64217 ZEND_NULL_HANDLER,
64218 ZEND_SEND_REF_SPEC_CV_CONST_HANDLER,
64219 ZEND_NULL_HANDLER,
64220 ZEND_NULL_HANDLER,
64221 ZEND_SEND_REF_SPEC_CV_UNUSED_HANDLER,
64222 ZEND_NULL_HANDLER,
64223 ZEND_NEW_SPEC_CONST_UNUSED_HANDLER,
64224 ZEND_NULL_HANDLER,
64225 ZEND_NEW_SPEC_VAR_UNUSED_HANDLER,
64226 ZEND_NEW_SPEC_UNUSED_UNUSED_HANDLER,
64227 ZEND_NULL_HANDLER,
64228 ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER,
64229 ZEND_FREE_SPEC_TMPVAR_HANDLER,
64230 ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER,
64231 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
64232 ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER,
64233 ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER,
64234 ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER,
64235 ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER,
64236 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
64237 ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER,
64238 ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER,
64239 ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER,
64240 ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER,
64241 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
64242 ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER,
64243 ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER,
64244 ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER,
64245 ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER,
64246 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
64247 ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER,
64248 ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER,
64249 ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER,
64250 ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER,
64251 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
64252 ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER,
64253 ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER,
64254 ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER,
64255 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER,
64256 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
64257 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER,
64258 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER,
64259 ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER,
64260 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER,
64261 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
64262 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER,
64263 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER,
64264 ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER,
64265 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER,
64266 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
64267 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER,
64268 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER,
64269 ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER,
64270 ZEND_NULL_HANDLER,
64271 ZEND_NULL_HANDLER,
64272 ZEND_NULL_HANDLER,
64273 ZEND_NULL_HANDLER,
64274 ZEND_NULL_HANDLER,
64275 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER,
64276 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
64277 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER,
64278 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER,
64279 ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER,
64280 ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
64281 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
64282 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
64283 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
64284 ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
64285 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
64286 ZEND_NULL_HANDLER,
64287 ZEND_NULL_HANDLER,
64288 ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
64289 ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER,
64290 ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER,
64291 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
64292 ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
64293 ZEND_NULL_HANDLER,
64294 ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER,
64295 ZEND_NULL_HANDLER,
64296 ZEND_NULL_HANDLER,
64297 ZEND_NULL_HANDLER,
64298 ZEND_NULL_HANDLER,
64299 ZEND_NULL_HANDLER,
64300 ZEND_NULL_HANDLER,
64301 ZEND_NULL_HANDLER,
64302 ZEND_NULL_HANDLER,
64303 ZEND_NULL_HANDLER,
64304 ZEND_NULL_HANDLER,
64305 ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER,
64306 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
64307 ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER,
64308 ZEND_NULL_HANDLER,
64309 ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER,
64310 ZEND_NULL_HANDLER,
64311 ZEND_NULL_HANDLER,
64312 ZEND_NULL_HANDLER,
64313 ZEND_NULL_HANDLER,
64314 ZEND_NULL_HANDLER,
64315 ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER,
64316 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
64317 ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER,
64318 ZEND_NULL_HANDLER,
64319 ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER,
64320 ZEND_NULL_HANDLER,
64321 ZEND_NULL_HANDLER,
64322 ZEND_NULL_HANDLER,
64323 ZEND_NULL_HANDLER,
64324 ZEND_NULL_HANDLER,
64325 ZEND_NULL_HANDLER,
64326 ZEND_NULL_HANDLER,
64327 ZEND_NULL_HANDLER,
64328 ZEND_NULL_HANDLER,
64329 ZEND_NULL_HANDLER,
64330 ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER,
64331 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
64332 ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER,
64333 ZEND_NULL_HANDLER,
64334 ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER,
64335 ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER,
64336 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
64337 ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
64338 ZEND_NULL_HANDLER,
64339 ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER,
64340 ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER,
64341 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
64342 ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER,
64343 ZEND_NULL_HANDLER,
64344 ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER,
64345 ZEND_FE_RESET_R_SPEC_CONST_HANDLER,
64346 ZEND_FE_RESET_R_SPEC_TMP_HANDLER,
64347 ZEND_FE_RESET_R_SPEC_VAR_HANDLER,
64348 ZEND_NULL_HANDLER,
64349 ZEND_FE_RESET_R_SPEC_CV_HANDLER,
64350 ZEND_FE_FETCH_R_SPEC_VAR_HANDLER,
64351 ZEND_EXIT_SPEC_HANDLER,
64352 ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER,
64353 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
64354 ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER,
64355 ZEND_NULL_HANDLER,
64356 ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER,
64357 ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER,
64358 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
64359 ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER,
64360 ZEND_NULL_HANDLER,
64361 ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER,
64362 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
64363 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64364 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64365 ZEND_NULL_HANDLER,
64366 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
64367 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER,
64368 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64369 ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64370 ZEND_NULL_HANDLER,
64371 ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER,
64372 ZEND_NULL_HANDLER,
64373 ZEND_NULL_HANDLER,
64374 ZEND_NULL_HANDLER,
64375 ZEND_NULL_HANDLER,
64376 ZEND_NULL_HANDLER,
64377 ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER,
64378 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
64379 ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER,
64380 ZEND_NULL_HANDLER,
64381 ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER,
64382 ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER,
64383 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
64384 ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER,
64385 ZEND_NULL_HANDLER,
64386 ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER,
64387 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
64388 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64389 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64390 ZEND_NULL_HANDLER,
64391 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
64392 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER,
64393 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64394 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER,
64395 ZEND_NULL_HANDLER,
64396 ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER,
64397 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER,
64398 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
64399 ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER,
64400 ZEND_NULL_HANDLER,
64401 ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER,
64402 ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER,
64403 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
64404 ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER,
64405 ZEND_NULL_HANDLER,
64406 ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER,
64407 ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER,
64408 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
64409 ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER,
64410 ZEND_NULL_HANDLER,
64411 ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER,
64412 ZEND_NULL_HANDLER,
64413 ZEND_NULL_HANDLER,
64414 ZEND_NULL_HANDLER,
64415 ZEND_NULL_HANDLER,
64416 ZEND_NULL_HANDLER,
64417 ZEND_NULL_HANDLER,
64418 ZEND_NULL_HANDLER,
64419 ZEND_NULL_HANDLER,
64420 ZEND_NULL_HANDLER,
64421 ZEND_NULL_HANDLER,
64422 ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
64423 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
64424 ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER,
64425 ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER,
64426 ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER,
64427 ZEND_NULL_HANDLER,
64428 ZEND_NULL_HANDLER,
64429 ZEND_NULL_HANDLER,
64430 ZEND_NULL_HANDLER,
64431 ZEND_NULL_HANDLER,
64432 ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER,
64433 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
64434 ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER,
64435 ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER,
64436 ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER,
64437 ZEND_NULL_HANDLER,
64438 ZEND_NULL_HANDLER,
64439 ZEND_NULL_HANDLER,
64440 ZEND_NULL_HANDLER,
64441 ZEND_NULL_HANDLER,
64442 ZEND_NULL_HANDLER,
64443 ZEND_NULL_HANDLER,
64444 ZEND_NULL_HANDLER,
64445 ZEND_NULL_HANDLER,
64446 ZEND_NULL_HANDLER,
64447 ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER,
64448 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
64449 ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER,
64450 ZEND_NULL_HANDLER,
64451 ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER,
64452 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER,
64453 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
64454 ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER,
64455 ZEND_NULL_HANDLER,
64456 ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER,
64457 ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER,
64458 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
64459 ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER,
64460 ZEND_NULL_HANDLER,
64461 ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER,
64462 ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER,
64463 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
64464 ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER,
64465 ZEND_NULL_HANDLER,
64466 ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER,
64467 ZEND_NULL_HANDLER,
64468 ZEND_NULL_HANDLER,
64469 ZEND_NULL_HANDLER,
64470 ZEND_NULL_HANDLER,
64471 ZEND_NULL_HANDLER,
64472 ZEND_NULL_HANDLER,
64473 ZEND_NULL_HANDLER,
64474 ZEND_NULL_HANDLER,
64475 ZEND_NULL_HANDLER,
64476 ZEND_NULL_HANDLER,
64477 ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
64478 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
64479 ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER,
64480 ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER,
64481 ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER,
64482 ZEND_NULL_HANDLER,
64483 ZEND_NULL_HANDLER,
64484 ZEND_NULL_HANDLER,
64485 ZEND_NULL_HANDLER,
64486 ZEND_NULL_HANDLER,
64487 ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER,
64488 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
64489 ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER,
64490 ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER,
64491 ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER,
64492 ZEND_NULL_HANDLER,
64493 ZEND_NULL_HANDLER,
64494 ZEND_NULL_HANDLER,
64495 ZEND_NULL_HANDLER,
64496 ZEND_NULL_HANDLER,
64497 ZEND_NULL_HANDLER,
64498 ZEND_NULL_HANDLER,
64499 ZEND_NULL_HANDLER,
64500 ZEND_NULL_HANDLER,
64501 ZEND_NULL_HANDLER,
64502 ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER,
64503 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
64504 ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER,
64505 ZEND_NULL_HANDLER,
64506 ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER,
64507 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER,
64508 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
64509 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER,
64510 ZEND_NULL_HANDLER,
64511 ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER,
64512 ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER,
64513 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
64514 ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER,
64515 ZEND_NULL_HANDLER,
64516 ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER,
64517 ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER,
64518 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
64519 ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER,
64520 ZEND_NULL_HANDLER,
64521 ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER,
64522 ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER,
64523 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
64524 ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER,
64525 ZEND_NULL_HANDLER,
64526 ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER,
64527 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
64528 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64529 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64530 ZEND_NULL_HANDLER,
64531 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
64532 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER,
64533 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64534 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64535 ZEND_NULL_HANDLER,
64536 ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER,
64537 ZEND_NULL_HANDLER,
64538 ZEND_NULL_HANDLER,
64539 ZEND_NULL_HANDLER,
64540 ZEND_NULL_HANDLER,
64541 ZEND_NULL_HANDLER,
64542 ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER,
64543 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
64544 ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER,
64545 ZEND_NULL_HANDLER,
64546 ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER,
64547 ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER,
64548 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
64549 ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER,
64550 ZEND_NULL_HANDLER,
64551 ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER,
64552 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
64553 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64554 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64555 ZEND_NULL_HANDLER,
64556 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
64557 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER,
64558 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64559 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER,
64560 ZEND_NULL_HANDLER,
64561 ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER,
64562 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER,
64563 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
64564 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER,
64565 ZEND_NULL_HANDLER,
64566 ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER,
64567 ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER,
64568 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
64569 ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER,
64570 ZEND_NULL_HANDLER,
64571 ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER,
64572 ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
64573 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
64574 ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER,
64575 ZEND_NULL_HANDLER,
64576 ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
64577 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
64578 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
64579 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
64580 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
64581 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER,
64582 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
64583 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
64584 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
64585 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER,
64586 ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER,
64587 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
64588 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
64589 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
64590 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
64591 ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER,
64592 ZEND_NULL_HANDLER,
64593 ZEND_NULL_HANDLER,
64594 ZEND_NULL_HANDLER,
64595 ZEND_NULL_HANDLER,
64596 ZEND_NULL_HANDLER,
64597 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER,
64598 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
64599 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
64600 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
64601 ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER,
64602 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
64603 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
64604 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER,
64605 ZEND_NULL_HANDLER,
64606 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER,
64607 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
64608 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
64609 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER,
64610 ZEND_NULL_HANDLER,
64611 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER,
64612 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
64613 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
64614 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER,
64615 ZEND_NULL_HANDLER,
64616 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER,
64617 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
64618 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
64619 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER,
64620 ZEND_NULL_HANDLER,
64621 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER,
64622 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER,
64623 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
64624 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER,
64625 ZEND_NULL_HANDLER,
64626 ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER,
64627 ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER,
64628 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
64629 ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER,
64630 ZEND_NULL_HANDLER,
64631 ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER,
64632 ZEND_NULL_HANDLER,
64633 ZEND_NULL_HANDLER,
64634 ZEND_NULL_HANDLER,
64635 ZEND_NULL_HANDLER,
64636 ZEND_NULL_HANDLER,
64637 ZEND_NULL_HANDLER,
64638 ZEND_NULL_HANDLER,
64639 ZEND_NULL_HANDLER,
64640 ZEND_NULL_HANDLER,
64641 ZEND_NULL_HANDLER,
64642 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
64643 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
64644 ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER,
64645 ZEND_NULL_HANDLER,
64646 ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER,
64647 ZEND_NULL_HANDLER,
64648 ZEND_NULL_HANDLER,
64649 ZEND_NULL_HANDLER,
64650 ZEND_NULL_HANDLER,
64651 ZEND_NULL_HANDLER,
64652 ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER,
64653 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
64654 ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER,
64655 ZEND_NULL_HANDLER,
64656 ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER,
64657 ZEND_NULL_HANDLER,
64658 ZEND_NULL_HANDLER,
64659 ZEND_NULL_HANDLER,
64660 ZEND_NULL_HANDLER,
64661 ZEND_NULL_HANDLER,
64662 ZEND_NULL_HANDLER,
64663 ZEND_NULL_HANDLER,
64664 ZEND_NULL_HANDLER,
64665 ZEND_NULL_HANDLER,
64666 ZEND_NULL_HANDLER,
64667 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER,
64668 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
64669 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER,
64670 ZEND_NULL_HANDLER,
64671 ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER,
64672 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER,
64673 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
64674 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER,
64675 ZEND_NULL_HANDLER,
64676 ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER,
64677 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER,
64678 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
64679 ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER,
64680 ZEND_NULL_HANDLER,
64681 ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER,
64682 ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER,
64683 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
64684 ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER,
64685 ZEND_NULL_HANDLER,
64686 ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER,
64687 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
64688 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64689 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64690 ZEND_NULL_HANDLER,
64691 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
64692 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
64693 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64694 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64695 ZEND_NULL_HANDLER,
64696 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
64697 ZEND_NULL_HANDLER,
64698 ZEND_NULL_HANDLER,
64699 ZEND_NULL_HANDLER,
64700 ZEND_NULL_HANDLER,
64701 ZEND_NULL_HANDLER,
64702 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER,
64703 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64704 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER,
64705 ZEND_NULL_HANDLER,
64706 ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER,
64707 ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
64708 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
64709 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER,
64710 ZEND_NULL_HANDLER,
64711 ZEND_NULL_HANDLER,
64712 ZEND_NULL_HANDLER,
64713 ZEND_NULL_HANDLER,
64714 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_HANDLER,
64715 ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK_HANDLER,
64716 ZEND_NULL_HANDLER,
64717 ZEND_NULL_HANDLER,
64718 ZEND_EXT_STMT_SPEC_HANDLER,
64719 ZEND_EXT_FCALL_BEGIN_SPEC_HANDLER,
64720 ZEND_EXT_FCALL_END_SPEC_HANDLER,
64721 ZEND_EXT_NOP_SPEC_HANDLER,
64722 ZEND_TICKS_SPEC_HANDLER,
64723 ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST_HANDLER,
64724 ZEND_NULL_HANDLER,
64725 ZEND_NULL_HANDLER,
64726 ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED_HANDLER,
64727 ZEND_NULL_HANDLER,
64728 ZEND_CATCH_SPEC_CONST_HANDLER,
64729 ZEND_THROW_SPEC_CONST_HANDLER,
64730 ZEND_THROW_SPEC_TMPVAR_HANDLER,
64731 ZEND_THROW_SPEC_TMPVAR_HANDLER,
64732 ZEND_NULL_HANDLER,
64733 ZEND_THROW_SPEC_CV_HANDLER,
64734 ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER,
64735 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
64736 ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER,
64737 ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
64738 ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER,
64739 ZEND_CLONE_SPEC_CONST_HANDLER,
64740 ZEND_CLONE_SPEC_TMPVAR_HANDLER,
64741 ZEND_CLONE_SPEC_TMPVAR_HANDLER,
64742 ZEND_CLONE_SPEC_UNUSED_HANDLER,
64743 ZEND_CLONE_SPEC_CV_HANDLER,
64744 ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
64745 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
64746 ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
64747 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
64748 ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
64749 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
64750 ZEND_NULL_HANDLER,
64751 ZEND_NULL_HANDLER,
64752 ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
64753 ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER,
64754 ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
64755 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
64756 ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
64757 ZEND_NULL_HANDLER,
64758 ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER,
64759 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
64760 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
64761 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
64762 ZEND_NULL_HANDLER,
64763 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
64764 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER,
64765 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
64766 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER,
64767 ZEND_NULL_HANDLER,
64768 ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER,
64769 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
64770 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
64771 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
64772 ZEND_NULL_HANDLER,
64773 ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
64774 ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER,
64775 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
64776 ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER,
64777 ZEND_NULL_HANDLER,
64778 ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER,
64779 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
64780 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
64781 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
64782 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER,
64783 ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER,
64784 ZEND_NULL_HANDLER,
64785 ZEND_NULL_HANDLER,
64786 ZEND_NULL_HANDLER,
64787 ZEND_NULL_HANDLER,
64788 ZEND_NULL_HANDLER,
64789 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER,
64790 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
64791 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER,
64792 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER,
64793 ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER,
64794 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER,
64795 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
64796 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER,
64797 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER,
64798 ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER,
64799 ZEND_NULL_HANDLER,
64800 ZEND_NULL_HANDLER,
64801 ZEND_NULL_HANDLER,
64802 ZEND_NULL_HANDLER,
64803 ZEND_NULL_HANDLER,
64804 ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER,
64805 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
64806 ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
64807 ZEND_NULL_HANDLER,
64808 ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER,
64809 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER,
64810 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
64811 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER,
64812 ZEND_NULL_HANDLER,
64813 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER,
64814 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
64815 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
64816 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
64817 ZEND_NULL_HANDLER,
64818 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
64819 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER,
64820 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
64821 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
64822 ZEND_NULL_HANDLER,
64823 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER,
64824 ZEND_NULL_HANDLER,
64825 ZEND_NULL_HANDLER,
64826 ZEND_NULL_HANDLER,
64827 ZEND_NULL_HANDLER,
64828 ZEND_NULL_HANDLER,
64829 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER,
64830 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
64831 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER,
64832 ZEND_NULL_HANDLER,
64833 ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER,
64834 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
64835 ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER,
64836 ZEND_NULL_HANDLER,
64837 ZEND_NULL_HANDLER,
64838 ZEND_NULL_HANDLER,
64839 ZEND_NULL_HANDLER,
64840 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_HANDLER,
64841 ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER,
64842 ZEND_NULL_HANDLER,
64843 ZEND_NULL_HANDLER,
64844 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
64845 ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER,
64846 ZEND_NULL_HANDLER,
64847 ZEND_NULL_HANDLER,
64848 ZEND_NULL_HANDLER,
64849 ZEND_NULL_HANDLER,
64850 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_HANDLER,
64851 ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER,
64852 ZEND_NULL_HANDLER,
64853 ZEND_NULL_HANDLER,
64854 ZEND_NULL_HANDLER,
64855 ZEND_NULL_HANDLER,
64856 ZEND_NULL_HANDLER,
64857 ZEND_NULL_HANDLER,
64858 ZEND_NULL_HANDLER,
64859 ZEND_NULL_HANDLER,
64860 ZEND_NULL_HANDLER,
64861 ZEND_NULL_HANDLER,
64862 ZEND_NULL_HANDLER,
64863 ZEND_NULL_HANDLER,
64864 ZEND_NULL_HANDLER,
64865 ZEND_NULL_HANDLER,
64866 ZEND_NULL_HANDLER,
64867 ZEND_NULL_HANDLER,
64868 ZEND_NULL_HANDLER,
64869 ZEND_NULL_HANDLER,
64870 ZEND_NULL_HANDLER,
64871 ZEND_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_NULL_HANDLER,
64887 ZEND_NULL_HANDLER,
64888 ZEND_NULL_HANDLER,
64889 ZEND_NULL_HANDLER,
64890 ZEND_NULL_HANDLER,
64891 ZEND_NULL_HANDLER,
64892 ZEND_NULL_HANDLER,
64893 ZEND_NULL_HANDLER,
64894 ZEND_SEND_VAR_SPEC_VAR_CONST_HANDLER,
64895 ZEND_NULL_HANDLER,
64896 ZEND_NULL_HANDLER,
64897 ZEND_SEND_VAR_SPEC_VAR_UNUSED_HANDLER,
64898 ZEND_NULL_HANDLER,
64899 ZEND_NULL_HANDLER,
64900 ZEND_NULL_HANDLER,
64901 ZEND_NULL_HANDLER,
64902 ZEND_NULL_HANDLER,
64903 ZEND_NULL_HANDLER,
64904 ZEND_SEND_VAR_SPEC_CV_CONST_HANDLER,
64905 ZEND_NULL_HANDLER,
64906 ZEND_NULL_HANDLER,
64907 ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER,
64908 ZEND_NULL_HANDLER,
64909 ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER,
64910 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
64911 ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER,
64912 ZEND_NULL_HANDLER,
64913 ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER,
64914 ZEND_SEND_ARRAY_SPEC_HANDLER,
64915 ZEND_SEND_USER_SPEC_CONST_HANDLER,
64916 ZEND_SEND_USER_SPEC_TMP_HANDLER,
64917 ZEND_SEND_USER_SPEC_VAR_HANDLER,
64918 ZEND_NULL_HANDLER,
64919 ZEND_SEND_USER_SPEC_CV_HANDLER,
64920 ZEND_STRLEN_SPEC_CONST_HANDLER,
64921 ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
64922 ZEND_STRLEN_SPEC_TMPVAR_HANDLER,
64923 ZEND_NULL_HANDLER,
64924 ZEND_STRLEN_SPEC_CV_HANDLER,
64925 ZEND_DEFINED_SPEC_CONST_HANDLER,
64926 ZEND_TYPE_CHECK_SPEC_CONST_HANDLER,
64927 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
64928 ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER,
64929 ZEND_NULL_HANDLER,
64930 ZEND_TYPE_CHECK_SPEC_CV_HANDLER,
64931 ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER,
64932 ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED_HANDLER,
64933 ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED_HANDLER,
64934 ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
64935 ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER,
64936 ZEND_FE_RESET_RW_SPEC_CONST_HANDLER,
64937 ZEND_FE_RESET_RW_SPEC_TMP_HANDLER,
64938 ZEND_FE_RESET_RW_SPEC_VAR_HANDLER,
64939 ZEND_NULL_HANDLER,
64940 ZEND_FE_RESET_RW_SPEC_CV_HANDLER,
64941 ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER,
64942 ZEND_FE_FREE_SPEC_TMPVAR_HANDLER,
64943 ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER,
64944 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
64945 ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER,
64946 ZEND_NULL_HANDLER,
64947 ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER,
64948 ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER,
64949 ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER,
64950 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
64951 ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
64952 ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER,
64953 ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER,
64954 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
64955 ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
64956 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER,
64957 ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER,
64958 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_HANDLER,
64959 ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER_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_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER,
64971 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
64972 ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
64973 ZEND_NULL_HANDLER,
64974 ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER,
64975 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
64976 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
64977 ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
64978 ZEND_NULL_HANDLER,
64979 ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
64980 ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER,
64981 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
64982 ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
64983 ZEND_NULL_HANDLER,
64984 ZEND_PRE_INC_OBJ_SPEC_CV_CV_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_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER,
64996 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
64997 ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER,
64998 ZEND_NULL_HANDLER,
64999 ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER,
65000 ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER,
65001 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65002 ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65003 ZEND_NULL_HANDLER,
65004 ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER,
65005 ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER,
65006 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
65007 ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER,
65008 ZEND_NULL_HANDLER,
65009 ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER,
65010 ZEND_ECHO_SPEC_CONST_HANDLER,
65011 ZEND_ECHO_SPEC_TMPVAR_HANDLER,
65012 ZEND_ECHO_SPEC_TMPVAR_HANDLER,
65013 ZEND_NULL_HANDLER,
65014 ZEND_ECHO_SPEC_CV_HANDLER,
65015 ZEND_NULL_HANDLER,
65016 ZEND_NULL_HANDLER,
65017 ZEND_NULL_HANDLER,
65018 ZEND_NULL_HANDLER,
65019 ZEND_NULL_HANDLER,
65020 ZEND_NULL_HANDLER,
65021 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
65022 ZEND_NULL_HANDLER,
65023 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
65024 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER,
65025 ZEND_NULL_HANDLER,
65026 ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER,
65027 ZEND_NULL_HANDLER,
65028 ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER,
65029 ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_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_INSTANCEOF_SPEC_CV_CONST_HANDLER,
65037 ZEND_NULL_HANDLER,
65038 ZEND_INSTANCEOF_SPEC_CV_VAR_HANDLER,
65039 ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER,
65040 ZEND_NULL_HANDLER,
65041 ZEND_GENERATOR_CREATE_SPEC_HANDLER,
65042 ZEND_NULL_HANDLER,
65043 ZEND_NULL_HANDLER,
65044 ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER,
65045 ZEND_NULL_HANDLER,
65046 ZEND_MAKE_REF_SPEC_CV_UNUSED_HANDLER,
65047 ZEND_DECLARE_FUNCTION_SPEC_HANDLER,
65048 ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_HANDLER,
65049 ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER,
65050 ZEND_DECLARE_CLASS_SPEC_CONST_HANDLER,
65051 ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER,
65052 ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER,
65053 ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER,
65054 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER,
65055 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
65056 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER,
65057 ZEND_NULL_HANDLER,
65058 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER,
65059 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
65060 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
65061 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
65062 ZEND_NULL_HANDLER,
65063 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
65064 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER,
65065 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
65066 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER,
65067 ZEND_NULL_HANDLER,
65068 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER,
65069 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER,
65070 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65071 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER,
65072 ZEND_NULL_HANDLER,
65073 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER,
65074 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER,
65075 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
65076 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER,
65077 ZEND_NULL_HANDLER,
65078 ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER,
65079 ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
65080 ZEND_USER_OPCODE_SPEC_HANDLER,
65081 ZEND_ASSERT_CHECK_SPEC_HANDLER,
65082 ZEND_JMP_SET_SPEC_CONST_HANDLER,
65083 ZEND_JMP_SET_SPEC_TMP_HANDLER,
65084 ZEND_JMP_SET_SPEC_VAR_HANDLER,
65085 ZEND_NULL_HANDLER,
65086 ZEND_JMP_SET_SPEC_CV_HANDLER,
65087 ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER,
65088 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER,
65089 ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER,
65090 ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER,
65091 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
65092 ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
65093 ZEND_NULL_HANDLER,
65094 ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER,
65095 ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER,
65096 ZEND_NULL_HANDLER,
65097 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
65098 ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER,
65099 ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER,
65100 ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER,
65101 ZEND_CALL_TRAMPOLINE_SPEC_HANDLER,
65102 ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER,
65103 ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
65104 ZEND_YIELD_SPEC_CONST_CONST_HANDLER,
65105 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
65106 ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
65107 ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER,
65108 ZEND_YIELD_SPEC_CONST_CV_HANDLER,
65109 ZEND_YIELD_SPEC_TMP_CONST_HANDLER,
65110 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
65111 ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER,
65112 ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER,
65113 ZEND_YIELD_SPEC_TMP_CV_HANDLER,
65114 ZEND_YIELD_SPEC_VAR_CONST_HANDLER,
65115 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
65116 ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER,
65117 ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER,
65118 ZEND_YIELD_SPEC_VAR_CV_HANDLER,
65119 ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER,
65120 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
65121 ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER,
65122 ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER,
65123 ZEND_YIELD_SPEC_UNUSED_CV_HANDLER,
65124 ZEND_YIELD_SPEC_CV_CONST_HANDLER,
65125 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
65126 ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER,
65127 ZEND_YIELD_SPEC_CV_UNUSED_HANDLER,
65128 ZEND_YIELD_SPEC_CV_CV_HANDLER,
65129 ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER,
65130 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
65131 ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER,
65132 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
65133 ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER,
65134 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
65135 ZEND_NULL_HANDLER,
65136 ZEND_NULL_HANDLER,
65137 ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER,
65138 ZEND_GENERATOR_RETURN_SPEC_OBSERVER_HANDLER,
65139 ZEND_FAST_CALL_SPEC_HANDLER,
65140 ZEND_FAST_RET_SPEC_HANDLER,
65141 ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER,
65142 ZEND_SEND_UNPACK_SPEC_HANDLER,
65143 ZEND_YIELD_FROM_SPEC_CONST_HANDLER,
65144 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
65145 ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER,
65146 ZEND_NULL_HANDLER,
65147 ZEND_YIELD_FROM_SPEC_CV_HANDLER,
65148 ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER,
65149 ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER,
65150 ZEND_COALESCE_SPEC_CONST_HANDLER,
65151 ZEND_COALESCE_SPEC_TMP_HANDLER,
65152 ZEND_COALESCE_SPEC_VAR_HANDLER,
65153 ZEND_NULL_HANDLER,
65154 ZEND_COALESCE_SPEC_CV_HANDLER,
65155 ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER,
65156 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
65157 ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER,
65158 ZEND_NULL_HANDLER,
65159 ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER,
65160 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
65161 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
65162 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
65163 ZEND_NULL_HANDLER,
65164 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
65165 ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER,
65166 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
65167 ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER,
65168 ZEND_NULL_HANDLER,
65169 ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER,
65170 ZEND_NULL_HANDLER,
65171 ZEND_NULL_HANDLER,
65172 ZEND_NULL_HANDLER,
65173 ZEND_NULL_HANDLER,
65174 ZEND_NULL_HANDLER,
65175 ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER,
65176 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
65177 ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER,
65178 ZEND_NULL_HANDLER,
65179 ZEND_SPACESHIP_SPEC_CV_CV_HANDLER,
65180 ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
65181 ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_HANDLER,
65182 ZEND_NULL_HANDLER,
65183 ZEND_NULL_HANDLER,
65184 ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
65185 ZEND_NULL_HANDLER,
65186 ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER,
65187 ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER,
65188 ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER,
65189 ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER,
65190 ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER,
65191 ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER,
65192 ZEND_UNSET_STATIC_PROP_SPEC_HANDLER,
65193 ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER,
65194 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER,
65195 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
65196 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
65197 ZEND_NULL_HANDLER,
65198 ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV_HANDLER,
65199 ZEND_NULL_HANDLER,
65200 ZEND_NULL_HANDLER,
65201 ZEND_NULL_HANDLER,
65202 ZEND_NULL_HANDLER,
65203 ZEND_NULL_HANDLER,
65204 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_HANDLER,
65205 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
65206 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
65207 ZEND_NULL_HANDLER,
65208 ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER,
65209 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_HANDLER,
65210 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
65211 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
65212 ZEND_NULL_HANDLER,
65213 ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER,
65214 ZEND_NULL_HANDLER,
65215 ZEND_NULL_HANDLER,
65216 ZEND_NULL_HANDLER,
65217 ZEND_NULL_HANDLER,
65218 ZEND_NULL_HANDLER,
65219 ZEND_BIND_LEXICAL_SPEC_TMP_CV_HANDLER,
65220 ZEND_BIND_STATIC_SPEC_CV_HANDLER,
65221 ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_HANDLER,
65222 ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
65223 ZEND_NULL_HANDLER,
65224 ZEND_NULL_HANDLER,
65225 ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
65226 ZEND_NULL_HANDLER,
65227 ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER,
65228 ZEND_SWITCH_LONG_SPEC_CONST_CONST_HANDLER,
65229 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65230 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65231 ZEND_NULL_HANDLER,
65232 ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65233 ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER,
65234 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
65235 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
65236 ZEND_NULL_HANDLER,
65237 ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER,
65238 ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER,
65239 ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER,
65240 ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER,
65241 ZEND_NULL_HANDLER,
65242 ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER,
65243 ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER,
65244 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
65245 ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER,
65246 ZEND_NULL_HANDLER,
65247 ZEND_COUNT_SPEC_CV_UNUSED_HANDLER,
65248 ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER,
65249 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
65250 ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER,
65251 ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
65252 ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER,
65253 ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER,
65254 ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER,
65255 ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER,
65256 ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER,
65257 ZEND_NULL_HANDLER,
65258 ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER,
65259 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER,
65260 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
65261 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
65262 ZEND_NULL_HANDLER,
65263 ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER,
65264 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
65265 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
65266 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
65267 ZEND_NULL_HANDLER,
65268 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
65269 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
65270 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
65271 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
65272 ZEND_NULL_HANDLER,
65273 ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
65274 ZEND_NULL_HANDLER,
65275 ZEND_NULL_HANDLER,
65276 ZEND_NULL_HANDLER,
65277 ZEND_NULL_HANDLER,
65278 ZEND_NULL_HANDLER,
65279 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER,
65280 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
65281 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
65282 ZEND_NULL_HANDLER,
65283 ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER,
65284 ZEND_MATCH_SPEC_CONST_CONST_HANDLER,
65285 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
65286 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
65287 ZEND_NULL_HANDLER,
65288 ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER,
65289 ZEND_NULL_HANDLER,
65290 ZEND_NULL_HANDLER,
65291 ZEND_NULL_HANDLER,
65292 ZEND_NULL_HANDLER,
65293 ZEND_NULL_HANDLER,
65294 ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER,
65295 ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER,
65296 ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER,
65297 ZEND_NULL_HANDLER,
65298 ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER,
65299 ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER,
65300 ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER,
65301 ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER,
65302 ZEND_NULL_HANDLER,
65303 ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER,
65304 ZEND_NULL_HANDLER,
65305 ZEND_NULL_HANDLER,
65306 ZEND_NULL_HANDLER,
65307 ZEND_NULL_HANDLER,
65308 ZEND_NULL_HANDLER,
65309 ZEND_NULL_HANDLER,
65310 ZEND_NULL_HANDLER,
65311 ZEND_NULL_HANDLER,
65312 ZEND_NULL_HANDLER,
65313 ZEND_NULL_HANDLER,
65314 ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER,
65315 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
65316 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
65317 ZEND_NULL_HANDLER,
65318 ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER,
65319 ZEND_JMP_NULL_SPEC_CONST_HANDLER,
65320 ZEND_JMP_NULL_SPEC_TMP_HANDLER,
65321 ZEND_JMP_NULL_SPEC_VAR_HANDLER,
65322 ZEND_NULL_HANDLER,
65323 ZEND_JMP_NULL_SPEC_CV_HANDLER,
65324 ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
65325 ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER,
65326 ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER,
65327 ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER,
65328 ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV_HANDLER,
65329 ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED_HANDLER,
65330 ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER,
65331 ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER,
65332 ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER,
65333 ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER,
65334 ZEND_RECV_NOTYPE_SPEC_HANDLER,
65335 ZEND_NULL_HANDLER,
65336 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
65337 ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER,
65338 ZEND_NULL_HANDLER,
65339 ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER,
65340 ZEND_JMP_FORWARD_SPEC_HANDLER,
65341 ZEND_NULL_HANDLER,
65342 ZEND_NULL_HANDLER,
65343 ZEND_NULL_HANDLER,
65344 ZEND_NULL_HANDLER,
65345 ZEND_NULL_HANDLER,
65346 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65347 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65348 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65349 ZEND_NULL_HANDLER,
65350 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65351 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65352 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65353 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65354 ZEND_NULL_HANDLER,
65355 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65356 ZEND_NULL_HANDLER,
65357 ZEND_NULL_HANDLER,
65358 ZEND_NULL_HANDLER,
65359 ZEND_NULL_HANDLER,
65360 ZEND_NULL_HANDLER,
65361 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65362 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65363 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65364 ZEND_NULL_HANDLER,
65365 ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65366 ZEND_NULL_HANDLER,
65367 ZEND_NULL_HANDLER,
65368 ZEND_NULL_HANDLER,
65369 ZEND_NULL_HANDLER,
65370 ZEND_NULL_HANDLER,
65371 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65372 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65373 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65374 ZEND_NULL_HANDLER,
65375 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65376 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65377 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65378 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65379 ZEND_NULL_HANDLER,
65380 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65381 ZEND_NULL_HANDLER,
65382 ZEND_NULL_HANDLER,
65383 ZEND_NULL_HANDLER,
65384 ZEND_NULL_HANDLER,
65385 ZEND_NULL_HANDLER,
65386 ZEND_ADD_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65387 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65388 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65389 ZEND_NULL_HANDLER,
65390 ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65391 ZEND_NULL_HANDLER,
65392 ZEND_NULL_HANDLER,
65393 ZEND_NULL_HANDLER,
65394 ZEND_NULL_HANDLER,
65395 ZEND_NULL_HANDLER,
65396 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65397 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65398 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65399 ZEND_NULL_HANDLER,
65400 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65401 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65402 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65403 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65404 ZEND_NULL_HANDLER,
65405 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65406 ZEND_NULL_HANDLER,
65407 ZEND_NULL_HANDLER,
65408 ZEND_NULL_HANDLER,
65409 ZEND_NULL_HANDLER,
65410 ZEND_NULL_HANDLER,
65411 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65412 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65413 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65414 ZEND_NULL_HANDLER,
65415 ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65416 ZEND_NULL_HANDLER,
65417 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
65418 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
65419 ZEND_NULL_HANDLER,
65420 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV_HANDLER,
65421 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65422 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65423 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65424 ZEND_NULL_HANDLER,
65425 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65426 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65427 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65428 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65429 ZEND_NULL_HANDLER,
65430 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65431 ZEND_NULL_HANDLER,
65432 ZEND_NULL_HANDLER,
65433 ZEND_NULL_HANDLER,
65434 ZEND_NULL_HANDLER,
65435 ZEND_NULL_HANDLER,
65436 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65437 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65438 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65439 ZEND_NULL_HANDLER,
65440 ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65441 ZEND_NULL_HANDLER,
65442 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65443 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65444 ZEND_NULL_HANDLER,
65445 ZEND_SUB_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65446 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65447 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65448 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65449 ZEND_NULL_HANDLER,
65450 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65451 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65452 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65453 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65454 ZEND_NULL_HANDLER,
65455 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65456 ZEND_NULL_HANDLER,
65457 ZEND_NULL_HANDLER,
65458 ZEND_NULL_HANDLER,
65459 ZEND_NULL_HANDLER,
65460 ZEND_NULL_HANDLER,
65461 ZEND_SUB_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65462 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65463 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65464 ZEND_NULL_HANDLER,
65465 ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65466 ZEND_NULL_HANDLER,
65467 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65468 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65469 ZEND_NULL_HANDLER,
65470 ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65471 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65472 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65473 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65474 ZEND_NULL_HANDLER,
65475 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65476 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65477 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65478 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65479 ZEND_NULL_HANDLER,
65480 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65481 ZEND_NULL_HANDLER,
65482 ZEND_NULL_HANDLER,
65483 ZEND_NULL_HANDLER,
65484 ZEND_NULL_HANDLER,
65485 ZEND_NULL_HANDLER,
65486 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65487 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65488 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65489 ZEND_NULL_HANDLER,
65490 ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65491 ZEND_NULL_HANDLER,
65492 ZEND_NULL_HANDLER,
65493 ZEND_NULL_HANDLER,
65494 ZEND_NULL_HANDLER,
65495 ZEND_NULL_HANDLER,
65496 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65497 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65498 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65499 ZEND_NULL_HANDLER,
65500 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65501 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65502 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65503 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65504 ZEND_NULL_HANDLER,
65505 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65506 ZEND_NULL_HANDLER,
65507 ZEND_NULL_HANDLER,
65508 ZEND_NULL_HANDLER,
65509 ZEND_NULL_HANDLER,
65510 ZEND_NULL_HANDLER,
65511 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER,
65512 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65513 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65514 ZEND_NULL_HANDLER,
65515 ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65516 ZEND_NULL_HANDLER,
65517 ZEND_NULL_HANDLER,
65518 ZEND_NULL_HANDLER,
65519 ZEND_NULL_HANDLER,
65520 ZEND_NULL_HANDLER,
65521 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65522 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65523 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65524 ZEND_NULL_HANDLER,
65525 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65526 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65527 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65528 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65529 ZEND_NULL_HANDLER,
65530 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65531 ZEND_NULL_HANDLER,
65532 ZEND_NULL_HANDLER,
65533 ZEND_NULL_HANDLER,
65534 ZEND_NULL_HANDLER,
65535 ZEND_NULL_HANDLER,
65536 ZEND_MUL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65537 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65538 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65539 ZEND_NULL_HANDLER,
65540 ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65541 ZEND_NULL_HANDLER,
65542 ZEND_NULL_HANDLER,
65543 ZEND_NULL_HANDLER,
65544 ZEND_NULL_HANDLER,
65545 ZEND_NULL_HANDLER,
65546 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65547 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65548 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65549 ZEND_NULL_HANDLER,
65550 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65551 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65552 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65553 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65554 ZEND_NULL_HANDLER,
65555 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65556 ZEND_NULL_HANDLER,
65557 ZEND_NULL_HANDLER,
65558 ZEND_NULL_HANDLER,
65559 ZEND_NULL_HANDLER,
65560 ZEND_NULL_HANDLER,
65561 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65562 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65563 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65564 ZEND_NULL_HANDLER,
65565 ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65566 ZEND_NULL_HANDLER,
65567 ZEND_NULL_HANDLER,
65568 ZEND_NULL_HANDLER,
65569 ZEND_NULL_HANDLER,
65570 ZEND_NULL_HANDLER,
65571 ZEND_NULL_HANDLER,
65572 ZEND_NULL_HANDLER,
65573 ZEND_NULL_HANDLER,
65574 ZEND_NULL_HANDLER,
65575 ZEND_NULL_HANDLER,
65576 ZEND_NULL_HANDLER,
65577 ZEND_NULL_HANDLER,
65578 ZEND_NULL_HANDLER,
65579 ZEND_NULL_HANDLER,
65580 ZEND_NULL_HANDLER,
65581 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65582 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65583 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65584 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65585 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65586 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65587 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65588 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65589 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65590 ZEND_NULL_HANDLER,
65591 ZEND_NULL_HANDLER,
65592 ZEND_NULL_HANDLER,
65593 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65594 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65595 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65596 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65597 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65598 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65599 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65600 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65601 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65602 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65603 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65604 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65605 ZEND_NULL_HANDLER,
65606 ZEND_NULL_HANDLER,
65607 ZEND_NULL_HANDLER,
65608 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65609 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65610 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
65623 ZEND_NULL_HANDLER,
65624 ZEND_NULL_HANDLER,
65625 ZEND_NULL_HANDLER,
65626 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65627 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65628 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65629 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65630 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65631 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65632 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65633 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65634 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65635 ZEND_NULL_HANDLER,
65636 ZEND_NULL_HANDLER,
65637 ZEND_NULL_HANDLER,
65638 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65639 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65640 ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65641 ZEND_NULL_HANDLER,
65642 ZEND_NULL_HANDLER,
65643 ZEND_NULL_HANDLER,
65644 ZEND_NULL_HANDLER,
65645 ZEND_NULL_HANDLER,
65646 ZEND_NULL_HANDLER,
65647 ZEND_NULL_HANDLER,
65648 ZEND_NULL_HANDLER,
65649 ZEND_NULL_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_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65657 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65658 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65659 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65660 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65661 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65662 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65663 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65664 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65665 ZEND_NULL_HANDLER,
65666 ZEND_NULL_HANDLER,
65667 ZEND_NULL_HANDLER,
65668 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65669 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65670 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65671 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65672 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65673 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65674 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65675 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65676 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65677 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65678 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65679 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65680 ZEND_NULL_HANDLER,
65681 ZEND_NULL_HANDLER,
65682 ZEND_NULL_HANDLER,
65683 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65684 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65685 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65686 ZEND_NULL_HANDLER,
65687 ZEND_NULL_HANDLER,
65688 ZEND_NULL_HANDLER,
65689 ZEND_NULL_HANDLER,
65690 ZEND_NULL_HANDLER,
65691 ZEND_NULL_HANDLER,
65692 ZEND_NULL_HANDLER,
65693 ZEND_NULL_HANDLER,
65694 ZEND_NULL_HANDLER,
65695 ZEND_NULL_HANDLER,
65696 ZEND_NULL_HANDLER,
65697 ZEND_NULL_HANDLER,
65698 ZEND_NULL_HANDLER,
65699 ZEND_NULL_HANDLER,
65700 ZEND_NULL_HANDLER,
65701 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65702 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65703 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65704 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65705 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65706 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65707 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65708 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65709 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65710 ZEND_NULL_HANDLER,
65711 ZEND_NULL_HANDLER,
65712 ZEND_NULL_HANDLER,
65713 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65714 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65715 ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65716 ZEND_NULL_HANDLER,
65717 ZEND_NULL_HANDLER,
65718 ZEND_NULL_HANDLER,
65719 ZEND_NULL_HANDLER,
65720 ZEND_NULL_HANDLER,
65721 ZEND_NULL_HANDLER,
65722 ZEND_NULL_HANDLER,
65723 ZEND_NULL_HANDLER,
65724 ZEND_NULL_HANDLER,
65725 ZEND_NULL_HANDLER,
65726 ZEND_NULL_HANDLER,
65727 ZEND_NULL_HANDLER,
65728 ZEND_NULL_HANDLER,
65729 ZEND_NULL_HANDLER,
65730 ZEND_NULL_HANDLER,
65731 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65732 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65733 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65734 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65735 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65736 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65737 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65738 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65739 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65740 ZEND_NULL_HANDLER,
65741 ZEND_NULL_HANDLER,
65742 ZEND_NULL_HANDLER,
65743 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65744 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65745 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65746 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65747 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65748 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65749 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65750 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65751 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65752 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65753 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65754 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65755 ZEND_NULL_HANDLER,
65756 ZEND_NULL_HANDLER,
65757 ZEND_NULL_HANDLER,
65758 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65759 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65760 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65761 ZEND_NULL_HANDLER,
65762 ZEND_NULL_HANDLER,
65763 ZEND_NULL_HANDLER,
65764 ZEND_NULL_HANDLER,
65765 ZEND_NULL_HANDLER,
65766 ZEND_NULL_HANDLER,
65767 ZEND_NULL_HANDLER,
65768 ZEND_NULL_HANDLER,
65769 ZEND_NULL_HANDLER,
65770 ZEND_NULL_HANDLER,
65771 ZEND_NULL_HANDLER,
65772 ZEND_NULL_HANDLER,
65773 ZEND_NULL_HANDLER,
65774 ZEND_NULL_HANDLER,
65775 ZEND_NULL_HANDLER,
65776 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65777 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65778 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65779 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65780 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65781 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65782 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65783 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65784 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65785 ZEND_NULL_HANDLER,
65786 ZEND_NULL_HANDLER,
65787 ZEND_NULL_HANDLER,
65788 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65789 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65790 ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65791 ZEND_NULL_HANDLER,
65792 ZEND_NULL_HANDLER,
65793 ZEND_NULL_HANDLER,
65794 ZEND_NULL_HANDLER,
65795 ZEND_NULL_HANDLER,
65796 ZEND_NULL_HANDLER,
65797 ZEND_NULL_HANDLER,
65798 ZEND_NULL_HANDLER,
65799 ZEND_NULL_HANDLER,
65800 ZEND_NULL_HANDLER,
65801 ZEND_NULL_HANDLER,
65802 ZEND_NULL_HANDLER,
65803 ZEND_NULL_HANDLER,
65804 ZEND_NULL_HANDLER,
65805 ZEND_NULL_HANDLER,
65806 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65807 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65808 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65809 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65810 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65811 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65812 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65813 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65814 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65815 ZEND_NULL_HANDLER,
65816 ZEND_NULL_HANDLER,
65817 ZEND_NULL_HANDLER,
65818 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65819 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65820 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65821 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65822 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65823 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65824 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65825 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65826 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65827 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65828 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65829 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65830 ZEND_NULL_HANDLER,
65831 ZEND_NULL_HANDLER,
65832 ZEND_NULL_HANDLER,
65833 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65834 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65835 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65836 ZEND_NULL_HANDLER,
65837 ZEND_NULL_HANDLER,
65838 ZEND_NULL_HANDLER,
65839 ZEND_NULL_HANDLER,
65840 ZEND_NULL_HANDLER,
65841 ZEND_NULL_HANDLER,
65842 ZEND_NULL_HANDLER,
65843 ZEND_NULL_HANDLER,
65844 ZEND_NULL_HANDLER,
65845 ZEND_NULL_HANDLER,
65846 ZEND_NULL_HANDLER,
65847 ZEND_NULL_HANDLER,
65848 ZEND_NULL_HANDLER,
65849 ZEND_NULL_HANDLER,
65850 ZEND_NULL_HANDLER,
65851 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65852 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65853 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65854 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65855 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65856 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65857 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65858 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65859 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65860 ZEND_NULL_HANDLER,
65861 ZEND_NULL_HANDLER,
65862 ZEND_NULL_HANDLER,
65863 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65864 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65865 ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65866 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
65867 ZEND_NULL_HANDLER,
65868 ZEND_NULL_HANDLER,
65869 ZEND_NULL_HANDLER,
65870 ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
65871 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST_HANDLER,
65872 ZEND_NULL_HANDLER,
65873 ZEND_NULL_HANDLER,
65874 ZEND_NULL_HANDLER,
65875 ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV_HANDLER,
65876 ZEND_NULL_HANDLER,
65877 ZEND_NULL_HANDLER,
65878 ZEND_NULL_HANDLER,
65879 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65880 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65881 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65882 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65883 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65884 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65885 ZEND_NULL_HANDLER,
65886 ZEND_NULL_HANDLER,
65887 ZEND_NULL_HANDLER,
65888 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_HANDLER,
65889 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65890 ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65891 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65892 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65893 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65894 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65895 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65896 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65897 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65898 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65899 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65900 ZEND_NULL_HANDLER,
65901 ZEND_NULL_HANDLER,
65902 ZEND_NULL_HANDLER,
65903 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65904 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65905 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65906 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65907 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65908 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65909 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65910 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65911 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65912 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65913 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65914 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65915 ZEND_NULL_HANDLER,
65916 ZEND_NULL_HANDLER,
65917 ZEND_NULL_HANDLER,
65918 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65919 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65920 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_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_NULL_HANDLER,
65931 ZEND_NULL_HANDLER,
65932 ZEND_NULL_HANDLER,
65933 ZEND_NULL_HANDLER,
65934 ZEND_NULL_HANDLER,
65935 ZEND_NULL_HANDLER,
65936 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_HANDLER,
65937 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65938 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65939 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65940 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65941 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65942 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65943 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65944 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65945 ZEND_NULL_HANDLER,
65946 ZEND_NULL_HANDLER,
65947 ZEND_NULL_HANDLER,
65948 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65949 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65950 ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65951 ZEND_NULL_HANDLER,
65952 ZEND_NULL_HANDLER,
65953 ZEND_NULL_HANDLER,
65954 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65955 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65956 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65957 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65958 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65959 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65960 ZEND_NULL_HANDLER,
65961 ZEND_NULL_HANDLER,
65962 ZEND_NULL_HANDLER,
65963 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
65964 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
65965 ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
65966 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65967 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65968 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65969 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65970 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65971 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65972 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65973 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65974 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65975 ZEND_NULL_HANDLER,
65976 ZEND_NULL_HANDLER,
65977 ZEND_NULL_HANDLER,
65978 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65979 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65980 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65981 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
65982 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
65983 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
65984 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65985 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65986 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65987 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65988 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65989 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65990 ZEND_NULL_HANDLER,
65991 ZEND_NULL_HANDLER,
65992 ZEND_NULL_HANDLER,
65993 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
65994 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
65995 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
65996 ZEND_NULL_HANDLER,
65997 ZEND_NULL_HANDLER,
65998 ZEND_NULL_HANDLER,
65999 ZEND_NULL_HANDLER,
66000 ZEND_NULL_HANDLER,
66001 ZEND_NULL_HANDLER,
66002 ZEND_NULL_HANDLER,
66003 ZEND_NULL_HANDLER,
66004 ZEND_NULL_HANDLER,
66005 ZEND_NULL_HANDLER,
66006 ZEND_NULL_HANDLER,
66007 ZEND_NULL_HANDLER,
66008 ZEND_NULL_HANDLER,
66009 ZEND_NULL_HANDLER,
66010 ZEND_NULL_HANDLER,
66011 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66012 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66013 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66014 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66015 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66016 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66017 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66018 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66019 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66020 ZEND_NULL_HANDLER,
66021 ZEND_NULL_HANDLER,
66022 ZEND_NULL_HANDLER,
66023 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66024 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66025 ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66026 ZEND_NULL_HANDLER,
66027 ZEND_NULL_HANDLER,
66028 ZEND_NULL_HANDLER,
66029 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66030 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66031 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66032 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66033 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66034 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66035 ZEND_NULL_HANDLER,
66036 ZEND_NULL_HANDLER,
66037 ZEND_NULL_HANDLER,
66038 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_HANDLER,
66039 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66040 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66041 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66042 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66043 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66044 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66045 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66046 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66047 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66048 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66049 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66050 ZEND_NULL_HANDLER,
66051 ZEND_NULL_HANDLER,
66052 ZEND_NULL_HANDLER,
66053 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66054 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66055 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66056 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66057 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66058 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66059 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66060 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66061 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66062 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66063 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66064 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66065 ZEND_NULL_HANDLER,
66066 ZEND_NULL_HANDLER,
66067 ZEND_NULL_HANDLER,
66068 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66069 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66070 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66071 ZEND_NULL_HANDLER,
66072 ZEND_NULL_HANDLER,
66073 ZEND_NULL_HANDLER,
66074 ZEND_NULL_HANDLER,
66075 ZEND_NULL_HANDLER,
66076 ZEND_NULL_HANDLER,
66077 ZEND_NULL_HANDLER,
66078 ZEND_NULL_HANDLER,
66079 ZEND_NULL_HANDLER,
66080 ZEND_NULL_HANDLER,
66081 ZEND_NULL_HANDLER,
66082 ZEND_NULL_HANDLER,
66083 ZEND_NULL_HANDLER,
66084 ZEND_NULL_HANDLER,
66085 ZEND_NULL_HANDLER,
66086 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_HANDLER,
66087 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66088 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66089 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66090 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66091 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66092 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66093 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66094 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66095 ZEND_NULL_HANDLER,
66096 ZEND_NULL_HANDLER,
66097 ZEND_NULL_HANDLER,
66098 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66099 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66100 ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66101 ZEND_NULL_HANDLER,
66102 ZEND_NULL_HANDLER,
66103 ZEND_NULL_HANDLER,
66104 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66105 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66106 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66107 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66108 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66109 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66110 ZEND_NULL_HANDLER,
66111 ZEND_NULL_HANDLER,
66112 ZEND_NULL_HANDLER,
66113 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_HANDLER,
66114 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ_HANDLER,
66115 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ_HANDLER,
66116 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66117 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66118 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66119 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66120 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66121 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66122 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66123 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66124 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66125 ZEND_NULL_HANDLER,
66126 ZEND_NULL_HANDLER,
66127 ZEND_NULL_HANDLER,
66128 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66129 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66130 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66131 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66132 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66133 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66134 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66135 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66136 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66137 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66138 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66139 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66140 ZEND_NULL_HANDLER,
66141 ZEND_NULL_HANDLER,
66142 ZEND_NULL_HANDLER,
66143 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66144 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66145 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66146 ZEND_NULL_HANDLER,
66147 ZEND_NULL_HANDLER,
66148 ZEND_NULL_HANDLER,
66149 ZEND_NULL_HANDLER,
66150 ZEND_NULL_HANDLER,
66151 ZEND_NULL_HANDLER,
66152 ZEND_NULL_HANDLER,
66153 ZEND_NULL_HANDLER,
66154 ZEND_NULL_HANDLER,
66155 ZEND_NULL_HANDLER,
66156 ZEND_NULL_HANDLER,
66157 ZEND_NULL_HANDLER,
66158 ZEND_NULL_HANDLER,
66159 ZEND_NULL_HANDLER,
66160 ZEND_NULL_HANDLER,
66161 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_HANDLER,
66162 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ_HANDLER,
66163 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ_HANDLER,
66164 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66165 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66166 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66167 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66168 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66169 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66170 ZEND_NULL_HANDLER,
66171 ZEND_NULL_HANDLER,
66172 ZEND_NULL_HANDLER,
66173 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
66174 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
66175 ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
66176 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
66177 ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
66178 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
66179 ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
66180 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
66181 ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
66182 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
66183 ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
66184 ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
66185 ZEND_POST_INC_LONG_SPEC_CV_HANDLER,
66186 ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
66187 ZEND_POST_DEC_LONG_SPEC_CV_HANDLER,
66188 ZEND_QM_ASSIGN_LONG_SPEC_CONST_HANDLER,
66189 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
66190 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
66191 ZEND_NULL_HANDLER,
66192 ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER,
66193 ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER,
66194 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
66195 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
66196 ZEND_NULL_HANDLER,
66197 ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
66198 ZEND_QM_ASSIGN_NOREF_SPEC_CONST_HANDLER,
66199 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
66200 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
66201 ZEND_NULL_HANDLER,
66202 ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV_HANDLER,
66203 ZEND_NULL_HANDLER,
66204 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
66205 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
66206 ZEND_NULL_HANDLER,
66207 ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER,
66208 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
66209 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66210 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66211 ZEND_NULL_HANDLER,
66212 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66213 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER,
66214 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66215 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66216 ZEND_NULL_HANDLER,
66217 ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER,
66218 ZEND_NULL_HANDLER,
66219 ZEND_NULL_HANDLER,
66220 ZEND_NULL_HANDLER,
66221 ZEND_NULL_HANDLER,
66222 ZEND_NULL_HANDLER,
66223 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST_HANDLER,
66224 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
66225 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
66226 ZEND_NULL_HANDLER,
66227 ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER,
66228 ZEND_NULL_HANDLER,
66229 ZEND_NULL_HANDLER,
66230 ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER,
66231 ZEND_NULL_HANDLER,
66232 ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER,
66233 ZEND_NULL_HANDLER,
66234 ZEND_NULL_HANDLER,
66235 ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER,
66236 ZEND_NULL_HANDLER,
66237 ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER,
66238 ZEND_SEND_VAL_SIMPLE_SPEC_CONST_HANDLER,
66239 ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST_HANDLER,
66240 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER,
66241 ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED_HANDLER,
66242 ZEND_NULL_HANDLER
66243 };
66244 static const uint32_t specs[] = {
66245 0,
66246 1 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66247 26 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66248 51 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66249 76 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66250 101 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66251 126 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66252 151 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66253 176 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66254 201 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66255 226 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66256 251 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66257 276 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66258 301 | SPEC_RULE_OP1,
66259 306 | SPEC_RULE_OP1,
66260 311 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66261 336 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66262 361 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE,
66263 386 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
66264 461 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE,
66265 536 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
66266 611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH,
66267 686 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL,
66268 736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
66269 861 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
66270 986 | SPEC_RULE_OP_DATA,
66271 991 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66272 1016 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66273 1041 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66274 1066,
66275 1067 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66276 1092 | SPEC_RULE_OP1,
66277 1097 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
66278 1222,
66279 1223 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
66280 1233 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
66281 1243 | SPEC_RULE_OP1,
66282 1248 | SPEC_RULE_OP1,
66283 1253,
66284 1253,
66285 1254,
66286 1254,
66287 1255,
66288 1256 | SPEC_RULE_OP1,
66289 1261 | SPEC_RULE_OP1,
66290 3481,
66291 1266 | SPEC_RULE_OP1,
66292 1271 | SPEC_RULE_OP1,
66293 1276 | SPEC_RULE_OP2,
66294 1281,
66295 1282 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
66296 1292 | SPEC_RULE_OP1,
66297 1297 | SPEC_RULE_OP1,
66298 1302 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66299 1327 | SPEC_RULE_OP2,
66300 1332 | SPEC_RULE_OP2,
66301 1337 | SPEC_RULE_OP2,
66302 1342,
66303 1343,
66304 1344,
66305 1345 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
66306 1349,
66307 1350 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
66308 1360,
66309 1361,
66310 1362 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66311 1387 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
66312 1437 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66313 1462 | SPEC_RULE_OP1,
66314 1467,
66315 1468,
66316 1469 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66317 1494 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66318 1519 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
66319 1529 | SPEC_RULE_OP1,
66320 1534 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66321 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66322 1584 | SPEC_RULE_OP1,
66323 1589,
66324 1590,
66325 1591 | SPEC_RULE_OP1,
66326 1596 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66327 1621 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66328 1646 | SPEC_RULE_OP1,
66329 1651 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66330 1676 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66331 1701 | SPEC_RULE_OP1,
66332 1706 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66333 1731 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66334 1756 | SPEC_RULE_OP1,
66335 1761 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66336 1786 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66337 1811 | SPEC_RULE_OP1,
66338 1816 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66339 1841 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66340 1866 | SPEC_RULE_OP1,
66341 1871 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66342 1896 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66343 1921 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66344 1946,
66345 1947 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
66346 1957,
66347 1958,
66348 1959,
66349 1960,
66350 1961,
66351 1962 | SPEC_RULE_OP2,
66352 1967,
66353 1968 | SPEC_RULE_OP1,
66354 1973 | SPEC_RULE_OP2,
66355 1978 | SPEC_RULE_OP1,
66356 1983 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
66357 1993 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66358 2018 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66359 2043 | SPEC_RULE_OP1,
66360 2048 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66361 2073 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
66362 2123 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66363 2148 | SPEC_RULE_OP2,
66364 2153,
66365 2154 | SPEC_RULE_OP1,
66366 2159 | SPEC_RULE_OP1,
66367 2164,
66368 2165 | SPEC_RULE_OP1,
66369 2170 | SPEC_RULE_OP1,
66370 2175 | SPEC_RULE_OP1,
66371 2180,
66372 2181,
66373 2182 | SPEC_RULE_OP2,
66374 2187 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
66375 2191 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
66376 2195 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
66377 2199 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66378 2199 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66379 2224 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66380 2224 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66381 2249 | SPEC_RULE_OP1,
66382 2254,
66383 2255 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66384 2280,
66385 2281 | SPEC_RULE_OP1,
66386 2286,
66387 2287,
66388 2288,
66389 2289,
66390 2290,
66391 2291,
66392 2292,
66393 2293 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66394 2318,
66395 2319,
66396 2320,
66397 2321 | SPEC_RULE_OP1,
66398 2326,
66399 2327 | SPEC_RULE_ISSET,
66400 2329 | SPEC_RULE_OP2,
66401 2334,
66402 2335 | SPEC_RULE_OP1,
66403 2340 | SPEC_RULE_OBSERVER,
66404 2342,
66405 2343 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66406 2368 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
66407 2378,
66408 2379,
66409 2380,
66410 2381,
66411 2382 | SPEC_RULE_OP1,
66412 2387,
66413 2388,
66414 2389 | SPEC_RULE_OP1,
66415 2394 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66416 2419,
66417 2420 | SPEC_RULE_OP1,
66418 2425,
66419 2426,
66420 2427,
66421 2428,
66422 2429,
66423 2430,
66424 2431,
66425 2432,
66426 2433 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66427 2458,
66428 2459,
66429 2460,
66430 2461 | SPEC_RULE_OP2,
66431 2466,
66432 2467 | SPEC_RULE_OP1,
66433 2472 | SPEC_RULE_OP1,
66434 2477 | SPEC_RULE_OP1,
66435 2482 | SPEC_RULE_OP1,
66436 2487 | SPEC_RULE_OP1,
66437 2492,
66438 2493 | SPEC_RULE_OP1,
66439 2498 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66440 2523 | SPEC_RULE_OP1,
66441 2528 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
66442 2553 | SPEC_RULE_OP1,
66443 2558 | SPEC_RULE_OP1,
66444 2563,
66445 2564,
66446 2565,
66447 2566,
66448 2567,
66449 2568,
66450 2569,
66451 2570,
66452 2571,
66453 2572,
66454 3481,
66455 3481,
66456 3481,
66457 3481,
66458 3481,
66459 3481,
66460 3481,
66461 3481,
66462 3481,
66463 3481,
66464 3481,
66465 3481,
66466 3481,
66467 3481,
66468 3481,
66469 3481,
66470 3481,
66471 3481,
66472 3481,
66473 3481,
66474 3481,
66475 3481,
66476 3481,
66477 3481,
66478 3481,
66479 3481,
66480 3481,
66481 3481,
66482 3481,
66483 3481,
66484 3481,
66485 3481,
66486 3481,
66487 3481,
66488 3481,
66489 3481,
66490 3481,
66491 3481,
66492 3481,
66493 3481,
66494 3481,
66495 3481,
66496 3481,
66497 3481,
66498 3481,
66499 3481,
66500 3481,
66501 };
66502 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
66503 zend_opcode_handler_funcs = labels;
66504 zend_spec_handlers = specs;
66505 execute_ex(NULL);
66506 #else
66507 zend_opcode_handlers = labels;
66508 zend_handlers_count = sizeof(labels) / sizeof(void*);
66509 zend_spec_handlers = specs;
66510 #endif
66511 VM_TRACE_START();
66512 }
66513
66514 static HashTable *zend_handlers_table = NULL;
66515
66516 void zend_vm_dtor(void)
66517 {
66518 VM_TRACE_END();
66519 if (zend_handlers_table) {
66520 zend_hash_destroy(zend_handlers_table);
66521 free(zend_handlers_table);
66522 zend_handlers_table = NULL;
66523 }
66524 }
66525
66526 static void init_opcode_serialiser(void)
66527 {
66528 int i;
66529 zval tmp;
66530
66531 zend_handlers_table = malloc(sizeof(HashTable));
66532 zend_hash_init(zend_handlers_table, zend_handlers_count, NULL, NULL, 1);
66533 zend_hash_real_init(zend_handlers_table, 0);
66534 Z_TYPE_INFO(tmp) = IS_LONG;
66535 for (i = 0; i < zend_handlers_count; i++) {
66536 Z_LVAL(tmp) = i;
66537 zend_hash_index_add(zend_handlers_table, (zend_long)(uintptr_t)zend_opcode_handlers[i], &tmp);
66538 }
66539 }
66540
66541 ZEND_API void ZEND_FASTCALL zend_serialize_opcode_handler(zend_op *op)
66542 {
66543 zval *zv;
66544
66545 if (!zend_handlers_table) {
66546 init_opcode_serialiser();
66547 }
66548 zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
66549 ZEND_ASSERT(zv != NULL);
66550 op->handler = (const void *)(uintptr_t)Z_LVAL_P(zv);
66551 }
66552
66553 ZEND_API void ZEND_FASTCALL zend_deserialize_opcode_handler(zend_op *op)
66554 {
66555 op->handler = zend_opcode_handlers[(uintptr_t)op->handler];
66556 }
66557
66558 ZEND_API const void* ZEND_FASTCALL zend_get_opcode_handler_func(const zend_op *op)
66559 {
66560 #if ZEND_VM_KIND == ZEND_VM_KIND_CALL
66561 return op->handler;
66562 #elif ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
66563 zval *zv;
66564
66565 if (!zend_handlers_table) {
66566 init_opcode_serialiser();
66567 }
66568 zv = zend_hash_index_find(zend_handlers_table, (zend_long)(uintptr_t)op->handler);
66569 ZEND_ASSERT(zv != NULL);
66570 return zend_opcode_handler_funcs[Z_LVAL_P(zv)];
66571 #else
66572 return NULL;
66573 #endif
66574 }
66575
66576 ZEND_API const zend_op *zend_get_halt_op(void)
66577 {
66578 #if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
66579 return &hybrid_halt_op;
66580 #else
66581 return NULL;
66582 #endif
66583 }
66584
66585 ZEND_API int zend_vm_kind(void)
66586 {
66587 return ZEND_VM_KIND;
66588 }
66589
66590 static uint32_t ZEND_FASTCALL zend_vm_get_opcode_handler_idx(uint32_t spec, const zend_op* op)
66591 {
66592 static const int zend_vm_decode[] = {
66593 _UNUSED_CODE, /* 0 = IS_UNUSED */
66594 _CONST_CODE, /* 1 = IS_CONST */
66595 _TMP_CODE, /* 2 = IS_TMP_VAR */
66596 _UNUSED_CODE, /* 3 */
66597 _VAR_CODE, /* 4 = IS_VAR */
66598 _UNUSED_CODE, /* 5 */
66599 _UNUSED_CODE, /* 6 */
66600 _UNUSED_CODE, /* 7 */
66601 _CV_CODE /* 8 = IS_CV */
66602 };
66603 uint32_t offset = 0;
66604 if (spec & SPEC_RULE_OP1) offset = offset * 5 + zend_vm_decode[op->op1_type];
66605 if (spec & SPEC_RULE_OP2) offset = offset * 5 + zend_vm_decode[op->op2_type];
66606 if (spec & SPEC_EXTRA_MASK) {
66607 if (spec & SPEC_RULE_RETVAL) {
66608 offset = offset * 2 + (op->result_type != IS_UNUSED);
66609 if ((spec & SPEC_RULE_OBSERVER) && ZEND_OBSERVER_ENABLED) {
66610 offset += 2;
66611 }
66612 } else if (spec & SPEC_RULE_QUICK_ARG) {
66613 offset = offset * 2 + (op->op2.num <= MAX_ARG_FLAG_NUM);
66614 } else if (spec & SPEC_RULE_OP_DATA) {
66615 offset = offset * 5 + zend_vm_decode[(op + 1)->op1_type];
66616 } else if (spec & SPEC_RULE_ISSET) {
66617 offset = offset * 2 + (op->extended_value & ZEND_ISEMPTY);
66618 } else if (spec & SPEC_RULE_SMART_BRANCH) {
66619 offset = offset * 3;
66620 if (op->result_type == (IS_SMART_BRANCH_JMPZ|IS_TMP_VAR)) {
66621 offset += 1;
66622 } else if (op->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)) {
66623 offset += 2;
66624 }
66625 } else if (spec & SPEC_RULE_OBSERVER) {
66626 offset = offset * 2;
66627 if (ZEND_OBSERVER_ENABLED) {
66628 offset += 1;
66629 }
66630 }
66631 }
66632 return (spec & SPEC_START_MASK) + offset;
66633 }
66634
66635 #if (ZEND_VM_KIND != ZEND_VM_KIND_HYBRID) || !ZEND_VM_SPEC
66636 static const void *zend_vm_get_opcode_handler(uint8_t opcode, const zend_op* op)
66637 {
66638 return zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
66639 }
66640 #endif
66641
66642 #if ZEND_VM_KIND == ZEND_VM_KIND_HYBRID
66643 static const void *zend_vm_get_opcode_handler_func(uint8_t opcode, const zend_op* op)
66644 {
66645 uint32_t spec = zend_spec_handlers[opcode];
66646 return zend_opcode_handler_funcs[zend_vm_get_opcode_handler_idx(spec, op)];
66647 }
66648
66649 #endif
66650
66651 ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler(zend_op* op)
66652 {
66653 uint8_t opcode = zend_user_opcodes[op->opcode];
66654
66655 if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
66656 if (op->op1_type < op->op2_type) {
66657 zend_swap_operands(op);
66658 }
66659 }
66660 op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(zend_spec_handlers[opcode], op)];
66661 }
66662
66663 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)
66664 {
66665 uint8_t opcode = zend_user_opcodes[op->opcode];
66666 uint32_t spec = zend_spec_handlers[opcode];
66667 switch (opcode) {
66668 case ZEND_ADD:
66669 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66670 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66671 break;
66672 }
66673 spec = 2580 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66674 if (op->op1_type < op->op2_type) {
66675 zend_swap_operands(op);
66676 }
66677 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66678 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66679 break;
66680 }
66681 spec = 2605 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66682 if (op->op1_type < op->op2_type) {
66683 zend_swap_operands(op);
66684 }
66685 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66686 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66687 break;
66688 }
66689 spec = 2630 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66690 if (op->op1_type < op->op2_type) {
66691 zend_swap_operands(op);
66692 }
66693 }
66694 break;
66695 case ZEND_SUB:
66696 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66697 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66698 break;
66699 }
66700 spec = 2655 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
66701 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66702 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66703 break;
66704 }
66705 spec = 2680 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
66706 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66707 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66708 break;
66709 }
66710 spec = 2705 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
66711 }
66712 break;
66713 case ZEND_MUL:
66714 if (op->op1_type < op->op2_type) {
66715 zend_swap_operands(op);
66716 }
66717 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66718 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66719 break;
66720 }
66721 spec = 2730 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66722 } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66723 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66724 break;
66725 }
66726 spec = 2755 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66727 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66728 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66729 break;
66730 }
66731 spec = 2780 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66732 }
66733 break;
66734 case ZEND_IS_IDENTICAL:
66735 if (op->op1_type < op->op2_type) {
66736 zend_swap_operands(op);
66737 }
66738 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66739 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66740 break;
66741 }
66742 spec = 2805 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66743 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66744 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66745 break;
66746 }
66747 spec = 2880 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66748 } 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))) {
66749 spec = 3105 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66750 }
66751 break;
66752 case ZEND_IS_NOT_IDENTICAL:
66753 if (op->op1_type < op->op2_type) {
66754 zend_swap_operands(op);
66755 }
66756 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66757 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66758 break;
66759 }
66760 spec = 2955 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66761 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66762 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66763 break;
66764 }
66765 spec = 3030 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66766 } 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))) {
66767 spec = 3110 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
66768 }
66769 break;
66770 case ZEND_IS_EQUAL:
66771 if (op->op1_type < op->op2_type) {
66772 zend_swap_operands(op);
66773 }
66774 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66775 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66776 break;
66777 }
66778 spec = 2805 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66779 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66780 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66781 break;
66782 }
66783 spec = 2880 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66784 }
66785 break;
66786 case ZEND_IS_NOT_EQUAL:
66787 if (op->op1_type < op->op2_type) {
66788 zend_swap_operands(op);
66789 }
66790 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66791 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66792 break;
66793 }
66794 spec = 2955 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66795 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66796 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66797 break;
66798 }
66799 spec = 3030 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
66800 }
66801 break;
66802 case ZEND_IS_SMALLER:
66803 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66804 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66805 break;
66806 }
66807 spec = 3115 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
66808 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66809 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66810 break;
66811 }
66812 spec = 3190 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
66813 }
66814 break;
66815 case ZEND_IS_SMALLER_OR_EQUAL:
66816 if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
66817 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66818 break;
66819 }
66820 spec = 3265 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
66821 } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
66822 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66823 break;
66824 }
66825 spec = 3340 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
66826 }
66827 break;
66828 case ZEND_QM_ASSIGN:
66829 if (op1_info == MAY_BE_LONG) {
66830 spec = 3427 | SPEC_RULE_OP1;
66831 } else if (op1_info == MAY_BE_DOUBLE) {
66832 spec = 3432 | SPEC_RULE_OP1;
66833 } 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))))) {
66834 spec = 3437 | SPEC_RULE_OP1;
66835 }
66836 break;
66837 case ZEND_PRE_INC:
66838 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
66839 spec = 3415 | SPEC_RULE_RETVAL;
66840 } else if (op1_info == MAY_BE_LONG) {
66841 spec = 3417 | SPEC_RULE_RETVAL;
66842 }
66843 break;
66844 case ZEND_PRE_DEC:
66845 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
66846 spec = 3419 | SPEC_RULE_RETVAL;
66847 } else if (op1_info == MAY_BE_LONG) {
66848 spec = 3421 | SPEC_RULE_RETVAL;
66849 }
66850 break;
66851 case ZEND_POST_INC:
66852 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
66853 spec = 3423;
66854 } else if (op1_info == MAY_BE_LONG) {
66855 spec = 3424;
66856 }
66857 break;
66858 case ZEND_POST_DEC:
66859 if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
66860 spec = 3425;
66861 } else if (op1_info == MAY_BE_LONG) {
66862 spec = 3426;
66863 }
66864 break;
66865 case ZEND_JMP:
66866 if (OP_JMP_ADDR(op, op->op1) > op) {
66867 spec = 2579;
66868 }
66869 break;
66870 case ZEND_RECV:
66871 if (op->op2.num == MAY_BE_ANY) {
66872 spec = 2573;
66873 }
66874 break;
66875 case ZEND_SEND_VAL:
66876 if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
66877 spec = 3477;
66878 }
66879 break;
66880 case ZEND_SEND_VAR_EX:
66881 if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
66882 spec = 3472 | SPEC_RULE_OP1;
66883 }
66884 break;
66885 case ZEND_FE_FETCH_R:
66886 if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
66887 spec = 3479 | SPEC_RULE_RETVAL;
66888 }
66889 break;
66890 case ZEND_FETCH_DIM_R:
66891 if (!(op2_info & (MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF))) {
66892 if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
66893 break;
66894 }
66895 spec = 3442 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
66896 }
66897 break;
66898 case ZEND_SEND_VAL_EX:
66899 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))) {
66900 spec = 3478;
66901 }
66902 break;
66903 case ZEND_SEND_VAR:
66904 if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
66905 spec = 3467 | SPEC_RULE_OP1;
66906 }
66907 break;
66908 case ZEND_COUNT:
66909 if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) {
66910 spec = 2574 | SPEC_RULE_OP1;
66911 }
66912 break;
66913 case ZEND_BW_OR:
66914 case ZEND_BW_AND:
66915 case ZEND_BW_XOR:
66916 case ZEND_BOOL_XOR:
66917 if (op->op1_type < op->op2_type) {
66918 zend_swap_operands(op);
66919 }
66920 break;
66921 case ZEND_USER_OPCODE:
66922 if (zend_spec_handlers[op->opcode] & SPEC_RULE_COMMUTATIVE) {
66923 if (op->op1_type < op->op2_type) {
66924 zend_swap_operands(op);
66925 }
66926 }
66927 break;
66928 default:
66929 break;
66930 }
66931 op->handler = zend_opcode_handlers[zend_vm_get_opcode_handler_idx(spec, op)];
66932 }
66933
66934 ZEND_API int ZEND_FASTCALL zend_vm_call_opcode_handler(zend_execute_data* ex)
66935 {
66936 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
66937 opcode_handler_t handler;
66938 #endif
66939 int ret;
66940 #ifdef ZEND_VM_IP_GLOBAL_REG
66941 const zend_op *orig_opline = opline;
66942 #endif
66943 #ifdef ZEND_VM_FP_GLOBAL_REG
66944 zend_execute_data *orig_execute_data = execute_data;
66945 execute_data = ex;
66946 #else
66947 zend_execute_data *execute_data = ex;
66948 #endif
66949
66950 LOAD_OPLINE();
66951 #if defined(ZEND_VM_FP_GLOBAL_REG) && defined(ZEND_VM_IP_GLOBAL_REG)
66952 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
66953 handler = (opcode_handler_t)zend_vm_get_opcode_handler_func(zend_user_opcodes[opline->opcode], opline);
66954 handler(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
66955 if (EXPECTED(opline != &hybrid_halt_op)) {
66956 #else
66957 ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
66958 if (EXPECTED(opline)) {
66959 #endif
66960 ret = execute_data != ex ? (int)(execute_data->prev_execute_data != ex) + 1 : 0;
66961 SAVE_OPLINE();
66962 } else {
66963 ret = -1;
66964 }
66965 #else
66966 ret = ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
66967 SAVE_OPLINE();
66968 #endif
66969 #ifdef ZEND_VM_FP_GLOBAL_REG
66970 execute_data = orig_execute_data;
66971 #endif
66972 #ifdef ZEND_VM_IP_GLOBAL_REG
66973 opline = orig_opline;
66974 #endif
66975 return ret;
66976 }
66977
66978
